wikiparser-node 0.11.0 → 1.0.0-beta.1

package/dist/parser/table.js

@@ -0,0 +1,108 @@
+"use strict";
+const Parser = require("../index");
+const Token = require("../src");
+const TableToken = require("../src/table");
+const TrToken = require("../src/table/tr");
+const TdToken = require("../src/table/td");
+const DdToken = require("../src/nowiki/dd");
+/**
+ * 解析表格，注意`tr`和`td`包含开头的换行
+ * @param {Token & {firstChild: AstText}} root 根节点
+ */
+const parseTable = ({ firstChild: { data }, type, name }, config = Parser.getConfig(), accum = []) => {
+    const stack = [], lines = data.split('\n');
+    let out = type === 'root' || type === 'parameter-value' || type === 'ext-inner' && name === 'poem'
+        ? ''
+        : `\n${lines.shift()}`;
+    /**
+     * 向表格中插入纯文本
+     * @param str 待插入的文本
+     * @param top 当前解析的表格或表格行
+     */
+    const push = (str, top) => {
+        if (!top) {
+            out += str;
+            return;
+        }
+        const { lastChild } = top;
+        if (lastChild.constructor === Token) {
+            lastChild.setText(String(lastChild) + str);
+        }
+        else {
+            const token = new Token(str, config, true, accum);
+            token.type = 'table-inter';
+            top.insertAt(token.setAttribute('stage', 3));
+        }
+    };
+    for (const outLine of lines) {
+        let top = stack.pop();
+        const [spaces] = /^(?:\s|\0\d+c\x7F)*/u.exec(outLine), line = outLine.slice(spaces.length), matchesStart = /^(:*)((?:\s|\0\d+c\x7F)*)(\{\||\{(?:\0\d+c\x7F)*\0\d+!\x7F|\0\d+\{\x7F)(.*)$/u
+            .exec(line);
+        if (matchesStart) {
+            while (top && top.type !== 'td') {
+                top = stack.pop();
+            }
+            const [, indent, moreSpaces, tableSyntax, attr] = matchesStart;
+            if (indent) {
+                new DdToken(indent, config, accum);
+            }
+            push(`\n${spaces}${indent && `\0${accum.length - 1}d\x7F`}${moreSpaces}\0${accum.length}b\x7F`, top);
+            const table = new TableToken(tableSyntax, attr, config, accum);
+            stack.push(...top ? [top] : [], table);
+            continue;
+        }
+        else if (!top) {
+            out += `\n${outLine}`;
+            continue;
+        }
+        // eslint-disable-next-line operator-linebreak
+        const matches = /^(?:(\|\}|\0\d+!\x7F\}|\0\d+\}\x7F)|(\|-+|\0\d+!\x7F-+|\0\d+-\x7F-*)(?!-)|(!|(?:\||\0\d+!\x7F)\+?))(.*)$/u
+            .exec(line);
+        if (!matches) {
+            push(`\n${outLine}`, top);
+            stack.push(top);
+            continue;
+        }
+        const [, closing, row, cell, attr] = matches;
+        if (closing) {
+            while (top.type !== 'table') {
+                top = stack.pop();
+            }
+            top.close(`\n${spaces}${closing}`, true);
+            push(attr, stack.at(-1));
+        }
+        else if (row) {
+            if (top.type === 'td') {
+                top = stack.pop();
+            }
+            if (top.type === 'tr') {
+                top = stack.pop();
+            }
+            const tr = new TrToken(`\n${spaces}${row}`, attr, config, accum);
+            stack.push(top, tr);
+            top.insertAt(tr);
+        }
+        else {
+            if (top.type === 'td') {
+                top = stack.pop();
+            }
+            const regex = cell === '!'
+                ? /!!|(?:\||\0\d+!\x7F){2}|\0\d+\+\x7F/gu
+                : /(?:\||\0\d+!\x7F){2}|\0\d+\+\x7F/gu;
+            let mt = regex.exec(attr), lastIndex = 0, lastSyntax = `\n${spaces}${cell}`;
+            while (mt) {
+                const td = new TdToken(lastSyntax, attr.slice(lastIndex, mt.index), config, accum);
+                top.insertAt(td);
+                ({ lastIndex } = regex);
+                [lastSyntax] = mt;
+                mt = regex.exec(attr);
+            }
+            const td = new TdToken(lastSyntax, attr.slice(lastIndex), config, accum);
+            stack.push(top, td);
+            top.insertAt(td);
+        }
+    }
+    return out.slice(1);
+};
+Parser.parsers['parseTable'] = __filename;
+module.exports = parseTable;

package/dist/src/arg.d.ts

@@ -1,54 +1,78 @@
-export = ArgToken;
+import * as Parser from '../index';
+import Token = require('.');
+import AtomToken = require('./atom');
+import HiddenToken = require('./hidden');
 /**
  * `{{{}}}`包裹的参数
  * @classdesc `{childNodes: [AtomToken, ?Token, ...HiddenToken]}`
  */
-declare class ArgToken extends Token {
+declare abstract class ArgToken extends Token {
+    /** @browser */
+    readonly type = "arg";
+    name: string;
+    childNodes: [AtomToken] | [AtomToken, Token, ...HiddenToken[]];
+    abstract get firstChild(): AtomToken;
+    abstract get firstElementChild(): AtomToken;
+    abstract get lastChild(): Token;
+    abstract get lastElementChild(): Token;
     /**
-     * @param {string[]} parts 以'|'分隔的各部分
-     * @param {import('../../typings/token').accum} accum
-     * @complexity `n`
+     * 预设值
+     * @browser
      */
-    constructor(parts: string[], config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
-    /** default */
     get default(): string | false;
+    /**
+     * @browser
+     * @param parts 以'|'分隔的各部分
+     */
+    constructor(parts: string[], 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;
-    /** @override */
-    override cloneNode(): ArgToken;
+    text(): string;
+    /**
+     * @override
+     * @browser
+     */
+    print(): string;
     /**
-     * 移除无效部分
-     * @complexity `n`
+     * @override
+     * @browser
      */
+    lint(start?: number): Parser.LintError[];
+    /** @override */
+    cloneNode(): this;
+    /** 移除无效部分 */
     removeRedundant(): void;
     /**
      * @override
-     * @param {Token} token 待插入的子节点
-     * @param {number} i 插入位置
+     * @param i 移除位置
+     */
+    removeAt(i: number): Token;
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
      * @throws `RangeError` 不可插入多余子节点
+     * @throws `TypeError` 不可插入文本节点
      */
-    override insertAt(token: Token, i?: number): Token;
+    insertAt<T extends Token>(token: T, i?: number): T;
     /**
      * 设置参数名
-     * @param {string} name 新参数名
+     * @param name 新参数名
      * @throws `SyntaxError` 非法的参数名
      */
     setName(name: string): void;
     /**
      * 设置预设值
-     * @param {string} value 预设值
+     * @param value 预设值
      * @throws `SyntaxError` 非法的参数预设值
      */
     setDefault(value: string): void;
 }
-import Token = require(".");
+export = ArgToken;

package/dist/src/arg.js

@@ -0,0 +1,196 @@
+"use strict";
+const string_1 = require("../util/string");
+const lint_1 = require("../util/lint");
+const Parser = require("../index");
+const Token = require(".");
+const AtomToken = require("./atom");
+const HiddenToken = require("./hidden");
+/**
+ * `{{{}}}`包裹的参数
+ * @classdesc `{childNodes: [AtomToken, ?Token, ...HiddenToken]}`
+ */
+class ArgToken extends Token {
+    /** @browser */
+    type = 'arg';
+    /**
+     * 预设值
+     * @browser
+     */
+    get default() {
+        return this.childNodes[1]?.text() ?? false;
+    }
+    /**
+     * @browser
+     * @param parts 以'|'分隔的各部分
+     */
+    constructor(parts, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, true, accum, {
+            AtomToken: 0, Token: 1, HiddenToken: '2:',
+        });
+        for (let i = 0; i < parts.length; i++) {
+            if (i === 0) {
+                const token = new AtomToken(parts[i], 'arg-name', config, accum, {
+                    'Stage-2': ':', '!HeadingToken': '',
+                });
+                super.insertAt(token);
+            }
+            else if (i > 1) {
+                const token = new HiddenToken(parts[i], config, accum, {
+                    'Stage-2': ':', '!HeadingToken': '',
+                });
+                super.insertAt(token);
+            }
+            else {
+                const token = new Token(parts[i], config, true, accum);
+                token.type = 'arg-default';
+                super.insertAt(token.setAttribute('stage', 2));
+            }
+        }
+        this.protectChildren(0);
+    }
+    /**
+     * @override
+     * @browser
+     */
+    toString(selector) {
+        return selector && this.matches(selector) ? '' : `{{{${super.toString(selector, '|')}}}}`;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    text() {
+        return `{{{${(0, string_1.text)(this.childNodes.slice(0, 2), '|')}}}}`;
+    }
+    /** @private */
+    getPadding() {
+        return 3;
+    }
+    /** @private */
+    getGaps() {
+        return 1;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    print() {
+        return super.print({ pre: '{{{', post: '}}}', sep: '|' });
+    }
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        if (!this.getAttribute('include')) {
+            return [(0, lint_1.generateForSelf)(this, { start }, 'unexpected template argument')];
+        }
+        const { childNodes: [argName, argDefault, ...rest] } = this, errors = argName.lint(start + 3);
+        if (argDefault) {
+            errors.push(...argDefault.lint(start + 4 + String(argName).length));
+        }
+        if (rest.length > 0) {
+            const rect = { start, ...this.getRootNode().posFromIndex(start) };
+            errors.push(...rest.map(child => {
+                const error = (0, lint_1.generateForChild)(child, rect, 'invisible content inside triple brackets'), { startIndex, startCol, excerpt } = error;
+                return { ...error, startIndex: startIndex - 1, startCol: startCol - 1, excerpt: `|${excerpt}` };
+            }));
+        }
+        return errors;
+    }
+    /** @override */
+    cloneNode() {
+        const [name, ...cloned] = this.cloneChildNodes();
+        return Parser.run(() => {
+            const token = new ArgToken([''], this.getAttribute('config'));
+            token.firstChild.safeReplaceWith(name);
+            token.append(...cloned);
+            token.afterBuild();
+            return token;
+        });
+    }
+    /** @private */
+    afterBuild() {
+        this.setAttribute('name', this.firstChild.text().trim());
+        const /** @implements */ argListener = ({ prevTarget }) => {
+            if (prevTarget === this.firstChild) {
+                this.setAttribute('name', prevTarget.text().trim());
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'replace', 'text'], argListener);
+    }
+    /** 移除无效部分 */
+    removeRedundant() {
+        Parser.run(() => {
+            for (let i = this.length - 1; i > 1; i--) {
+                super.removeAt(i);
+            }
+        });
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        if (i === 1) {
+            this.removeRedundant();
+        }
+        return super.removeAt(i);
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     * @throws `RangeError` 不可插入多余子节点
+     * @throws `TypeError` 不可插入文本节点
+     */
+    insertAt(token, i = this.length) {
+        const j = i < 0 ? i + this.length : i;
+        if (j > 1) {
+            throw new RangeError(`${this.constructor.name}不可插入多余的子节点！`);
+        }
+        else if (typeof token === 'string') {
+            throw new TypeError(`${this.constructor.name}不可插入文本节点！`);
+        }
+        super.insertAt(token, i);
+        if (j === 1) {
+            token.type = 'arg-default';
+        }
+        return token;
+    }
+    /**
+     * 设置参数名
+     * @param name 新参数名
+     * @throws `SyntaxError` 非法的参数名
+     */
+    setName(name) {
+        const root = Parser.parse(`{{{${name}}}}`, this.getAttribute('include'), 2, this.getAttribute('config')), { length, firstChild: arg } = root;
+        if (length !== 1 || arg.type !== 'arg' || arg.length !== 1) {
+            throw new SyntaxError(`非法的参数名称：${(0, string_1.noWrap)(name)}`);
+        }
+        const { firstChild } = arg;
+        arg.destroy();
+        this.firstChild.safeReplaceWith(firstChild);
+    }
+    /**
+     * 设置预设值
+     * @param value 预设值
+     * @throws `SyntaxError` 非法的参数预设值
+     */
+    setDefault(value) {
+        const root = Parser.parse(`{{{|${value}}}}`, this.getAttribute('include'), 2, this.getAttribute('config')), { length, firstChild: arg } = root;
+        if (length !== 1 || arg.type !== 'arg' || arg.length !== 2) {
+            throw new SyntaxError(`非法的参数预设值：${(0, string_1.noWrap)(value)}`);
+        }
+        const { childNodes: [, oldDefault] } = this, { lastChild } = arg;
+        arg.destroy();
+        if (oldDefault) {
+            oldDefault.safeReplaceWith(lastChild);
+        }
+        else {
+            this.insertAt(lastChild);
+        }
+    }
+}
+Parser.classes['ArgToken'] = __filename;
+module.exports = ArgToken;

package/dist/src/atom.d.ts

@@ -0,0 +1,12 @@
+import * as Parser from '../index';
+import Token = require('.');
+declare type AtomTypes = 'arg-name' | 'attr-key' | 'attr-value' | 'ext-attr-dirty' | 'html-attr-dirty' | 'table-attr-dirty' | 'converter-flag' | 'converter-rule-variant' | 'converter-rule-to' | 'converter-rule-from' | 'converter-rule-noconvert' | 'invoke-function' | 'invoke-module' | 'template-name' | 'link-target' | 'param-line';
+/** 不会被继续解析的plain Token */
+declare class AtomToken extends Token {
+    type: AtomTypes;
+    /** @browser */
+    constructor(wikitext: string | undefined, type: AtomTypes, config?: Parser.Config, accum?: Token[], acceptable?: Acceptable);
+    /** @override */
+    cloneNode(): this;
+}
+export = AtomToken;

package/dist/src/atom.js

@@ -0,0 +1,22 @@
+"use strict";
+const Parser = require("../index");
+const Token = require(".");
+/** 不会被继续解析的plain Token */
+class AtomToken extends Token {
+    /** @browser */
+    constructor(wikitext, type, config = Parser.getConfig(), accum = [], acceptable) {
+        super(wikitext, config, true, accum, acceptable);
+        this.type = type;
+    }
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), config = this.getAttribute('config'), acceptable = this.getAttribute('acceptable');
+        return Parser.run(() => {
+            const token = new AtomToken(undefined, this.type, config, [], acceptable);
+            token.append(...cloned);
+            return token;
+        });
+    }
+}
+Parser.classes['AtomToken'] = __filename;
+module.exports = AtomToken;

package/dist/src/attribute.d.ts

@@ -1,65 +1,106 @@
-export = AttributeToken;
+import * as Parser from '../index';
+import Token = require('.');
+import AtomToken = require('./atom');
+import type { TokenAttributeGetter } from '../lib/node';
+declare type AttributeTypes = 'ext-attr' | 'html-attr' | 'table-attr';
+declare const AttributeToken_base: ((abstract new (...args: any[]) => {
+    removeAt(): never;
+    insertAt(token: string, i?: number | undefined): import("../lib/text");
+    insertAt<T extends import("../lib/node").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;
+}) & typeof Token;
 /**
  * 扩展和HTML标签属性
  * @classdesc `{childNodes: [AtomToken, Token|AtomToken]}`
  */
-declare class AttributeToken extends Token {
+declare abstract class AttributeToken extends AttributeToken_base {
+    #private;
+    type: AttributeTypes;
+    name: string;
+    childNodes: [AtomToken, Token];
+    abstract get firstChild(): AtomToken;
+    abstract get firstElementChild(): AtomToken;
+    abstract get lastChild(): Token;
+    abstract get lastElementChild(): Token;
+    abstract get parentNode(): import('./attributes') | undefined;
+    abstract get parentElement(): import('./attributes') | undefined;
+    abstract get nextSibling(): AtomToken | this | undefined;
+    abstract get nextElementSibling(): AtomToken | this | undefined;
+    abstract get previousSibling(): AtomToken | this | undefined;
+    abstract get previousElementSibling(): AtomToken | this | undefined;
     /**
-     * @param {'ext-attr'|'html-attr'|'table-attr'} type 标签类型
-     * @param {string} tag 标签名
-     * @param {string} key 属性名
-     * @param {string} equal 等号
-     * @param {string} value 属性值
-     * @param {string[]} quotes 引号
-     * @param {import('../../typings/token').accum} accum
+     * 引号是否匹配
+     * @browser
      */
-    constructor(type: 'ext-attr' | 'html-attr' | 'table-attr', tag: string, key: string, equal?: string, value?: string, quotes?: string[], config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
-    /** 引号是否匹配 */
     get balanced(): boolean;
-    set value(arg: string | true);
-    /** getValue()的getter */
-    get value(): string | true;
-    /** 标签名 */
+    /**
+     * 标签名
+     * @browser
+     */
     get tag(): string;
-    type: "ext-attr" | "html-attr" | "table-attr";
+    /**
+     * getValue()的getter
+     * @browser
+     */
+    get value(): string | true;
+    set value(value: string | true);
+    /**
+     * @browser
+     * @param type 标签类型
+     * @param tag 标签名
+     * @param key 属性名
+     * @param equal 等号
+     * @param value 属性值
+     * @param quotes 引号
+     */
+    constructor(type: AttributeTypes, tag: string, key: string, equal?: string, value?: string, quotes?: [string?, string?], config?: Parser.Config, accum?: Token[]);
     /**
      * @override
-     * @param {string} selector
-     * @returns {string}
+     * @browser
      */
-    override toString(selector: string): string;
+    toString(selector?: string): string;
     /**
      * @override
-     * @returns {string}
+     * @browser
+     */
+    text(): string;
+    /**
+     * @override
+     * @browser
+     */
+    print(): string;
+    /**
+     * @override
+     * @browser
+     */
+    lint(start?: number): Parser.LintError[];
+    /**
+     * 获取属性值
+     * @browser
      */
-    override text(): string;
-    /** @override */
-    override print(): string;
-    /** 获取属性值 */
     getValue(): string | true;
     /** @override */
-    override cloneNode(): import("./attribute");
+    cloneNode(): this;
     /** 转义等号 */
     escape(): void;
     /** 闭合引号 */
     close(): void;
     /**
      * 设置属性值
-     * @param {string|boolean} value 参数值
+     * @param value 参数值
      * @throws `SyntaxError` 非法的标签属性
      */
     setValue(value: string | boolean): void;
     /**
      * 修改属性名
-     * @param {string} key 新属性名
+     * @param key 新属性名
      * @throws `Error` title属性不能更名
      * @throws `SyntaxError` 非法的模板参数名
      */
     rename(key: string): void;
-    #private;
 }
-declare namespace AttributeToken {
-    export { ParserConfig };
-}
-import Token = require(".");
-type ParserConfig = import('../../typings/token').ParserConfig;
+export = AttributeToken;