wikiparser-node 1.9.1-b → 1.9.1

package/dist/addon/token.js

@@ -0,0 +1,239 @@
+"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 index_1 = 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_1.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.replace(/-->/gu, '-->'), true, config));
+    };
+index_1.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);
+                // @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_1.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_1.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_1.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;
+        }
+        const isHtml = (0, debug_1.isToken)('html'), 
+        /**
+         * 检查是否为指定的 HTML 标签
+         * @param node 节点
+         * @param name 标签名
+         * @param closing 是否为闭合标签
+         */
+        checkHtml = (node, name, closing) => isHtml(node)
+            && (!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;
+    };
+index_1.Token.prototype.redoQuotes =
+    /** @implements */
+    function () {
+        const acceptable = this.getAcceptable();
+        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 index_1.Token(this.toString(), this.getAttribute('config'), accum);
+            node.setAttribute('stage', 6);
+            return node.parse(7);
+        });
+        this.replaceChildren(...token.childNodes);
+    };
+index_1.Token.prototype.solveConst =
+    /** @implements */
+    function () {
+        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 ? target.toString() : 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);
+            }
+        }
+    };
+constants_1.classes['ExtendedTableToken'] = __filename;

package/dist/addon/transclude.js

@@ -0,0 +1,185 @@
+"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, 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, 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;
+                // eslint-disable-next-line es-x/no-regexp-lookbehind-assertions
+                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].text(), 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), isTable = (0, debug_1.isToken)('table');
+        for (const table of parsed.childNodes) {
+            if (isTable(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,73 @@
+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][];
+}
+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' | '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 {
+    type: string;
+    readonly childNodes: readonly AstNode[];
+    /** Linter */
+    lint(): LintError[];
+    /** 以HTML格式打印 */
+    print(): string;
+}
+/** 类似HTMLElement */
+interface AstElement extends AstNode {
+    /** 保存为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): AstElement;
+}
+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,31 @@
+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>;
+    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; }