wikiparser-node 0.11.0 → 1.0.0-beta.0

package/dist/src/gallery.js

@@ -0,0 +1,132 @@
+"use strict";
+const Parser = require("../index");
+const Token = require(".");
+const GalleryImageToken = require("./link/galleryImage");
+const HiddenToken = require("./hidden");
+/**
+ * gallery标签
+ * @classdesc `{childNodes: ...(GalleryImageToken|HiddenToken|AstText)}`
+ */
+class GalleryToken extends Token {
+    /** @browser */
+    type = 'ext-inner';
+    /** 所有图片 */
+    get images() {
+        return this.childNodes.filter(({ type }) => type === 'gallery-image');
+    }
+    /**
+     * @browser
+     * @param inner 标签内部wikitext
+     */
+    constructor(inner, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, true, accum, {
+            AstText: ':', GalleryImageToken: ':', HiddenToken: ':',
+        });
+        for (const line of inner?.split('\n') ?? []) {
+            const matches = /^([^|]+)(?:\|(.*))?/u.exec(line);
+            if (!matches) {
+                super.insertAt((line.trim()
+                    ? new HiddenToken(line, config, [], {
+                        AstText: ':',
+                    })
+                    : line));
+                continue;
+            }
+            const [, file, alt] = matches, title = this.normalizeTitle(file, 6, true, true);
+            if (title.valid) {
+                super.insertAt(new GalleryImageToken('gallery', file, alt, config, accum));
+            }
+            else {
+                super.insertAt(new HiddenToken(line, config, [], {
+                    AstText: ':',
+                }));
+            }
+        }
+    }
+    /**
+     * @override
+     * @browser
+     */
+    toString(selector) {
+        return super.toString(selector, '\n');
+    }
+    /**
+     * @override
+     * @browser
+     */
+    text() {
+        return super.text('\n').replace(/\n\s*\n/gu, '\n');
+    }
+    /** @private */
+    getGaps() {
+        return 1;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    print() {
+        return super.print({ sep: '\n' });
+    }
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        const { top, left } = this.getRootNode().posFromIndex(start), errors = [];
+        for (let i = 0, startIndex = start; i < this.length; i++) {
+            const child = this.childNodes[i], str = String(child), { length } = str, trimmed = str.trim(), startLine = top + i, startCol = i ? 0 : left;
+            if (child.type === 'hidden' && trimmed && !/^<!--.*-->$/u.test(trimmed)) {
+                errors.push({
+                    message: Parser.msg('invalid content in <$1>', 'gallery'),
+                    severity: 'error',
+                    startIndex,
+                    endIndex: startIndex + length,
+                    startLine,
+                    endLine: startLine,
+                    startCol,
+                    endCol: startCol + length,
+                    excerpt: String(child).slice(0, 50),
+                });
+            }
+            else if (child.type !== 'hidden' && child.type !== 'text') {
+                errors.push(...child.lint(startIndex));
+            }
+            startIndex += length + 1;
+        }
+        return errors;
+    }
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes();
+        return Parser.run(() => {
+            const token = new GalleryToken(undefined, this.getAttribute('config'));
+            token.append(...cloned);
+            return token;
+        });
+    }
+    /**
+     * 插入图片
+     * @param file 图片文件名
+     * @param i 插入位置
+     * @throws `SyntaxError` 非法的文件名
+     */
+    insertImage(file, i = this.length) {
+        const title = this.normalizeTitle(file, 6, true, true);
+        if (title.valid) {
+            const token = Parser.run(
+            () => new GalleryImageToken('gallery', file, undefined, this.getAttribute('config')));
+            return this.insertAt(token, i);
+        }
+        throw new SyntaxError(`非法的文件名：${file}`);
+    }
+    /** @ignore */
+    insertAt(token, i = 0) {
+        if (typeof token === 'string' && token.trim() || token instanceof HiddenToken) {
+            throw new RangeError('请勿向图库中插入不可见内容！');
+        }
+        return super.insertAt(token, i);
+    }
+}
+Parser.classes['GalleryToken'] = __filename;
+module.exports = GalleryToken;

package/dist/src/heading.d.ts

@@ -1,44 +1,82 @@
-export = HeadingToken;
+import * as Parser from '../index';
+import Token = require('.');
+import SyntaxToken = require('./syntax');
+declare const HeadingToken_base: (abstract new (...args: any[]) => {
+    "__#14@#isRoot"(): boolean;
+    prependNewLine(): string;
+    toString(selector?: string | undefined): string; /** 内部wikitext */
+    getPadding(): number;
+    text(): string;
+    length: number;
+    insertAt(token: unknown, i?: number | undefined): unknown;
+}) & ((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;
 /**
  * 章节标题
  * @classdesc `{childNodes: [Token, SyntaxToken]}`
  */
-declare class HeadingToken extends Token {
+declare abstract class HeadingToken extends HeadingToken_base {
+    #private;
+    /** @browser */
+    readonly type = "heading";
+    name: string;
+    childNodes: [Token, SyntaxToken];
+    abstract get children(): [Token, SyntaxToken];
+    abstract get firstChild(): Token;
+    abstract get firstElementChild(): Token;
+    abstract get lastChild(): SyntaxToken;
+    abstract get lastElementChild(): SyntaxToken;
     /**
-     * @param {number} level 标题层级
-     * @param {string[]} input 标题文字
-     * @param {import('../../typings/token').accum} accum
+     * 标题层级
+     * @browser
      */
-    constructor(level: number, input: string[], config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
+    get level(): number;
+    /** @throws `RangeError` 标题层级应为 1 - 6 之间的整数 */
+    set level(n: number);
     /** 内部wikitext */
     get innerText(): string;
+    /**
+     * @browser
+     * @param level 标题层级
+     * @param input 标题文字
+     */
+    constructor(level: number, input: string[], config?: Parser.Config, accum?: Token[]);
     /**
      * @override
-     * @this {{prependNewLine(): ''|'\n'} & HeadingToken}
-     * @param {string} selector
-     * @returns {string}
+     * @browser
      */
-    override toString(this: {
-        prependNewLine(): '' | '\n';
-    } & HeadingToken, selector: string): string;
+    toString(selector?: string): string;
     /**
      * @override
-     * @this {HeadingToken & {prependNewLine(): ''|'\n'}}
-     * @returns {string}
+     * @browser
      */
-    override text(this: HeadingToken & {
-        prependNewLine(): '' | '\n';
-    }): string;
-    /** @override */
-    override print(): string;
+    text(): string;
+    /**
+     * @override
+     * @browser
+     */
+    print(): string;
+    /**
+     * @override
+     * @browser
+     */
+    lint(start?: number): Parser.LintError[];
     /** @override */
-    override cloneNode(): HeadingToken;
+    cloneNode(): this;
     /**
      * 设置标题层级
-     * @param {number} n 标题层级
+     * @param n 标题层级
      */
     setLevel(n: number): void;
     /** 移除标题后的不可见内容 */
     removeTrail(): void;
 }
-import Token = require(".");
+export = HeadingToken;

package/dist/src/heading.js

@@ -0,0 +1,135 @@
+"use strict";
+const lint_1 = require("../util/lint");
+const fixed = require("../mixin/fixed");
+const sol = require("../mixin/sol");
+const Parser = require("../index");
+const Token = require(".");
+const SyntaxToken = require("./syntax");
+/**
+ * 章节标题
+ * @classdesc `{childNodes: [Token, SyntaxToken]}`
+ */
+class HeadingToken extends sol(fixed(Token)) {
+    /** @browser */
+    type = 'heading';
+    /**
+     * 标题层级
+     * @browser
+     */
+    get level() {
+        return Number(this.name);
+    }
+    /** @throws `RangeError` 标题层级应为 1 - 6 之间的整数 */
+    set level(n) {
+        this.setLevel(n);
+    }
+    /**
+     * 标题格式的等号
+     * @browser
+     */
+    get #equals() {
+        return '='.repeat(this.level);
+    }
+    /** 内部wikitext */
+    get innerText() {
+        return this.firstChild.text();
+    }
+    /**
+     * @browser
+     * @param level 标题层级
+     * @param input 标题文字
+     */
+    constructor(level, input, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, true, accum);
+        this.setAttribute('name', String(level));
+        const token = new Token(input[0], config, true, accum);
+        token.type = 'heading-title';
+        token.setAttribute('stage', 2);
+        const trail = new SyntaxToken(input[1], /^[^\S\n]*$/u, 'heading-trail', config, accum, {
+            'Stage-1': ':', '!ExtToken': '',
+        });
+        this.append(token, trail);
+    }
+    /**
+     * @override
+     * @browser
+     */
+    toString(selector) {
+        const equals = this.#equals;
+        return selector && this.matches(selector)
+            ? ''
+            : `${this.prependNewLine()}${equals}${this.firstChild.toString(selector)}${equals}${this.lastChild.toString(selector)}`;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    text() {
+        const equals = this.#equals;
+        return `${this.prependNewLine()}${equals}${this.firstChild.text()}${equals}`;
+    }
+    /** @private */
+    getPadding() {
+        return super.getPadding() + this.level;
+    }
+    /** @private */
+    getGaps() {
+        return this.level;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    print() {
+        const equals = this.#equals;
+        return super.print({ pre: equals, sep: equals });
+    }
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start), innerStr = String(this.firstChild);
+        let refError;
+        if (this.name === '1') {
+            refError = (0, lint_1.generateForSelf)(this, { start }, '<h1>');
+            errors.push(refError);
+        }
+        if (innerStr.startsWith('=') || innerStr.endsWith('=')) {
+            refError ??= (0, lint_1.generateForSelf)(this, { start }, '');
+            errors.push({ ...refError, message: Parser.msg('unbalanced "=" in a section header') });
+        }
+        if (this.closest('html-attrs, table-attrs')) {
+            refError ??= (0, lint_1.generateForSelf)(this, { start }, '');
+            errors.push({ ...refError, message: Parser.msg('section header in a HTML tag') });
+        }
+        return errors;
+    }
+    /** @override */
+    cloneNode() {
+        const [title, trail] = this.cloneChildNodes();
+        return Parser.run(() => {
+            const token = new HeadingToken(this.level, [], this.getAttribute('config'));
+            token.firstChild.safeReplaceWith(title);
+            token.lastChild.safeReplaceWith(trail);
+            return token;
+        });
+    }
+    /**
+     * 设置标题层级
+     * @param n 标题层级
+     */
+    setLevel(n) {
+        if (!Number.isInteger(n)) {
+            this.typeError('setLevel', 'Number');
+        }
+        const level = String(Math.min(Math.max(n, 1), 6));
+        this.setAttribute('name', level);
+    }
+    /** 移除标题后的不可见内容 */
+    removeTrail() {
+        this.lastChild.replaceChildren();
+    }
+}
+Parser.classes['HeadingToken'] = __filename;
+module.exports = HeadingToken;

package/dist/src/hidden.d.ts

@@ -0,0 +1,20 @@
+import * as Parser from '../index';
+import Token = require('.');
+declare const HiddenToken_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 Token;
+/** 不可见的节点 */
+declare class HiddenToken extends HiddenToken_base {
+    /** @browser */
+    readonly type = "hidden";
+    /** @browser */
+    constructor(wikitext?: string, config?: Parser.Config, accum?: Token[], acceptable?: Acceptable);
+    /** @override */
+    cloneNode(): this;
+}
+export = HiddenToken;

package/dist/src/hidden.js

@@ -0,0 +1,24 @@
+"use strict";
+const hidden = require("../mixin/hidden");
+const Parser = require("../index");
+const Token = require(".");
+/** 不可见的节点 */
+class HiddenToken extends hidden(Token) {
+    /** @browser */
+    type = 'hidden';
+    /** @browser */
+    constructor(wikitext, config = Parser.getConfig(), accum = [], acceptable) {
+        super(wikitext, config, true, accum, acceptable);
+    }
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), config = this.getAttribute('config'), acceptable = this.getAttribute('acceptable');
+        return Parser.run(() => {
+            const token = new HiddenToken(undefined, config, [], acceptable);
+            token.append(...cloned);
+            return token;
+        });
+    }
+}
+Parser.classes['HiddenToken'] = __filename;
+module.exports = HiddenToken;

package/dist/src/html.d.ts

@@ -1,56 +1,110 @@
-export = HtmlToken;
+import * as Parser from '../index';
+import Token = require('.');
+import AttributesToken = require('./attributes');
+import type { TokenAttributeGetter } from '../lib/node';
+declare const HtmlToken_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;
+}) & ((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: [AttributesToken]}`
  */
-declare class HtmlToken extends Token {
-    /**
-     * @param {string} name 标签名
-     * @param {AttributesToken} attr 标签属性
-     * @param {boolean} closing 是否闭合
-     * @param {boolean} selfClosing 是否自封闭
-     * @param {import('../../typings/token').accum} accum
-     */
-    constructor(name: string, attr: AttributesToken, closing: boolean, selfClosing: boolean, config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
-    /** @throws `Error` 自闭合标签或空标签 */
-    set closing(arg: boolean);
-    /** getter */
+declare abstract class HtmlToken extends HtmlToken_base {
+    #private;
+    /** @browser */
+    readonly type = "html";
+    name: string;
+    childNodes: [AttributesToken];
+    abstract get children(): [AttributesToken];
+    abstract get firstChild(): AttributesToken;
+    abstract get firstElementChild(): AttributesToken;
+    abstract get lastChild(): AttributesToken;
+    abstract get lastElementChild(): AttributesToken;
+    /**
+     * 是否是闭合标签
+     * @browser
+     */
     get closing(): boolean;
-    /** @throws `Error` 闭合标签或无效自闭合标签 */
-    set selfClosing(arg: boolean);
-    /** getter */
+    /** @throws `Error` 自封闭标签或空标签 */
+    set closing(value: boolean);
+    /** 是否自封闭 */
     get selfClosing(): boolean;
+    /** @throws `Error` 闭合标签或无效自封闭标签 */
+    set selfClosing(value: boolean);
+    /**
+     * @browser
+     * @param name 标签名
+     * @param attr 标签属性
+     * @param closing 是否闭合
+     * @param selfClosing 是否自封闭
+     */
+    constructor(name: string, attr: AttributesToken, closing: boolean, selfClosing: boolean, config?: Parser.Config, accum?: Token[]);
     /**
      * @override
-     * @param {string} selector
+     * @browser
      */
-    override toString(selector: string): string;
-    /** @override */
-    override text(): string;
-    /** @override */
-    override print(): string;
+    toString(selector?: string): string;
+    /**
+     * @override
+     * @browser
+     */
+    text(): string;
+    /**
+     * @override
+     * @browser
+     */
+    print(): string;
+    /**
+     * @override
+     * @browser
+     */
+    lint(start?: number): Parser.LintError[];
     /**
      * 搜索匹配的标签
-     * @complexity `n`
+     * @browser
      * @throws `SyntaxError` 同时闭合和自封闭的标签
      * @throws `SyntaxError` 无效自封闭标签
      * @throws `SyntaxError` 未闭合的标签
      */
-    findMatchingTag(): this | HtmlToken;
+    findMatchingTag(): this | undefined;
     /** @override */
-    override cloneNode(): HtmlToken;
+    cloneNode(): this;
     /**
      * 更换标签名
-     * @param {string} tag 标签名
+     * @param tag 标签名
      * @throws `RangeError` 非法的HTML标签
      */
     replaceTag(tag: string): void;
     /**
      * 修复无效自封闭标签
-     * @complexity `n`
      * @throws `Error` 无法修复无效自封闭标签
      */
     fix(): void;
-    #private;
 }
-import Token = require(".");
+export = HtmlToken;