wikiparser-node 1.13.1-b → 1.13.1

package/dist/addon/token.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const constants_1 = require("../util/constants");
+const debug_1 = require("../util/debug");
+const string_1 = require("../util/string");
+const index_1 = require("../index");
+const index_2 = require("../src/index");
+const comment_1 = require("../src/nowiki/comment");
+const include_1 = require("../src/tagPair/include");
+const ext_1 = require("../src/tagPair/ext");
+const html_1 = require("../src/html");
+const attributes_1 = require("../src/attributes");
+index_2.Token.prototype.createComment = /** @implements */ function (data = '') {
+    const config = this.getAttribute('config');
+    // @ts-expect-error abstract class
+    return debug_1.Shadow.run(() => new comment_1.CommentToken(data.replaceAll('-->', '-->'), true, config));
+};
+index_2.Token.prototype.createElement = /** @implements */ function (tagName, { selfClosing, closing } = {}) {
+    const config = this.getAttribute('config'), include = this.getAttribute('include');
+    if (tagName === (include ? 'noinclude' : 'includeonly')) {
+        return debug_1.Shadow.run(
+        // @ts-expect-error abstract class
+        () => new include_1.IncludeToken(tagName, '', undefined, selfClosing ? undefined : tagName, config));
+    }
+    else if (config.ext.includes(tagName)) {
+        // @ts-expect-error abstract class
+        return debug_1.Shadow.run(() => new ext_1.ExtToken(tagName, '', undefined, selfClosing ? undefined : '', config));
+    }
+    else if (config.html.some(tags => tags.includes(tagName))) {
+        return debug_1.Shadow.run(() => {
+            // @ts-expect-error abstract class
+            const attr = new attributes_1.AttributesToken(undefined, 'html-attrs', tagName, config);
+            attr.afterBuild();
+            // @ts-expect-error abstract class
+            return new html_1.HtmlToken(tagName, attr, Boolean(closing), Boolean(selfClosing), config);
+        });
+    }
+    throw new RangeError(`Invalid tag name: ${tagName}`);
+};
+index_2.Token.prototype.caretPositionFromIndex = /** @implements */ function (index) {
+    if (index === undefined) {
+        return undefined;
+    }
+    const { length } = this.toString();
+    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 = cur.toString().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 };
+};
+index_2.Token.prototype.sections = /** @implements */ function () {
+    if (this.type !== 'root') {
+        return undefined;
+    }
+    const { childNodes, length } = this, headings = [...childNodes.entries()]
+        .filter((entry) => entry[1].type === 'heading')
+        .map(([i, { level }]) => [i, level]), lastHeading = [-1, -1, -1, -1, -1, -1], sections = headings.map(([i]) => {
+        const range = this.createRange();
+        range.setStart(this, i);
+        return range;
+    });
+    for (const [i, [index, level]] of headings.entries()) {
+        for (let j = level; j < 6; j++) {
+            const last = lastHeading[j];
+            if (last >= 0) {
+                sections[last].setEnd(this, index);
+            }
+            lastHeading[j] = j === level ? i : -1;
+        }
+    }
+    for (const last of lastHeading) {
+        if (last >= 0) {
+            sections[last].setEnd(this, length);
+        }
+    }
+    const range = this.createRange();
+    range.setStart(this, 0);
+    range.setEnd(this, headings[0]?.[0] ?? length);
+    sections.unshift(range);
+    return sections;
+};
+index_2.Token.prototype.findEnclosingHtml = /** @implements */ function (tag) {
+    tag = tag?.toLowerCase();
+    const { html } = this.getAttribute('config'), normalTags = new Set(html[0]), voidTags = new Set(html[2]);
+    if (html[2].includes(tag)) {
+        throw new RangeError(`Void tag: ${tag}`);
+    }
+    else if (tag !== undefined && !html.slice(0, 2).some(tags => tags.includes(tag))) {
+        throw new RangeError(`Invalid tag name: ${tag}`);
+    }
+    const { parentNode } = this;
+    if (!parentNode) {
+        return undefined;
+    }
+    /**
+     * 检查是否为指定的 HTML 标签
+     * @param node 节点
+     * @param name 标签名
+     * @param closing 是否为闭合标签
+     */
+    const checkHtml = (node, name, closing) => node.is('html')
+        && (!name && !voidTags.has(node.name) || node.name === name)
+        && (normalTags.has(node.name) || !node.selfClosing)
+        && node.closing === closing;
+    const { childNodes, length } = parentNode, index = childNodes.indexOf(this);
+    let i = index - 1, j = length;
+    for (; i >= 0; i--) {
+        const open = childNodes[i];
+        if (checkHtml(open, tag, false)) {
+            for (j = index + 1; j < length; j++) {
+                const close = childNodes[j];
+                if (checkHtml(close, open.name, true)) {
+                    break;
+                }
+            }
+            if (j < length) {
+                break;
+            }
+        }
+    }
+    if (i === -1) {
+        return parentNode.findEnclosingHtml(tag);
+    }
+    const range = this.createRange();
+    range.setStart(parentNode, i);
+    range.setEnd(parentNode, j + 1);
+    return range;
+};
+/**
+ * 隐式换行
+ * @param str 字符串
+ * @param prev 前一个字符
+ */
+const implicitNewLine = (str, prev) => prev + (prev !== '\n' && /^(?:\{\||[:;#*])/u.test(str) ? `\n${str}` : str);
+/**
+ * 比较两个字符串是否相等
+ * @param a
+ * @param b
+ */
+const cmp = (a, b) => a === b || Boolean(a && b) && Number(a) === Number(b);
+/**
+ * 展开模板
+ * @param wikitext
+ * @param config
+ * @param include
+ * @param context 模板调用环境
+ * @param accum
+ * @param stack 模板调用栈
+ */
+const expand = (wikitext, config, include, context, accum = [], stack = []) => {
+    const magicWords = new Set(['if', 'ifeq', 'ifexist', 'switch']), n = accum.length, token = new index_2.Token(wikitext, config, accum);
+    token.type = 'root';
+    token.parseOnce(0, include);
+    if (context !== false) {
+        token.setText((0, string_1.removeCommentLine)(token.firstChild.toString(), true));
+    }
+    token.parseOnce();
+    for (const plain of [...accum.slice(n), token]) {
+        if (plain.length !== 1 || plain.firstChild.type !== 'text') {
+            continue;
+        }
+        const { data } = plain.firstChild;
+        if (!/\0\d+t\x7F/u.test(data)) {
+            continue;
+        }
+        const expanded = data.replace(/([^\x7F]?)\0(\d+)t\x7F/gu, (m, prev, i) => {
+            const target = accum[i], { type, name, length, firstChild: f } = target;
+            if (type === 'arg') {
+                const arg = (0, string_1.removeCommentLine)(f.toString()).trim();
+                if (/\0\d+t\x7F/u.test(arg)) {
+                    return m;
+                }
+                else if (!context || !context.hasArg(arg)) {
+                    const effective = target.childNodes[1] ?? target;
+                    // @ts-expect-error sparse array
+                    accum[accum.indexOf(length === 1 ? f : effective)] = undefined;
+                    return prev + effective.toString();
+                }
+                // @ts-expect-error sparse array
+                accum[accum.indexOf(context.getArg(arg).lastChild)] = undefined;
+                return prev + context.getValue(arg);
+            }
+            else if (type === 'template') {
+                if (context === false) {
+                    return m;
+                }
+                const c = target.getAttribute('config'), t = index_1.default.normalizeTitle((0, string_1.removeComment)(f.toString()), 10, include, c, true), { title, valid } = t;
+                if (!valid) {
+                    // @ts-expect-error sparse array
+                    accum[accum.indexOf(target)] = undefined;
+                    // @ts-expect-error sparse array
+                    accum[accum.indexOf(f)] = undefined;
+                    return prev + target.toString();
+                }
+                else if (!index_1.default.templates.has(title)) {
+                    if (index_1.default.templateDir === undefined) {
+                        return m;
+                    }
+                    else if (!path.isAbsolute(index_1.default.templateDir)) {
+                        index_1.default.templateDir = path.join(__dirname, '..', '..', index_1.default.templateDir);
+                    }
+                    const titles = [title, title.replaceAll('_', ' ')].flatMap(tt => [tt, tt.replaceAll(':', '꞉')]), file = ['.wiki', '.txt', '']
+                        .flatMap(ext => titles.map(tt => path.join(index_1.default.templateDir, tt + ext)))
+                        .find(fs.existsSync);
+                    if (!file) {
+                        return m;
+                    }
+                    index_1.default.templates.set(title, fs.readFileSync(file, 'utf8'));
+                }
+                else if (stack.includes(title)) {
+                    return `${prev}<span class="error">Template loop detected: [[${title}]]</span>`;
+                }
+                return implicitNewLine(expand(index_1.default.templates.get(title), config, true, target, accum, [...stack, title]).toString(), prev);
+            }
+            else if (!magicWords.has(name)) {
+                return m;
+            }
+            else if (length < 3 || name === 'ifeq' && length === 3) {
+                return prev;
+            }
+            const c = target.childNodes, var1 = (0, string_1.decodeHtml)(c[1].value), var2 = (0, string_1.decodeHtml)(c[2].value), known = !/\0\d+t\x7F/u.test(var1);
+            if (known && (name === 'if' || name === 'ifexist')) {
+                let bool = Boolean(var1);
+                if (name === 'ifexist') {
+                    const title = index_1.default.normalizeTitle(var1, 0, include, config, true);
+                    bool = title.valid && !title.interwiki;
+                }
+                const effective = c[bool ? 2 : 3];
+                if (effective) {
+                    // @ts-expect-error sparse array
+                    accum[accum.indexOf(effective.lastChild)] = undefined;
+                    return implicitNewLine(effective.value, prev);
+                }
+                return prev;
+            }
+            else if (known && name === 'ifeq' && !/\0\d+t\x7F/u.test(var2)) {
+                const effective = c[cmp(var1, var2) ? 3 : 4];
+                if (effective) {
+                    // @ts-expect-error sparse array
+                    accum[accum.indexOf(effective.lastChild)] = undefined;
+                    return implicitNewLine(effective.value, prev);
+                }
+                return prev;
+            }
+            else if (known && name === 'switch') {
+                let defaultVal = '', found = false, transclusion = false, defaultParam;
+                for (let j = 2; j < length; j++) {
+                    const { anon, value, lastChild, name: option } = c[j];
+                    transclusion = /\0\d+t\x7F/u.test(anon ? value : option);
+                    if (anon) {
+                        if (j === length - 1) {
+                            // @ts-expect-error sparse array
+                            accum[accum.indexOf(lastChild)] = undefined;
+                            return implicitNewLine(value, prev);
+                        }
+                        else if (transclusion) {
+                            break;
+                        }
+                        else {
+                            found ||= cmp(var1, (0, string_1.decodeHtml)(value)) || value === '#default';
+                        }
+                    }
+                    else if (transclusion) {
+                        break;
+                    }
+                    else if (found || cmp(var1, (0, string_1.decodeHtml)(option))) {
+                        // @ts-expect-error sparse array
+                        accum[accum.indexOf(lastChild)] = undefined;
+                        return implicitNewLine(value, prev);
+                    }
+                    else if (option.toLowerCase() === '#default') {
+                        defaultVal = value;
+                        defaultParam = lastChild;
+                    }
+                    if (j === length - 1) {
+                        if (defaultParam) {
+                            // @ts-expect-error sparse array
+                            accum[accum.indexOf(defaultParam)] = undefined;
+                        }
+                        return implicitNewLine(defaultVal, prev);
+                    }
+                }
+            }
+            return m;
+        });
+        plain.setText(expanded);
+        if (plain.type === 'parameter-key') {
+            plain.parentNode.trimName((0, string_1.removeCommentLine)(expanded));
+        }
+    }
+    return token;
+};
+index_2.Token.prototype.expand = /** @implements */ function () {
+    return debug_1.Shadow.run(() => expand(this.toString(), this.getAttribute('config'), this.getAttribute('include')).parse());
+};
+index_2.Token.prototype.solveConst = /** @implements */ function () {
+    return debug_1.Shadow.run(() => expand(this.toString(), this.getAttribute('config'), this.getAttribute('include'), false).parse());
+};
+index_2.Token.prototype.toHtml = /** @implements */ function () {
+    if (this.type !== 'root') {
+        return this.cloneNode().toHtmlInternal();
+    }
+    const expanded = this.expand();
+    constants_1.states.set(expanded, { headings: new Set() });
+    const lines = expanded.toHtmlInternal().split('\n'), blockElems = 'table|h1|h2|h3|h4|h5|h6|pre|p|ul|ol|dl', antiBlockElems = 'td|th', openRegex = new RegExp(String.raw `<(?:${blockElems}|\/(?:${antiBlockElems})|\/?(?:tr|caption|dt|dd|li))\b`, 'iu'), closeRegex = new RegExp(String.raw `<(?:\/(?:${blockElems})|${antiBlockElems}|\/?(?:center|blockquote|div|hr|figure))\b`, 'iu');
+    let output = '', inBlockElem = false, pendingPTag = false, inBlockquote = false, lastParagraph = '';
+    const /** @ignore */ closeParagraph = () => {
+        if (lastParagraph) {
+            const result = `</${lastParagraph}>\n`;
+            lastParagraph = '';
+            return result;
+        }
+        return '';
+    };
+    for (let line of lines) {
+        const openMatch = openRegex.test(line), closeMatch = closeRegex.test(line);
+        if (openMatch || closeMatch) {
+            const blockquote = /<(\/?)blockquote[\s>](?!.*<\/?blockquote[\s>])/iu.exec(line)?.[1];
+            inBlockquote = blockquote === undefined ? inBlockquote : blockquote === '';
+            pendingPTag = false;
+            output += closeParagraph();
+            inBlockElem = !closeMatch;
+        }
+        else if (!inBlockElem) {
+            if (line.startsWith(' ') && (lastParagraph === 'pre' || line.trim()) && !inBlockquote) {
+                if (lastParagraph !== 'pre') {
+                    pendingPTag = false;
+                    output += `${closeParagraph()}<pre>`;
+                    lastParagraph = 'pre';
+                }
+                line = line.slice(1);
+            }
+            else if (/^(?:<link\b[^>]*>\s*)+$/iu.test(line)) {
+                if (pendingPTag) {
+                    output += closeParagraph();
+                    pendingPTag = false;
+                }
+            }
+            else if (!line.trim()) {
+                if (pendingPTag) {
+                    output += `${pendingPTag}<br>`;
+                    pendingPTag = false;
+                    lastParagraph = 'p';
+                }
+                else if (lastParagraph === 'p') {
+                    pendingPTag = '</p><p>';
+                }
+                else {
+                    output += closeParagraph();
+                    pendingPTag = '<p>';
+                }
+            }
+            else if (pendingPTag) {
+                output += pendingPTag;
+                pendingPTag = false;
+                lastParagraph = 'p';
+            }
+            else if (lastParagraph !== 'p') {
+                output += `${closeParagraph()}<p>`;
+                lastParagraph = 'p';
+            }
+        }
+        if (!pendingPTag) {
+            output += `${line}\n`;
+        }
+    }
+    output += closeParagraph();
+    constants_1.states.delete(expanded);
+    return output.trimEnd();
+};
+constants_1.classes['ExtendedToken'] = __filename;

package/dist/addon/transclude.js

@@ -0,0 +1,184 @@
+"use strict";
+/* eslint @stylistic/operator-linebreak: [2, "before", {overrides: {"=": "after"}}] */
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../util/constants");
+const debug_1 = require("../util/debug");
+const string_1 = require("../util/string");
+const index_1 = require("../index");
+const index_2 = require("../src/index");
+const transclude_1 = require("../src/transclude");
+const parameter_1 = require("../src/parameter");
+const atom_1 = require("../src/atom");
+transclude_1.TranscludeToken.prototype.newAnonArg =
+    /** @implements */
+    function (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);
+    };
+transclude_1.TranscludeToken.prototype.setValue =
+    /** @implements */
+    function (key, value) {
+        if (!this.isTemplate()) {
+            throw new Error('TranscludeToken.setValue method is only for templates!');
+        }
+        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);
+    };
+transclude_1.TranscludeToken.prototype.replaceTemplate =
+    /** @implements */
+    function (title) {
+        if (this.type === 'magic-word') {
+            throw new Error('TranscludeToken.replaceTemplate method is only for templates!');
+        }
+        const { childNodes } = index_1.default.parse(title, this.getAttribute('include'), 2, this.getAttribute('config'));
+        this.firstChild.replaceChildren(...childNodes);
+    };
+transclude_1.TranscludeToken.prototype.replaceModule =
+    /** @implements */
+    function (title) {
+        if (this.type !== 'magic-word' || this.name !== 'invoke') {
+            throw new Error('TranscludeToken.replaceModule method is only for modules!');
+        }
+        const config = this.getAttribute('config');
+        if (this.length === 1) {
+            index_2.Token.prototype.insertAt.call(this, debug_1.Shadow.run(() => 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);
+    };
+transclude_1.TranscludeToken.prototype.replaceFunction =
+    /** @implements */
+    function (func) {
+        if (this.type !== 'magic-word' || this.name !== 'invoke') {
+            throw new Error('TranscludeToken.replaceModule method is only for modules!');
+        }
+        else if (this.length < 2) {
+            throw new Error('No module name specified!');
+        }
+        const config = this.getAttribute('config');
+        if (this.length === 2) {
+            index_2.Token.prototype.insertAt.call(this, debug_1.Shadow.run(() => 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);
+    };
+transclude_1.TranscludeToken.prototype.fixDuplication =
+    /** @implements */
+    function (aggressive) {
+        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 || !key.trim() || isNaN(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 @typescript-eslint/no-unused-expressions
+                /^a\d+$/u;
+                const str = key.slice(0, -/(?<!\d)\d+$/u.exec(key)[0].length), regex = new RegExp(String.raw `^${(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 (const [i, arg] of series.entries()) {
+                        const name = `${str}${i + 1}`;
+                        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].toString(true), 828)
+                        .title} still has ${remaining} duplicated ${key} parameters:\n${[...this.getArgs(key)].map(arg => {
+                    const { top, left } = arg.getBoundingClientRect();
+                    return `Line ${String(top)} Column ${String(left)}`;
+                }).join('\n')}`);
+                duplicatedKeys.push(key);
+                continue;
+            }
+        }
+        return duplicatedKeys;
+    };
+transclude_1.TranscludeToken.prototype.escapeTables =
+    /** @implements */
+    function () {
+        if (!/\n[^\S\n]*(?::+[^\S\n]*)?\{\|/u.test(this.text())) {
+            return this;
+        }
+        const stripped = this.toString().slice(2, -2), include = this.getAttribute('include'), config = this.getAttribute('config'), parsed = index_1.default.parse(stripped, include, 4, config);
+        for (const table of parsed.childNodes) {
+            if (table.is('table')) {
+                table.escape();
+            }
+        }
+        const { firstChild, length } = index_1.default.parse(`{{${parsed.toString()}}}`, include, undefined, config);
+        if (length !== 1 || !(firstChild instanceof transclude_1.TranscludeToken)) {
+            throw new Error('Failed to escape tables!');
+        }
+        this.safeReplaceWith(firstChild);
+        return firstChild;
+    };
+constants_1.classes['ExtendedTranscludeToken'] = __filename;

package/dist/base.d.ts

@@ -0,0 +1,110 @@
+export interface Config {
+    ext: string[];
+    readonly html: [string[], string[], string[]];
+    readonly namespaces: Record<string, string>;
+    readonly nsid: Record<string, number>;
+    readonly parserFunction: [Record<string, string>, string[], string[], string[]];
+    readonly doubleUnderscore: [string[], string[], Record<string, string>?];
+    readonly protocol: string;
+    readonly img: Record<string, string>;
+    readonly redirection: string[];
+    readonly variants: string[];
+    readonly excludes?: string[];
+    readonly interwiki: string[];
+    readonly conversionTable?: [string, string][];
+    readonly redirects?: [string, string][];
+    readonly articlePath?: string;
+}
+export type TokenTypes = 'root' | 'plain' | 'redirect' | 'redirect-syntax' | 'redirect-target' | 'onlyinclude' | 'noinclude' | 'include' | 'comment' | 'ext' | 'ext-attrs' | 'ext-attr-dirty' | 'ext-attr' | 'attr-key' | 'attr-value' | 'ext-inner' | 'arg' | 'arg-name' | 'arg-default' | 'hidden' | 'magic-word' | 'magic-word-name' | 'invoke-function' | 'invoke-module' | 'template' | 'template-name' | 'parameter' | 'parameter-key' | 'parameter-value' | 'heading' | 'heading-title' | 'heading-trail' | 'html' | 'html-attrs' | 'html-attr-dirty' | 'html-attr' | 'table' | 'tr' | 'td' | 'table-syntax' | 'table-attrs' | 'table-attr-dirty' | 'table-attr' | 'table-inter' | 'td-inner' | 'hr' | 'double-underscore' | 'link' | 'link-target' | 'link-text' | 'category' | 'file' | 'gallery-image' | 'imagemap-image' | 'image-parameter' | 'quote' | 'ext-link' | 'ext-link-text' | 'ext-link-url' | 'free-ext-link' | 'magic-link' | 'list' | 'dd' | 'list-range' | 'converter' | 'converter-flags' | 'converter-flag' | 'converter-rule' | 'converter-rule-variant' | 'converter-rule-to' | 'converter-rule-from' | 'param-line' | 'imagemap-link';
+export declare const stages: {
+    redirect: number;
+    onlyinclude: number;
+    noinclude: number;
+    include: number;
+    comment: number;
+    ext: number;
+    arg: number;
+    'magic-word': number;
+    template: number;
+    heading: number;
+    html: number;
+    table: number;
+    hr: number;
+    'double-underscore': number;
+    link: number;
+    category: number;
+    file: number;
+    quote: number;
+    'ext-link': number;
+    'free-ext-link': number;
+    'magic-link': number;
+    list: number;
+    dd: number;
+    converter: number;
+};
+export type Stage = keyof typeof stages;
+export declare const rules: readonly ["bold-header", "format-leakage", "fostered-content", "h1", "illegal-attr", "insecure-style", "invalid-gallery", "invalid-imagemap", "invalid-invoke", "invalid-isbn", "lonely-apos", "lonely-bracket", "lonely-http", "nested-link", "no-arg", "no-duplicate", "no-ignored", "obsolete-attr", "obsolete-tag", "parsing-order", "pipe-like", "table-layout", "tag-like", "unbalanced-header", "unclosed-comment", "unclosed-quote", "unclosed-table", "unescaped", "unknown-page", "unmatched-tag", "unterminated-url", "url-encoding", "var-anchor", "void-ext"];
+export declare namespace LintError {
+    type Severity = 'error' | 'warning';
+    type Rule = typeof rules[number];
+    interface Fix {
+        readonly range: [number, number];
+        text: string;
+    }
+}
+export interface LintError {
+    rule: LintError.Rule;
+    message: string;
+    severity: LintError.Severity;
+    startIndex: number;
+    endIndex: number;
+    startLine: number;
+    startCol: number;
+    endLine: number;
+    endCol: number;
+    fix?: LintError.Fix;
+    suggestions?: (LintError.Fix & {
+        desc: string;
+    })[];
+}
+export type AST = Record<string, string | number | boolean> & {
+    range: [number, number];
+    type?: TokenTypes;
+    name?: string;
+    childNodes?: AST[];
+    data?: string;
+};
+/** 类似Node */
+export interface AstNode {
+    readonly childNodes: readonly AstNode[];
+    /** 节点类型 */
+    type: string;
+    /** Linter */
+    lint(): LintError[];
+    /** 以HTML格式打印 */
+    print(): string;
+}
+/** 所有节点的基类 */
+interface Token extends AstNode {
+    readonly name?: string;
+    /**
+     * 符合选择器的所有后代节点
+     * @param selector 选择器
+     */
+    querySelectorAll<T = Token>(selector: string): T[];
+    /** 保存为JSON */
+    json(): AST;
+}
+export interface Parser {
+    config: Config | string;
+    i18n: Record<string, string> | string | undefined;
+    /** 获取当前的解析设置 */
+    getConfig(): Config;
+    /**
+     * 解析wikitext
+     * @param include 是否嵌入
+     * @param maxStage 最大解析层级
+     */
+    parse(wikitext: string, include?: boolean, maxStage?: number | Stage | Stage[], config?: Config): Token;
+}
+export {};