wikiparser-node 1.13.1-b → 1.13.1

package/dist/base.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = exports.stages = void 0;
+exports.stages = {
+    redirect: 1,
+    onlyinclude: 1,
+    noinclude: 1,
+    include: 1,
+    comment: 1,
+    ext: 1,
+    arg: 2,
+    'magic-word': 2,
+    template: 2,
+    heading: 2,
+    html: 3,
+    table: 4,
+    hr: 5,
+    'double-underscore': 5,
+    link: 6,
+    category: 6,
+    file: 6,
+    quote: 7,
+    'ext-link': 8,
+    'free-ext-link': 9,
+    'magic-link': 9,
+    list: 10,
+    dd: 10,
+    converter: 11,
+};
+Object.setPrototypeOf(exports.stages, null);
+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',
+];
+Object.freeze(exports.rules);

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import type { Config, LintError, TokenTypes, Parser as ParserBase, Stage } 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 | Stage | Stage[], 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, TokenTypes };
+export type * from './internal';
+declare global { type Acceptable = unknown; }

package/dist/index.js

@@ -0,0 +1,279 @@
+"use strict";
+/* eslint n/exports-style: 0 */
+const fs = require("fs");
+const path = require("path");
+const base_1 = require("./base");
+const debug_1 = require("./util/debug");
+const constants_1 = require("./util/constants");
+const string_1 = require("./util/string");
+/* NOT FOR BROWSER */
+const chalk = require("chalk");
+const diff_1 = require("./util/diff");
+/**
+ * 从根路径require
+ * @param file 文件名
+ * @param dir 子路径
+ */
+const rootRequire = (file, dir) => require(path.isAbsolute(file) ? file : path.join('..', file.includes('/') ? '' : dir, file));
+/* NOT FOR BROWSER */
+/**
+ * 快速规范化页面标题
+ * @param title 标题
+ */
+const normalizeTitle = (title) => String(Parser.normalizeTitle(title));
+/** 重定向列表 */
+class RedirectMap extends Map {
+    /** @ignore */
+    constructor(entries) {
+        super();
+        if (entries) {
+            for (const [k, v] of entries) {
+                this.set(k, v);
+            }
+        }
+    }
+    set(key, value) {
+        return super.set(normalizeTitle(key), normalizeTitle(value));
+    }
+}
+const promises = [Promise.resolve()];
+let viewOnly = false, redirectMap = new RedirectMap();
+/* NOT FOR BROWSER END */
+const Parser = {
+    config: 'default',
+    i18n: undefined,
+    rules: base_1.rules,
+    /* NOT FOR BROWSER */
+    /** @implements */
+    get viewOnly() {
+        return viewOnly;
+    },
+    set viewOnly(value) {
+        if (viewOnly && !value) {
+            debug_1.Shadow.rev++;
+        }
+        viewOnly = value;
+    },
+    /** @implements */
+    get redirects() {
+        return redirectMap;
+    },
+    set redirects(redirects) {
+        redirectMap = new RedirectMap(redirects);
+    },
+    conversionTable: new Map(),
+    templates: new Map(),
+    warning: true,
+    debugging: false,
+    /* NOT FOR BROWSER END */
+    /** @implements */
+    getConfig() {
+        if (typeof this.config === 'string') {
+            this.config = rootRequire(this.config, 'config');
+            if (this.config.doubleUnderscore.length < 3) {
+                (0, diff_1.error)(`The schema (${path.resolve(__dirname, '..', 'config', '.schema.json')}) of parser configuration is updated.`);
+            }
+            /* NOT FOR BROWSER */
+            const { config: { conversionTable, redirects } } = this;
+            if (conversionTable) {
+                this.conversionTable = new Map(conversionTable);
+            }
+            if (redirects) {
+                this.redirects = new Map(redirects);
+            }
+            /* NOT FOR BROWSER END */
+            return this.getConfig();
+        }
+        const { doubleUnderscore } = this.config;
+        if (doubleUnderscore.length > 2 && doubleUnderscore[0].length === 0) {
+            doubleUnderscore[0] = Object.keys(doubleUnderscore[2]);
+        }
+        return {
+            ...this.config,
+            excludes: [],
+        };
+    },
+    /** @implements */
+    msg(msg, arg = '') {
+        if (typeof this.i18n === 'string') {
+            this.i18n = rootRequire(this.i18n, 'i18n');
+            return this.msg(msg, arg);
+        }
+        return msg && (this.i18n?.[msg] ?? msg).replace('$1', this.msg(arg));
+    },
+    /** @implements */
+    normalizeTitle(title, defaultNs = 0, include, config = Parser.getConfig(), halfParsed, decode = false, selfLink = false) {
+        const { Title } = require('./lib/title');
+        let titleObj;
+        if (halfParsed) {
+            titleObj = new Title(title, defaultNs, config, decode, selfLink);
+        }
+        else {
+            const { Token } = require('./src/index');
+            titleObj = debug_1.Shadow.run(() => {
+                const root = new Token(title, config);
+                root.type = 'root';
+                root.parseOnce(0, include).parseOnce();
+                const t = new Title(root.toString(), defaultNs, config, decode, selfLink);
+                for (const key of ['main', 'fragment']) {
+                    const str = t[key];
+                    if (str?.includes('\0')) {
+                        const s = root.buildFromStr(str, constants_1.BuildMethod.Text);
+                        if (key === 'main') {
+                            t.main = s;
+                        }
+                        else {
+                            t.setFragment(s);
+                        }
+                    }
+                }
+                return t;
+            });
+        }
+        /* NOT FOR BROWSER */
+        titleObj.conversionTable = this.conversionTable;
+        titleObj.redirects = this.redirects;
+        /* NOT FOR BROWSER END */
+        return titleObj;
+    },
+    /** @implements */
+    parse(wikitext, include, maxStage = constants_1.MAX_STAGE, config = Parser.getConfig()) {
+        wikitext = (0, string_1.tidy)(wikitext);
+        if (typeof maxStage !== 'number') {
+            const types = Array.isArray(maxStage) ? maxStage : [maxStage];
+            maxStage = Math.max(...types.map(t => base_1.stages[t] || constants_1.MAX_STAGE));
+        }
+        const { Token } = require('./src/index');
+        const root = debug_1.Shadow.run(() => {
+            const token = new Token(wikitext, config);
+            token.type = 'root';
+            try {
+                return token.parse(maxStage, include);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    const file = path.join(__dirname, '..', 'errors', new Date().toISOString()), stage = token.getAttribute('stage');
+                    fs.writeFileSync(file, stage === constants_1.MAX_STAGE ? wikitext : token.toString());
+                    fs.writeFileSync(`${file}.err`, e.stack);
+                    fs.writeFileSync(`${file}.json`, JSON.stringify({ stage, include, config }, null, '\t'));
+                }
+                throw e;
+            }
+        });
+        /* NOT FOR BROWSER */
+        if (this.debugging) {
+            let restored = root.toString(), process = 'parsing';
+            if (restored === wikitext) {
+                const entities = { lt: '<', gt: '>', amp: '&' };
+                restored = root.print().replace(/<[^<]+?>|&([lg]t|amp);/gu, (_, s) => s ? entities[s] : '');
+                process = 'printing';
+            }
+            if (restored !== wikitext) {
+                const { 0: cur, length } = promises;
+                promises.unshift((async () => {
+                    await cur;
+                    this.error(`Original wikitext is altered when ${process}!`);
+                    return (0, diff_1.diff)(wikitext, restored, length);
+                })());
+            }
+        }
+        /* NOT FOR BROWSER END */
+        return root;
+    },
+    /* NOT FOR BROWSER */
+    /** @implements */
+    warn(msg, ...args) {
+        if (this.warning) {
+            console.warn(chalk.yellow(msg), ...args);
+        }
+    },
+    /** @implements */
+    debug(msg, ...args) {
+        if (this.debugging) {
+            console.debug(chalk.blue(msg), ...args);
+        }
+    },
+    error: diff_1.error,
+    info: diff_1.info,
+    /** @implements */
+    log(f) {
+        if (typeof f === 'function') {
+            console.log(String(f));
+        }
+    },
+    /** @implements */
+    require(name) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        return Object.hasOwn(constants_1.classes, name) ? require(constants_1.classes[name])[name] : require(path.join(__dirname, name));
+    },
+    /** @implements */
+    async clearCache() {
+        await (0, diff_1.cmd)('npm', ['--prefix', path.join(__dirname, '..'), 'run', 'build:core']);
+        const entries = Object.entries(constants_1.classes);
+        for (const [, filePath] of entries) {
+            try {
+                delete require.cache[require.resolve(filePath)];
+            }
+            catch { }
+        }
+        for (const [name, filePath] of entries) {
+            if (name in global) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                Object.assign(global, { [name]: require(filePath)[name] });
+            }
+        }
+        this.info('已重新加载Parser');
+    },
+    /** @implements */
+    isInterwiki(title, { interwiki } = Parser.getConfig()) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        /^(zh|en)\s*:/diu;
+        return interwiki.length > 0
+            ? new RegExp(String.raw `^(${interwiki.join('|')})\s*:`, 'diu')
+                .exec(title.replaceAll('_', ' ').replace(/^\s*:?\s*/u, ''))
+            : null;
+    },
+    /** @implements */
+    reparse(date = '') {
+        const main = fs.readdirSync(path.join(__dirname, '..', 'errors'))
+            .find(name => name.startsWith(date) && name.endsWith('Z'));
+        if (!main) {
+            throw new RangeError(`找不到对应时间戳的错误记录：${date}`);
+        }
+        const file = path.join(__dirname, '..', 'errors', main), wikitext = fs.readFileSync(file, 'utf8');
+        const { stage, include, config } = require(`${file}.json`), { Token } = require('./src/index');
+        debug_1.Shadow.run(() => {
+            const halfParsed = stage < constants_1.MAX_STAGE, token = new Token(halfParsed ? wikitext : (0, string_1.tidy)(wikitext), config);
+            token.type = 'root';
+            if (halfParsed) {
+                token.setAttribute('stage', stage);
+                token.parseOnce(stage, include);
+            }
+            else {
+                token.parse(undefined, include);
+            }
+            fs.unlinkSync(file);
+            fs.unlinkSync(`${file}.err`);
+            fs.unlinkSync(`${file}.json`);
+        });
+    },
+};
+const def = {
+    default: { value: Parser },
+}, enumerable = new Set([
+    'normalizeTitle',
+    'parse',
+    /* NOT FOR BROWSER */
+    'conversionTable',
+    'warning',
+    'debugging',
+    'isInterwiki',
+]);
+for (const key in Parser) {
+    if (!enumerable.has(key)) {
+        def[key] = { enumerable: false };
+    }
+}
+Object.defineProperties(Parser, def);
+exports.default = Parser;
+module.exports = Parser;

package/dist/internal.d.ts

@@ -0,0 +1,47 @@
+export type { AstNodes, } from './lib/node';
+export type * from './lib/text';
+export type { Token } from './src/index';
+export type * from './src/redirect';
+export type * from './src/link/redirectTarget';
+export type * from './src/onlyinclude';
+export type * from './src/nowiki/noinclude';
+export type * from './src/tagPair/include';
+export type * from './src/nowiki/comment';
+export type * from './src/atom';
+export type { AttributeToken } from './src/attribute';
+export type * from './src/attributes';
+export type * from './src/tagPair/ext';
+export type * from './src/hidden';
+export type * from './src/arg';
+export type * from './src/syntax';
+export type * from './src/parameter';
+export type * from './src/transclude';
+export type * from './src/heading';
+export type * from './src/html';
+export type { TdToken } from './src/table/td';
+export type * from './src/table/tr';
+export type { TableToken } from './src/table/index';
+export type * from './src/nowiki/hr';
+export type * from './src/nowiki/doubleUnderscore';
+export type * from './src/link/index';
+export type * from './src/link/category';
+export type { ImageParameterToken } from './src/imageParameter';
+export type * from './src/link/file';
+export type * from './src/link/galleryImage';
+export type * from './src/nowiki/quote';
+export type * from './src/magicLink';
+export type * from './src/extLink';
+export type { ListRangeToken } from './src/nowiki/listBase';
+export type * from './src/nowiki/dd';
+export type * from './src/nowiki/list';
+export type * from './src/converterFlags';
+export type * from './src/converterRule';
+export type * from './src/converter';
+export type * from './src/nowiki/index';
+export type * from './src/pre';
+export type * from './src/paramTag/index';
+export type * from './src/paramTag/inputbox';
+export type * from './src/nested';
+export type * from './src/gallery';
+export type * from './src/imagemapLink';
+export type * from './src/imagemap';

package/dist/lib/element.d.ts

@@ -0,0 +1,125 @@
+import { AstNode } from './node';
+import type { LintError, AST } from '../base';
+import type { AstNodes, AstText, Token } from '../internal';
+/** 类似HTMLElement */
+export declare abstract class AstElement extends AstNode {
+    #private;
+    readonly name?: string;
+    readonly data: undefined;
+    /** 子节点总数 */
+    get length(): number;
+    set length(n: number);
+    /** 全部非文本子节点 */
+    get children(): Token[];
+    /** 首位非文本子节点 */
+    get firstElementChild(): Token | undefined;
+    /** 末位非文本子节点 */
+    get lastElementChild(): Token | undefined;
+    /** 非文本子节点总数 */
+    get childElementCount(): number;
+    /** 父节点 */
+    get parentElement(): Token | undefined;
+    /** AstElement.prototype.text()的getter写法 */
+    get outerText(): string;
+    /** 不可见 */
+    get hidden(): boolean;
+    /** 内部高度 */
+    get clientHeight(): number | undefined;
+    /** 内部宽度 */
+    get clientWidth(): number | undefined;
+    constructor();
+    /** 合并相邻的文本子节点 */
+    normalize(): void;
+    /**
+     * 移除子节点
+     * @param i 移除位置
+     */
+    removeAt(i: number): AstNodes;
+    /**
+     * 插入子节点
+     * @param node 待插入的子节点
+     * @param i 插入位置
+     * @throws `RangeError` 不能插入祖先或子节点
+     */
+    insertAt<T extends AstNodes>(node: T, i?: number): T;
+    /**
+     * 最近的祖先节点
+     * @param selector 选择器
+     */
+    closest<T = Token>(selector: string): T | undefined;
+    /**
+     * 符合选择器的第一个后代节点
+     * @param selector 选择器
+     */
+    querySelector<T = Token>(selector: string): T | undefined;
+    /**
+     * 符合选择器的所有后代节点
+     * @param selector 选择器
+     */
+    querySelectorAll<T = Token>(selector: string): T[];
+    /**
+     * 在末尾批量插入子节点
+     * @param elements 插入节点
+     */
+    append(...elements: (AstNodes | string)[]): void;
+    /**
+     * 批量替换子节点
+     * @param elements 新的子节点
+     */
+    replaceChildren(...elements: (AstNodes | string)[]): void;
+    /**
+     * 修改文本子节点
+     * @param str 新文本
+     * @param i 子节点位置
+     * @throws `RangeError` 对应位置的子节点不是文本节点
+     */
+    setText(str: string, i?: number): string;
+    /**
+     * 保存为JSON
+     * @param file 文件名
+     * @param start
+     */
+    json(file?: string, start?: number): AST;
+    /**
+     * 检查是否符合选择器
+     * @param selector 选择器
+     */
+    matches<T>(selector?: string): this is T;
+    /**
+     * 类型选择器
+     * @param types
+     */
+    getElementByTypes<T = Token>(types: string): T | undefined;
+    /**
+     * id选择器
+     * @param id id名
+     */
+    getElementById<T = Token>(id: string): T | undefined;
+    /**
+     * 类选择器
+     * @param className 类名之一
+     */
+    getElementsByClassName<T = Token>(className: string): T[];
+    /**
+     * 标签名选择器
+     * @param tag 标签名
+     */
+    getElementsByTagName<T = Token>(tag: string): T[];
+    /**
+     * 在开头批量插入子节点
+     * @param elements 插入节点
+     */
+    prepend(...elements: (AstNodes | string)[]): void;
+    /**
+     * 移除子节点
+     * @param node 子节点
+     */
+    removeChild<T extends AstNodes>(node: T): T;
+    /**
+     * 在指定位置前插入子节点
+     * @param child 插入节点
+     * @param reference 指定位置处的子节点
+     */
+    insertBefore(child: string, reference?: AstNodes): AstText;
+    insertBefore<T extends AstNodes>(child: T, reference?: AstNodes): T;
+}