wikiparser-node 1.11.0-b → 1.11.0

package/dist/addon/token.js

@@ -0,0 +1,304 @@
+"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 (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].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 字符串
+ */
+const implicitNewLine = (str) => /^(?:\{\||[:;#*])/u.test(str) ? `\n${str}` : str;
+/**
+ * 展开模板
+ * @param wikitext
+ * @param config
+ * @param include
+ * @param context 模板调用环境
+ * @param accum
+ * @throws `Error` not root token
+ */
+const expand = (wikitext, config, include, context, accum = []) => {
+    const magicWords = new Set(['if', 'ifeq', 'switch']), n = accum.length, token = new index_2.Token(wikitext, config, accum);
+    token.type = 'root';
+    token.parseOnce(0, include);
+    if (context) {
+        token.setText((0, string_1.removeComment)(token.firstChild.toString()));
+    }
+    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(/\0(\d+)t\x7F/gu, (m, i) => {
+            const target = accum[i], { type, name, length, firstChild: f } = target;
+            if (type === 'arg') {
+                const arg = (0, string_1.removeComment)(f.toString()).trim();
+                if (context === undefined || /\0\d+t\x7F/u.test(arg)) {
+                    return m;
+                }
+                else if (context === false || !context.hasArg(arg)) {
+                    const effective = target.childNodes[1] ?? target;
+                    // @ts-expect-error sparse array
+                    accum[accum.indexOf(effective)] = undefined;
+                    return effective.toString();
+                }
+                // @ts-expect-error sparse array
+                accum[accum.indexOf(context.getArg(arg).lastChild)] = undefined;
+                return context.getValue(arg);
+            }
+            else if (type === 'template') {
+                if (context === false) {
+                    return m;
+                }
+                const c = target.getAttribute('config'), { title } = index_1.default.normalizeTitle((0, string_1.removeComment)(f.toString()), 10, include, c, true);
+                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 file = ['.wiki', '.txt', ''].map(ext => path.join(index_1.default.templateDir, title + ext))
+                        .find(fs.existsSync);
+                    if (!file) {
+                        return m;
+                    }
+                    index_1.default.templates.set(title, fs.readFileSync(file, 'utf8'));
+                }
+                return implicitNewLine(expand(index_1.default.templates.get(title), config, true, target, accum).toString());
+            }
+            else if (!magicWords.has(name)) {
+                return m;
+            }
+            else if (length < 3 || name === 'ifeq' && length === 3) {
+                return '';
+            }
+            const c = target.childNodes, var1 = c[1].value, var2 = c[2].value, known = !/\0\d+t\x7F/u.test(var1);
+            if (name === 'if' && known) {
+                const effective = c[var1 ? 2 : 3];
+                if (effective) {
+                    // @ts-expect-error sparse array
+                    accum[accum.indexOf(effective.lastChild)] = undefined;
+                    return implicitNewLine(effective.value);
+                }
+                return '';
+            }
+            else if (name === 'ifeq' && known && !/\0\d+t\x7F/u.test(var2)) {
+                const effective = c[var1 === var2 ? 3 : 4];
+                if (effective) {
+                    // @ts-expect-error sparse array
+                    accum[accum.indexOf(effective.lastChild)] = undefined;
+                    return implicitNewLine(effective.value);
+                }
+                return '';
+            }
+            else if (name === 'switch' && known) {
+                let defaultVal = '', found = false, transclusion = false, defaultParam;
+                for (let j = 2; j < length; j++) {
+                    const { anon, value, firstChild, lastChild } = c[j], option = (0, string_1.trimPHP)((0, string_1.removeComment)(firstChild.toString()));
+                    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);
+                        }
+                        else if (transclusion) {
+                            break;
+                        }
+                        else {
+                            found ||= var1 === value;
+                        }
+                    }
+                    else if (transclusion) {
+                        break;
+                    }
+                    else if (found || option === var1) {
+                        // @ts-expect-error sparse array
+                        accum[accum.indexOf(lastChild)] = undefined;
+                        return implicitNewLine(value);
+                    }
+                    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);
+                    }
+                }
+            }
+            return m;
+        });
+        plain.setText(expanded);
+        if (plain.type === 'parameter-key') {
+            plain.parentNode.trimName((0, string_1.removeComment)(expanded));
+        }
+    }
+    return token;
+};
+index_2.Token.prototype.expand = /** @implements */ function (context) {
+    if (this.type !== 'root') {
+        throw new Error('Only root token can be expanded!');
+    }
+    return debug_1.Shadow.run(() => expand(this.toString(), this.getAttribute('config'), this.getAttribute('include'), context).parse());
+};
+index_2.Token.prototype.solveConst = /** @implements */ function () {
+    if (this.type !== 'root') {
+        throw new Error('Only root token can be expanded!');
+    }
+    return debug_1.Shadow.run(() => expand(this.toString(), this.getAttribute('config'), this.getAttribute('include'), false).parse());
+};
+constants_1.classes['ExtendedTableToken'] = __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 (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].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,81 @@
+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[]];
+    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 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;
+    childNodes?: AST[];
+};
+/** 类似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, config?: Config): Token;
+}
+export {};

package/dist/base.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = void 0;
+exports.rules = [
+    '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',
+];

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import type { Config, LintError, Parser as ParserBase } from './base';
+import type { Title } from './lib/title';
+import type { Token } from './internal';
+declare interface Parser extends ParserBase {
+    rules: readonly LintError.Rule[];
+    viewOnly: boolean;
+    conversionTable: Map<string, string>;
+    redirects: Map<string, string>;
+    templateDir?: string;
+    templates: Map<string, string>;
+    warning: boolean;
+    debugging: boolean;
+    /**
+     * 规范化页面标题
+     * @param title 标题（含或不含命名空间前缀）
+     * @param defaultNs 命名空间
+     * @param include 是否嵌入
+     */
+    normalizeTitle(title: string, defaultNs?: number, include?: boolean, config?: Config): Title;
+    parse(wikitext: string, include?: boolean, maxStage?: number, config?: Config): Token;
+    /**
+     * 是否是跨维基链接
+     * @param title 链接标题
+     */
+    isInterwiki(title: string, config?: Config): RegExpExecArray | null;
+}
+declare const Parser: Parser;
+// @ts-expect-error mixed export styles
+export = Parser;
+export default Parser;
+export type { Config, LintError };
+export type * from './internal';
+declare global { type Acceptable = unknown; }