wikiparser-node 0.11.0 → 1.0.0-beta.1

package/dist/src/table/trBase.d.ts

@@ -0,0 +1,72 @@
+import * as Parser from '../../index';
+import Token = require('..');
+import TableBaseToken = require('./base');
+import TdToken = require('./td');
+import SyntaxToken = require('../syntax');
+import type { AstNodeTypes } from '../../lib/node';
+declare interface TableCoords {
+    row: number;
+    column: number;
+    x?: undefined;
+    y?: undefined;
+    start?: boolean;
+}
+declare interface TableRenderedCoords {
+    row?: undefined;
+    column?: undefined;
+    x: number;
+    y: number;
+}
+/** 表格行或表格 */
+declare abstract class TrBaseToken extends TableBaseToken {
+    #private;
+    type: 'table' | 'tr';
+    /**
+     * @override
+     * @browser
+     */
+    lint(start?: number): Parser.LintError[];
+    /**
+     * @override
+     * @browser
+     */
+    text(): string;
+    /** @override */
+    toString(selector?: string): string;
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i: number): AstNodeTypes;
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt<T extends Token>(token: T, i?: number): T;
+    /** 获取行数 */
+    getRowCount(): number;
+    /** 获取列数 */
+    getColCount(): number;
+    /**
+     * 获取第n列
+     * @param n 列号
+     * @param insert 是否用于判断插入新列的位置
+     * @throws `RangeError` 不存在对应单元格
+     */
+    getNthCol(n: number, insert?: false): TdToken | undefined;
+    /** @ignore */
+    getNthCol(n: number, insert: true): TdToken | import('./tr') | SyntaxToken | undefined;
+    /**
+     * 插入新的单元格
+     * @param inner 单元格内部wikitext
+     * @param {TableCoords} coord 单元格坐标
+     * @param subtype 单元格类型
+     * @param attr 单元格属性
+     */
+    insertTableCell(inner: string | Token, { column }: TableCoords, subtype?: 'td' | 'th' | 'caption', attr?: TdToken.TdAttrs): TdToken;
+}
+declare namespace TrBaseToken {
+    export type { TableCoords, TableRenderedCoords, };
+}
+export = TrBaseToken;

package/dist/src/table/trBase.js

@@ -0,0 +1,153 @@
+"use strict";
+const lint_1 = require("../../util/lint");
+const Parser = require("../../index");
+const Token = require("..");
+const TableBaseToken = require("./base");
+const TdToken = require("./td");
+/** 表格行或表格 */
+class TrBaseToken extends TableBaseToken {
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start), inter = this.childNodes.find(({ type }) => type === 'table-inter');
+        if (!inter) {
+            return errors;
+        }
+        const first = inter.childNodes.find(child => child.text().trim()), tdPattern = /^\s*(?:!|\{\{\s*![!-]?\s*\}\})/u;
+        if (!first || tdPattern.test(String(first))
+            || first.type === 'arg' && tdPattern.test(first.default || '')) {
+            return errors;
+        }
+        else if (first.type === 'magic-word') {
+            try {
+                const possibleValues = first.getPossibleValues();
+                if (possibleValues.every(token => tdPattern.test(token.text()))) {
+                    return errors;
+                }
+            }
+            catch { }
+        }
+        const error = (0, lint_1.generateForChild)(inter, { start }, 'content to be moved out from the table');
+        errors.push({
+            ...error,
+            startIndex: error.startIndex + 1,
+            startLine: error.startLine + 1,
+            startCol: 0,
+            excerpt: error.excerpt.slice(1),
+        });
+        return errors;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    text() {
+        this.#correct();
+        const str = super.text();
+        return this.type === 'tr' && !str.trim().includes('\n') ? '' : str;
+    }
+    /** 修复简单的表格语法错误 */
+    #correct() {
+        const { childNodes: [, , child] } = this;
+        if (child?.constructor === Token) {
+            const { firstChild } = child;
+            if (firstChild?.type !== 'text') {
+                child.prepend('\n');
+            }
+            else if (!firstChild.data.startsWith('\n')) {
+                firstChild.insertData(0, '\n');
+            }
+        }
+    }
+    /** @override */
+    toString(selector) {
+        this.#correct();
+        return super.toString(selector);
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        const child = this.childNodes.at(i);
+        if (child instanceof TdToken && child.isIndependent()) {
+            const { nextSibling } = child;
+            if (nextSibling?.type === 'td') {
+                nextSibling.independence();
+            }
+        }
+        return super.removeAt(i);
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt(token, i = this.length) {
+        if (!Parser.running && !(token instanceof TrBaseToken)) {
+            this.typeError('insertAt', 'TrToken');
+        }
+        const child = this.childNodes.at(i);
+        if (token instanceof TdToken && token.isIndependent() && child instanceof TdToken) {
+            child.independence();
+        }
+        return super.insertAt(token, i);
+    }
+    /** 获取行数 */
+    getRowCount() {
+        return Number(this.childNodes.some(child => child instanceof TdToken && child.isIndependent() && !child.firstChild.text().endsWith('+')));
+    }
+    /** 获取列数 */
+    getColCount() {
+        let count = 0, last = 0;
+        for (const child of this.childNodes) {
+            if (child instanceof TdToken) {
+                last = child.isIndependent() ? Number(child.subtype !== 'caption') : last;
+                count += last;
+            }
+        }
+        return count;
+    }
+    /** @ignore */
+    getNthCol(n, insert = false) {
+        if (!Number.isInteger(n)) {
+            this.typeError('getNthCol', 'Number');
+        }
+        const nCols = this.getColCount();
+        let m = n < 0 ? n + nCols : n;
+        if (m < 0 || m > nCols || m === nCols && !insert) {
+            throw new RangeError(`不存在第 ${m} 个单元格！`);
+        }
+        let last = 0;
+        for (const child of this.childNodes.slice(2)) {
+            if (child instanceof TdToken) {
+                if (child.isIndependent()) {
+                    last = Number(child.subtype !== 'caption');
+                }
+                m -= last;
+                if (m < 0) {
+                    return child;
+                }
+            }
+            else if (child.type === 'tr' || child.type === 'table-syntax') {
+                return child;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 插入新的单元格
+     * @param inner 单元格内部wikitext
+     * @param {TableCoords} coord 单元格坐标
+     * @param subtype 单元格类型
+     * @param attr 单元格属性
+     */
+    insertTableCell(inner, { column }, subtype = 'td', attr = {}) {
+        const token = TdToken.create(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
+        return this.insertBefore(token, this.getNthCol(column, true));
+    }
+}
+Parser.classes['TrBaseToken'] = __filename;
+module.exports = TrBaseToken;

package/dist/src/tagPair/ext.d.ts

@@ -1,18 +1,54 @@
-export = ExtToken;
+import * as Parser from '../../index';
+import Token = require('..');
+import TagPairToken = require('.');
+import AttributesToken = require('../attributes');
+declare const ExtToken_base: (abstract new (...args: any[]) => {
+    childNodes: import("../../lib/node").AstNodeTypes[];
+    readonly "__#12@#attributesChild": AttributesToken;
+    readonly attributes: Record<string, string | true>;
+    className: string;
+    readonly classList: Set<string>;
+    id: string;
+    hasAttr(key: string): boolean;
+    getAttr(key: string): string | true | undefined;
+    getAttrNames(): Set<string>;
+    hasAttrs(): boolean;
+    getAttrs(): Record<string, string | true>;
+    setAttr(key: string, value: string | boolean): void;
+    removeAttr(key: string): void;
+    toggleAttr(key: string, force?: boolean | undefined): void;
+    length: number;
+    toString(selector?: string | undefined, separator?: string | undefined): string;
+    text(separator?: string | undefined): string;
+    insertAt(token: unknown, i?: number | undefined): unknown;
+}) & typeof TagPairToken;
 /**
  * 扩展标签
- * @classdesc `{childNodes: [AttributesToken, NowikiToken|Token]}`
+ * @classdesc `{childNodes: [AttributesToken, Token]}`
  */
-declare class ExtToken extends TagPairToken {
+declare abstract class ExtToken extends ExtToken_base {
+    readonly type = "ext";
+    childNodes: [AttributesToken, Token];
+    abstract get children(): [AttributesToken, Token];
+    abstract get firstChild(): AttributesToken;
+    abstract get firstElementChild(): AttributesToken;
+    abstract get lastChild(): Token;
+    /** @override */
+    get closed(): boolean;
     /**
-     * @param {string} name 标签名
-     * @param {string} attr 标签属性
-     * @param {string} inner 内部wikitext
-     * @param {string|undefined} closed 是否封闭
-     * @param {import('../../../typings/token').accum} accum
+     * @browser
+     * @param name 标签名
+     * @param attr 标签属性
+     * @param inner 内部wikitext
+     * @param closed 是否封闭
      */
-    constructor(name: string, attr?: string, inner?: string, closed?: string | undefined, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum);
+    constructor(name: string, attr?: string, inner?: string, closed?: string | undefined, config?: Parser.Config, accum?: Token[]);
+    /**
+     * @override
+     * @browser
+     */
+    lint(start?: number): Parser.LintError[];
     /** @override */
-    override cloneNode(): ExtToken;
+    cloneNode(): this;
 }
-import TagPairToken = require(".");
+export = ExtToken;

package/dist/src/tagPair/ext.js

@@ -0,0 +1,127 @@
+"use strict";
+const lint_1 = require("../../util/lint");
+const base_1 = require("../../util/base");
+const attributesParent = require("../../mixin/attributesParent");
+const Parser = require("../../index");
+const Token = require("..");
+const TagPairToken = require(".");
+const AttributesToken = require("../attributes");
+/**
+ * 扩展标签
+ * @classdesc `{childNodes: [AttributesToken, Token]}`
+ */
+class ExtToken extends attributesParent(TagPairToken) {
+    type = 'ext';
+    /** @override */
+    get closed() {
+        return true;
+    }
+    /**
+     * @browser
+     * @param name 标签名
+     * @param attr 标签属性
+     * @param inner 内部wikitext
+     * @param closed 是否封闭
+     */
+    constructor(name, attr = '', inner = '', closed = undefined, config = Parser.getConfig(), accum = []) {
+        const lcName = name.toLowerCase(), 
+        attrToken = new AttributesToken(!attr || attr.trimStart() !== attr ? attr : ` ${attr}`, 'ext-attrs', lcName, config, accum), newConfig = { ...config, ext: (0, base_1.del)(config.ext, lcName), excludes: [...config.excludes ?? []] };
+        let innerToken;
+        switch (lcName) {
+            case 'tab':
+                newConfig.ext = (0, base_1.del)(newConfig.ext, 'tabs');
+            // fall through
+            case 'indicator':
+            case 'poem':
+            case 'ref':
+            case 'option':
+            case 'combooption':
+            case 'tabs':
+            case 'poll':
+            case 'seo':
+                if (lcName === 'poem') {
+                    newConfig.excludes.push('heading');
+                }
+                innerToken = new Token(inner, newConfig, true, accum);
+                break;
+            case 'pre': {
+                const PreToken = require('../pre');
+                innerToken = new PreToken(inner, newConfig, accum);
+                break;
+            }
+            case 'dynamicpagelist': {
+                const ParamTagToken = require('../paramTag');
+                innerToken = new ParamTagToken(inner, newConfig, accum);
+                break;
+            }
+            case 'inputbox': {
+                newConfig.excludes.push('heading');
+                const InputboxToken = require('../paramTag/inputbox');
+                innerToken = new InputboxToken(inner, newConfig, accum);
+                break;
+            }
+            case 'references': {
+                const NestedToken = require('../nested');
+                innerToken = new NestedToken(inner, /<!--.*?(?:-->|$)|<(ref)(\s[^>]*)?>(.*?)<\/(ref\s*)>/gisu, ['ref'], newConfig, accum);
+                break;
+            }
+            case 'choose': {
+                const NestedToken = require('../nested');
+                innerToken = new NestedToken(inner, /<(option|choicetemplate)(\s[^>]*)?>(.*?)<\/(\1)>/gsu, ['option', 'choicetemplate'], newConfig, accum);
+                break;
+            }
+            case 'combobox': {
+                const NestedToken = require('../nested');
+                innerToken = new NestedToken(inner, /<(combooption)(\s[^>]*)?>(.*?)<\/(combooption\s*)>/gisu, ['combooption'], newConfig, accum);
+                break;
+            }
+            case 'gallery': {
+                const GalleryToken = require('../gallery');
+                innerToken = new GalleryToken(inner, newConfig, accum);
+                break;
+            }
+            case 'imagemap': {
+                const ImagemapToken = require('../imagemap');
+                innerToken = new ImagemapToken(inner, newConfig, accum);
+                break;
+            }
+            // 更多定制扩展的代码示例：
+            // ```
+            // case 'extensionName': {
+            //	const ExtensionToken: typeof import('../extension') = require('../extension');
+            //	innerToken = new ExtensionToken(inner, newConfig, accum);
+            //	break;
+            // }
+            // ```
+            default: {
+                const NowikiToken = require('../nowiki');
+                innerToken = new NowikiToken(inner, newConfig);
+            }
+        }
+        innerToken.setAttribute('name', lcName).type = 'ext-inner';
+        super(name, attrToken, innerToken, closed, config, accum);
+    }
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start);
+        if (this.name !== 'nowiki' && this.closest('html-attrs, table-attrs')) {
+            const root = this.getRootNode(), excerpt = String(root).slice(Math.max(0, start - 25), start + 25), rect = { start, ...root.posFromIndex(start) };
+            errors.push({ ...(0, lint_1.generateForSelf)(this, rect, 'extension tag in HTML tag attributes'), excerpt });
+        }
+        return errors;
+    }
+    /** @override */
+    cloneNode() {
+        const inner = this.lastChild.cloneNode(), tags = this.getAttribute('tags'), config = this.getAttribute('config'), attr = String(this.firstChild);
+        return Parser.run(() => {
+            const token = new ExtToken(tags[0], attr, '', this.selfClosing ? undefined : tags[1], config);
+            token.lastChild.safeReplaceWith(inner);
+            return token;
+        });
+    }
+}
+Parser.classes['ExtToken'] = __filename;
+module.exports = ExtToken;

package/dist/src/tagPair/include.d.ts

@@ -1,25 +1,44 @@
-export = IncludeToken;
+import * as Parser from '../../index';
+import TagPairToken = require('.');
+import Token = require('..');
+import AstText = require('../../lib/text');
+declare const IncludeToken_base: ((abstract new (...args: any[]) => {
+    text(): string;
+    length: number;
+    toString(selector?: string | undefined, separator?: string | undefined): string;
+    insertAt(token: unknown, i?: number | undefined): unknown;
+}) & {
+    readonly hidden: true;
+}) & typeof TagPairToken;
 /**
- * `<includeonly>`或`<noinclude>`
+ * `<includeonly>`或`<noinclude>`或`<onlyinclude>`
  * @classdesc `{childNodes: [AstText, AstText]}`
  */
-declare class IncludeToken extends TagPairToken {
+declare abstract class IncludeToken extends IncludeToken_base {
+    /** @browser */
+    readonly type = "include";
+    childNodes: [AstText, AstText];
+    abstract get children(): [];
+    abstract get firstChild(): AstText;
+    abstract get firstElementChild(): undefined;
+    abstract get lastChild(): AstText;
+    abstract get lastElementChild(): undefined;
     /**
-     * @param {string} name 标签名
-     * @param {string} attr 标签属性
-     * @param {string|undefined} inner 内部wikitext
-     * @param {string|undefined} closed 是否封闭
-     * @param {import('../../../typings/token').accum} accum
+     * @browser
+     * @param name 标签名
+     * @param attr 标签属性
+     * @param inner 内部wikitext
+     * @param closed 是否封闭
      */
-    constructor(name: string, attr?: string, inner?: string | undefined, closed?: string | undefined, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum);
+    constructor(name: string, attr?: string, inner?: string | undefined, closed?: string | undefined, config?: Parser.Config, accum?: Token[]);
     /** @override */
-    override cloneNode(): IncludeToken;
+    cloneNode(): this;
     /**
      * @override
-     * @param {string} str 新文本
+     * @param str 新文本
      */
-    override setText(str: string): string;
+    setText(str: string): string;
     /** 清除标签属性 */
     removeAttr(): void;
 }
-import TagPairToken = require(".");
+export = IncludeToken;

package/dist/src/tagPair/include.js

@@ -0,0 +1,40 @@
+"use strict";
+const hidden = require("../../mixin/hidden");
+const Parser = require("../../index");
+const TagPairToken = require(".");
+/**
+ * `<includeonly>`或`<noinclude>`或`<onlyinclude>`
+ * @classdesc `{childNodes: [AstText, AstText]}`
+ */
+class IncludeToken extends hidden(TagPairToken) {
+    /** @browser */
+    type = 'include';
+    /**
+     * @browser
+     * @param name 标签名
+     * @param attr 标签属性
+     * @param inner 内部wikitext
+     * @param closed 是否封闭
+     */
+    constructor(name, attr = '', inner = undefined, closed = undefined, config = Parser.getConfig(), accum = []) {
+        super(name, attr, inner ?? '', inner === undefined ? closed : closed ?? '', config, accum);
+    }
+    /** @override */
+    cloneNode() {
+        const tags = this.getAttribute('tags'), config = this.getAttribute('config'), inner = this.selfClosing ? undefined : this.lastChild.data, closing = this.selfClosing || !this.closed ? undefined : tags[1];
+        return Parser.run(() => new IncludeToken(tags[0], this.firstChild.data, inner, closing, config));
+    }
+    /**
+     * @override
+     * @param str 新文本
+     */
+    setText(str) {
+        return super.setText(str, 1);
+    }
+    /** 清除标签属性 */
+    removeAttr() {
+        super.setText('');
+    }
+}
+Parser.classes['IncludeToken'] = __filename;
+module.exports = IncludeToken;

package/dist/src/tagPair/index.d.ts

@@ -1,41 +1,56 @@
-export = TagPairToken;
-/**
- * 成对标签
- * @classdesc `{childNodes: [AstText|AttributesToken, AstText|Token]}`
- */
-declare class TagPairToken extends Token {
+import * as Parser from '../../index';
+import Token = require('..');
+import type { AstNodeTypes, TokenAttributeGetter } from '../../lib/node';
+declare const TagPairToken_base: ((abstract new (...args: any[]) => {
+    removeAt(): never;
+    insertAt(token: string, i?: number | undefined): import("../../lib/text");
+    insertAt<T extends AstNodeTypes>(token: T, i?: number | undefined): T;
+    length: number;
+    toString(selector?: string | undefined, separator?: string | undefined): string;
+    text(separator?: string | undefined): string;
+}) & {
+    readonly fixed: true; /** @browser */
+}) & typeof Token;
+/** 成对标签 */
+declare abstract class TagPairToken extends TagPairToken_base {
+    #private;
+    type: 'ext' | 'include';
+    name: string;
+    abstract get firstChild(): AstNodeTypes;
+    abstract get lastChild(): AstNodeTypes;
     /**
-     * @param {string} name 标签名
-     * @param {string|Token} attr 标签属性
-     * @param {string|Token} inner 内部wikitext
-     * @param {string|undefined} closed 是否封闭；约定`undefined`表示自闭合，`''`表示未闭合
-     * @param {import('../../../typings/token').accum} accum
+     * 是否闭合
+     * @browser
      */
-    constructor(name: string, attr: string | Token, inner: string | Token, closed: string | undefined, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum);
-    set closed(arg: boolean);
-    /** getter */
     get closed(): boolean;
-    set selfClosing(arg: boolean);
-    /** getter */
+    set closed(value: boolean);
+    /** 是否自封闭 */
     get selfClosing(): boolean;
+    set selfClosing(value: boolean);
     /** 内部wikitext */
-    get innerText(): string;
+    get innerText(): string | undefined;
+    /**
+     * @browser
+     * @param name 标签名
+     * @param attr 标签属性
+     * @param inner 内部wikitext
+     * @param closed 是否封闭；约定`undefined`表示自封闭，`''`表示未闭合
+     */
+    constructor(name: string, attr: string | Token, inner: string | Token, closed: string | undefined, config?: Parser.Config, accum?: Token[]);
     /**
      * @override
-     * @param {string} selector
+     * @browser
      */
-    override toString(selector: string): string;
+    toString(selector?: string): string;
     /**
      * @override
-     * @returns {string}
+     * @browser
      */
-    override text(): string;
-    /** @override */
-    override print(): string;
-    #private;
-}
-declare namespace TagPairToken {
-    export { TokenAttribute };
+    text(): string;
+    /**
+     * @override
+     * @browser
+     */
+    print(): string;
 }
-import Token = require("..");
-type TokenAttribute<T> = import('../../../typings/node').TokenAttribute<T>;
+export = TagPairToken;