wikiparser-node 0.11.0 → 1.0.0-beta.1

package/dist/src/magicLink.d.ts

@@ -1,23 +1,31 @@
-export = MagicLinkToken;
+import * as Parser from '../index';
+import Token = require('.');
 /**
  * 自由外链
- * @classdesc `{childNodes: [...AstText|CommentToken|IncludeToken|NoincludeToken]}`
+ * @classdesc `{childNodes: ...AstText|CommentToken|IncludeToken|NoincludeToken}`
  */
 declare class MagicLinkToken extends Token {
-    /**
-     * @param {string} url 网址
-     * @param {boolean} doubleSlash 是否接受"//"作为协议
-     * @param {import('../../typings/token').accum} accum
-     */
-    constructor(url: string, doubleSlash: boolean, config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
-    set protocol(arg: string);
+    #private;
+    type: 'free-ext-link' | 'ext-link-url';
     /** 协议 */
-    get protocol(): string;
-    set link(arg: string);
+    get protocol(): string | undefined;
+    set protocol(value: string | undefined);
     /** 和内链保持一致 */
     get link(): string;
+    set link(url: string);
+    /**
+     * @browser
+     * @param url 网址
+     * @param doubleSlash 是否接受"//"作为协议
+     */
+    constructor(url: string | undefined, doubleSlash: boolean, config?: Parser.Config, accum?: Token[]);
+    /**
+     * @override
+     * @browser
+     */
+    lint(start?: number): Parser.LintError[];
     /** @override */
-    override cloneNode(): MagicLinkToken;
+    cloneNode(): this;
     /**
      * 获取网址
      * @throws `Error` 非标准协议
@@ -25,12 +33,11 @@ declare class MagicLinkToken extends Token {
     getUrl(): URL;
     /**
      * 设置外链目标
-     * @param {string|URL} url 含协议的网址
+     * @param url 含协议的网址
      * @throws `SyntaxError` 非法的自由外链目标
      */
     setTarget(url: string | URL): void;
     /** 是否是模板或魔术字参数 */
     isParamValue(): boolean;
-    #private;
 }
-import Token = require(".");
+export = MagicLinkToken;

package/dist/src/magicLink.js

@@ -0,0 +1,126 @@
+"use strict";
+const lint_1 = require("../util/lint");
+const Parser = require("../index");
+const Token = require(".");
+/**
+ * 自由外链
+ * @classdesc `{childNodes: ...AstText|CommentToken|IncludeToken|NoincludeToken}`
+ */
+class MagicLinkToken extends Token {
+    #protocolRegex;
+    /** 协议 */
+    get protocol() {
+        return this.#protocolRegex.exec(this.text())?.[0];
+    }
+    set protocol(value) {
+        if (typeof value !== 'string') {
+            this.typeError('protocol', 'String');
+        }
+        else if (!new RegExp(`${this.#protocolRegex.source}$`, 'iu').test(value)) {
+            throw new RangeError(`非法的外链协议：${value}`);
+        }
+        const { link } = this;
+        if (!this.#protocolRegex.test(link)) {
+            throw new Error(`特殊外链无法更改协议：${link}`);
+        }
+        this.replaceChildren(link.replace(this.#protocolRegex, value));
+    }
+    /** 和内链保持一致 */
+    get link() {
+        return this.text();
+    }
+    set link(url) {
+        this.setTarget(url);
+    }
+    /**
+     * @browser
+     * @param url 网址
+     * @param doubleSlash 是否接受"//"作为协议
+     */
+    constructor(url, doubleSlash, config = Parser.getConfig(), accum = []) {
+        super(url, config, true, accum, {
+            'Stage-1': ':', '!ExtToken': '',
+        });
+        this.type = doubleSlash ? 'ext-link-url' : 'free-ext-link';
+        this.#protocolRegex = new RegExp(`^(?:${config.protocol}${doubleSlash ? '|//' : ''})`, 'iu');
+    }
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start), source = `[，；。：！？（）]+${this.type === 'ext-link-url' ? '|\\|+' : ''}`, regex = new RegExp(source, 'u'), regexGlobal = new RegExp(source, 'gu');
+        let rect;
+        for (const child of this.childNodes) {
+            const str = String(child);
+            if (child.type !== 'text' || !regex.test(str)) {
+                continue;
+            }
+            rect ??= { start, ...this.getRootNode().posFromIndex(start) };
+            const refError = (0, lint_1.generateForChild)(child, rect, '', 'warning');
+            errors.push(...[...str.matchAll(regexGlobal)].map(({ index, 0: s }) => {
+                const lines = str.slice(0, index).split('\n'), { length: top } = lines, { length: left } = lines.at(-1), startIndex = start + index, startLine = refError.startLine + top - 1, startCol = (top > 1 ? 0 : refError.startCol) + left;
+                return {
+                    ...refError,
+                    message: Parser.msg('$1 in URL', s.startsWith('|') ? '"|"' : Parser.msg('full-width punctuation')),
+                    startIndex,
+                    endIndex: startIndex + s.length,
+                    startLine,
+                    endLine: startLine,
+                    startCol,
+                    endCol: startCol + s.length,
+                    excerpt: str.slice(Math.max(0, index - 25), index + 25),
+                };
+            }));
+        }
+        return errors;
+    }
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes();
+        return Parser.run(() => {
+            const token = new MagicLinkToken(undefined, this.type === 'ext-link-url', this.getAttribute('config'));
+            token.append(...cloned);
+            token.afterBuild();
+            return token;
+        });
+    }
+    /**
+     * 获取网址
+     * @throws `Error` 非标准协议
+     */
+    getUrl() {
+        let url = this.text();
+        if (url.startsWith('//')) {
+            url = `https:${url}`;
+        }
+        try {
+            return new URL(url);
+        }
+        catch (e) {
+            if (e instanceof TypeError && e.message === 'Invalid URL') {
+                throw new Error(`非标准协议的外部链接：${url}`);
+            }
+            throw e;
+        }
+    }
+    /**
+     * 设置外链目标
+     * @param url 含协议的网址
+     * @throws `SyntaxError` 非法的自由外链目标
+     */
+    setTarget(url) {
+        const strUrl = String(url), root = Parser.parse(strUrl, this.getAttribute('include'), 9, this.getAttribute('config')), { length, firstChild: freeExtLink } = root;
+        if (length !== 1 || freeExtLink.type !== 'free-ext-link') {
+            throw new SyntaxError(`非法的自由外链目标：${strUrl}`);
+        }
+        this.replaceChildren(...freeExtLink.childNodes);
+    }
+    /** 是否是模板或魔术字参数 */
+    isParamValue() {
+        const parameter = this.closest('parameter');
+        return parameter?.getValue() === this.text();
+    }
+}
+Parser.classes['MagicLinkToken'] = __filename;
+module.exports = MagicLinkToken;

package/dist/src/nested.d.ts

@@ -0,0 +1,47 @@
+import * as Parser from '../index';
+import Token = require('.');
+import ExtToken = require('./tagPair/ext');
+import NoincludeToken = require('./nowiki/noinclude');
+import CommentToken = require('./nowiki/comment');
+import AttributesToken = require('./attributes');
+/**
+ * 嵌套式的扩展标签
+ * @classdesc `{childNodes: ...ExtToken|NoincludeToken|CommentToken}`
+ */
+declare abstract class NestedToken extends Token {
+    #private;
+    /** @browser */
+    readonly type = "ext-inner";
+    childNodes: (ExtToken | NoincludeToken | CommentToken)[];
+    abstract get children(): (ExtToken | NoincludeToken | CommentToken)[];
+    abstract get firstChild(): ExtToken | NoincludeToken | CommentToken | undefined;
+    abstract get firstElementChild(): ExtToken | NoincludeToken | CommentToken | undefined;
+    abstract get lastChild(): ExtToken | NoincludeToken | CommentToken | undefined;
+    abstract get lastElementChild(): ExtToken | NoincludeToken | CommentToken | undefined;
+    abstract get nextSibling(): undefined;
+    abstract get nextElementSibling(): undefined;
+    abstract get previousSibling(): AttributesToken;
+    abstract get previousElementSibling(): AttributesToken;
+    abstract get parentNode(): ExtToken | undefined;
+    abstract get parentElement(): ExtToken | undefined;
+    /**
+     * @browser
+     * @param regex 内层正则
+     * @param tags 内层标签名
+     */
+    constructor(wikitext: string | undefined, regex: RegExp, tags: string[], config?: Parser.Config, accum?: Token[]);
+    /**
+     * @override
+     * @browser
+     */
+    lint(start?: number): Parser.LintError[];
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt<T extends Token>(token: T, i?: number): T;
+    /** @override */
+    cloneNode(): this;
+}
+export = NestedToken;

package/dist/src/nested.js

@@ -0,0 +1,84 @@
+"use strict";
+const lint_1 = require("../util/lint");
+const Parser = require("../index");
+const Token = require(".");
+const ExtToken = require("./tagPair/ext");
+const NoincludeToken = require("./nowiki/noinclude");
+const CommentToken = require("./nowiki/comment");
+/**
+ * 嵌套式的扩展标签
+ * @classdesc `{childNodes: ...ExtToken|NoincludeToken|CommentToken}`
+ */
+class NestedToken extends Token {
+    /** @browser */
+    type = 'ext-inner';
+    #tags;
+    #regex;
+    /**
+     * @browser
+     * @param regex 内层正则
+     * @param tags 内层标签名
+     */
+    constructor(wikitext, regex, tags, config = Parser.getConfig(), accum = []) {
+        const text = wikitext?.replace(regex, (comment, name, attr, inner, closing) => {
+            const str = `\0${accum.length + 1}${name ? 'e' : 'c'}\x7F`;
+            if (name) {
+                new ExtToken(name, attr, inner, closing, config, accum);
+            }
+            else {
+                const closed = comment.endsWith('-->');
+                new CommentToken(comment.slice(4, closed ? -3 : undefined), closed, config, accum);
+            }
+            return str;
+        })?.replace(/(?<=^|\0\d+[ce]\x7F)[^\0]+(?=$|\0\d+[ce]\x7F)/gu, substr => {
+            new NoincludeToken(substr, config, accum);
+            return `\0${accum.length}c\x7F`;
+        });
+        super(text, config, true, accum, {
+            NoincludeToken: ':', ExtToken: ':',
+        });
+        this.#tags = tags;
+        this.#regex = regex;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        let rect;
+        return [
+            ...super.lint(start),
+            ...this.childNodes.filter(child => {
+                if (child.type === 'ext' || child.type === 'comment') {
+                    return false;
+                }
+                const str = String(child).trim();
+                return str && !/^<!--.*-->$/su.test(str);
+            }).map(child => {
+                rect ??= { start, ...this.getRootNode().posFromIndex(start) };
+                return (0, lint_1.generateForChild)(child, rect, Parser.msg('invalid content in <$1>', this.name));
+            }),
+        ];
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt(token, i = this.length) {
+        return typeof token !== 'string' && token.type === 'ext' && !this.#tags.includes(token.name)
+            ? this.typeError(`${this.constructor.name}只能以${this.#tags.join('或')}标签作为子节点！`)
+            : super.insertAt(token, i);
+    }
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), config = this.getAttribute('config');
+        return Parser.run(() => {
+            const token = new NestedToken(undefined, this.#regex, this.#tags, config);
+            token.append(...cloned);
+            return token;
+        });
+    }
+}
+Parser.classes['NestedToken'] = __filename;
+module.exports = NestedToken;

package/dist/src/nowiki/base.d.ts

@@ -0,0 +1,39 @@
+import * as Parser from '../../index';
+import Token = require('..');
+import AstText = require('../../lib/text');
+declare type NowikiTypes = 'ext-inner' | 'comment' | 'dd' | 'double-underscore' | 'hr' | 'list' | 'noinclude' | 'quote';
+declare const NowikiBaseToken_base: ((abstract new (...args: any[]) => {
+    removeAt(): never;
+    insertAt(token: string, i?: number | undefined): AstText;
+    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;
+/**
+ * 纯文字Token，不会被解析
+ * @classdesc `{childNodes: [AstText]}`
+ */
+declare abstract class NowikiBaseToken extends NowikiBaseToken_base {
+    type: NowikiTypes;
+    childNodes: [AstText];
+    abstract get children(): [];
+    abstract get firstChild(): AstText;
+    abstract get firstElementChild(): undefined;
+    abstract get lastChild(): AstText;
+    abstract get lastElementChild(): undefined;
+    /** @browser */
+    constructor(wikitext: string, config?: Parser.Config, accum?: Token[]);
+    /** @override */
+    cloneNode(this: this & {
+        constructor: new (...args: unknown[]) => unknown;
+    }): this;
+    /**
+     * @override
+     * @param str 新文本
+     */
+    setText(str: string): string;
+}
+export = NowikiBaseToken;

package/dist/src/nowiki/base.js

@@ -0,0 +1,29 @@
+"use strict";
+const fixed = require("../../mixin/fixed");
+const Parser = require("../../index");
+const Token = require("..");
+/**
+ * 纯文字Token，不会被解析
+ * @classdesc `{childNodes: [AstText]}`
+ */
+class NowikiBaseToken extends fixed(Token) {
+    /** @browser */
+    constructor(wikitext, config = Parser.getConfig(), accum = []) {
+        super(wikitext, config, true, accum);
+    }
+    /** @override */
+    cloneNode() {
+        const { constructor, firstChild: { data }, type } = this, token = Parser.run(() => new constructor(data, this.getAttribute('config')));
+        token.type = type;
+        return token;
+    }
+    /**
+     * @override
+     * @param str 新文本
+     */
+    setText(str) {
+        return super.setText(str, 0);
+    }
+}
+Parser.classes['NowikiBaseToken'] = __filename;
+module.exports = NowikiBaseToken;

package/dist/src/nowiki/comment.d.ts

@@ -1,31 +1,42 @@
-export = CommentToken;
-/**
- * HTML注释，不可见
- * @classdesc `{childNodes: [AstText]}`
- */
-declare class CommentToken extends NowikiToken {
-    /**
-     * @param {string} wikitext wikitext
-     * @param {boolean} closed 是否闭合
-     * @param {import('../../../typings/token').accum} accum
-     */
-    constructor(wikitext: string, closed?: boolean, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum);
+import * as Parser from '../../index';
+import Token = require('..');
+import NowikiBaseToken = require('./base');
+declare const CommentToken_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 NowikiBaseToken;
+/** HTML注释，不可见 */
+declare abstract class CommentToken extends CommentToken_base {
+    /** @browser */
+    readonly type = "comment";
     closed: boolean;
     /** 内部wikitext */
     get innerText(): string;
-    /** @override */
-    override print(): string;
+    /**
+     * @browser
+     * @param closed 是否闭合
+     */
+    constructor(wikitext: string, closed?: boolean, config?: Parser.Config, accum?: Token[]);
     /**
      * @override
-     * @param {number} start 起始位置
+     * @browser
      */
-    override lint(start?: number): any;
+    print(): string;
     /**
      * @override
-     * @param {string} selector
+     * @browser
      */
-    override toString(selector: string): string;
+    lint(start?: number): Parser.LintError[];
+    /**
+     * @override
+     * @browser
+     */
+    toString(selector?: string): string;
     /** @override */
-    override cloneNode(): CommentToken;
+    cloneNode(): this;
 }
-import NowikiToken = require(".");
+export = CommentToken;

package/dist/src/nowiki/comment.js

@@ -0,0 +1,61 @@
+"use strict";
+const hidden = require("../../mixin/hidden");
+const lint_1 = require("../../util/lint");
+const Parser = require("../../index");
+const NowikiBaseToken = require("./base");
+/** HTML注释，不可见 */
+class CommentToken extends hidden(NowikiBaseToken) {
+    /** @browser */
+    type = 'comment';
+    closed;
+    /** 内部wikitext */
+    get innerText() {
+        return this.firstChild.data;
+    }
+    /**
+     * @browser
+     * @param closed 是否闭合
+     */
+    constructor(wikitext, closed = true, config = Parser.getConfig(), accum = []) {
+        super(wikitext, config, accum);
+        this.closed = closed;
+        Object.defineProperty(this, 'closed', { enumerable: false });
+    }
+    /** @private */
+    getPadding() {
+        return 4;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    print() {
+        return super.print({ pre: '<!--', post: this.closed ? '-->' : '' });
+    }
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        return this.closed ? [] : [(0, lint_1.generateForSelf)(this, { start }, 'unclosed HTML comment')];
+    }
+    /**
+     * @override
+     * @browser
+     */
+    toString(selector) {
+        if (!this.closed && this.nextSibling) {
+            Parser.error('自动闭合HTML注释', this);
+            this.closed = true;
+        }
+        return selector && this.matches(selector)
+            ? ''
+            : `<!--${this.firstChild.data}${this.closed ? '-->' : ''}`;
+    }
+    /** @override */
+    cloneNode() {
+        return Parser.run(() => new CommentToken(this.firstChild.data, this.closed, this.getAttribute('config')));
+    }
+}
+Parser.classes['CommentToken'] = __filename;
+module.exports = CommentToken;

package/dist/src/nowiki/dd.d.ts

@@ -1,17 +1,23 @@
-export = DdToken;
-/**
- * :
- * @classdesc `{childNodes: [AstText]}`
- */
-declare class DdToken extends NowikiToken {
-    /** 是否包含<dt> */
+import NowikiBaseToken = require('./base');
+/** `:` */
+declare abstract class DdToken extends NowikiBaseToken {
+    /** @browser */
+    readonly type: 'dd' | 'list';
+    /** 是否包含`;` */
     get dt(): boolean;
-    /** 是否包含<ul> */
+    /** 是否包含`*` */
     get ul(): boolean;
-    /** 是否包含<ol> */
+    /** 是否包含`#` */
     get ol(): boolean;
-    set indent(arg: number);
     /** 缩进数 */
     get indent(): number;
+    /** @throws `RangeError` indent不是自然数 */
+    set indent(indent: number);
+    /**
+     * @override
+     * @param str 新文本
+     * @throws `RangeError` 错误的列表语法
+     */
+    setText(str: string): string;
 }
-import NowikiToken = require(".");
+export = DdToken;

package/dist/src/nowiki/dd.js

@@ -0,0 +1,50 @@
+"use strict";
+const Parser = require("../../index");
+const NowikiBaseToken = require("./base");
+/** `:` */
+class DdToken extends NowikiBaseToken {
+    /** @browser */
+    type = 'dd';
+    /** 是否包含`;` */
+    get dt() {
+        return this.firstChild.data.includes(';');
+    }
+    /** 是否包含`*` */
+    get ul() {
+        return this.firstChild.data.includes('*');
+    }
+    /** 是否包含`#` */
+    get ol() {
+        return this.firstChild.data.includes('#');
+    }
+    /** 缩进数 */
+    get indent() {
+        return this.firstChild.data.split(':').length - 1;
+    }
+    /** @throws `RangeError` indent不是自然数 */
+    set indent(indent) {
+        if (this.type === 'dd') {
+            if (!Number.isInteger(indent)) {
+                this.typeError('indent setter', 'Number');
+            }
+            else if (indent < 0) {
+                throw new RangeError('indent 应为自然数！');
+            }
+            this.setText(':'.repeat(indent));
+        }
+    }
+    /**
+     * @override
+     * @param str 新文本
+     * @throws `RangeError` 错误的列表语法
+     */
+    setText(str) {
+        const src = this.type === 'dd' ? ':' : ';:*#';
+        if (new RegExp(`[^${src}]`, 'u').test(str)) {
+            throw new RangeError(`${this.constructor.name} 仅能包含${[...src].map(c => `"${c}"`).join('、')}！`);
+        }
+        return super.setText(str);
+    }
+}
+Parser.classes['DdToken'] = __filename;
+module.exports = DdToken;

package/dist/src/nowiki/doubleUnderscore.d.ts

@@ -1,22 +1,37 @@
-export = DoubleUnderscoreToken;
-/**
- * 状态开关
- * @classdesc `{childNodes: [AstText]}`
- */
-declare class DoubleUnderscoreToken extends NowikiToken {
-    /** @override */
-    override print(): string;
+import * as Parser from '../../index';
+import NowikiBaseToken = require('./base');
+import Token = require('..');
+declare const DoubleUnderscoreToken_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 NowikiBaseToken;
+/** 状态开关 */
+declare abstract class DoubleUnderscoreToken extends DoubleUnderscoreToken_base {
+    /** @browser */
+    readonly type = "double-underscore";
+    name: string;
+    /**
+     * @override
+     * @browser
+     */
+    print(): string;
     /**
      * @override
-     * @param {string} selector
+     * @browser
      */
-    override toString(selector: string): string;
+    toString(selector?: string): string;
+    /** @param word 状态开关名 */
+    constructor(word: string, config?: Parser.Config, accum?: Token[]);
     /** @override */
-    override cloneNode(): DoubleUnderscoreToken;
+    cloneNode(): this;
     /**
      * @override
      * @throws `Error` 禁止修改
      */
-    override setText(): void;
+    setText(): never;
 }
-import NowikiToken = require(".");
+export = DoubleUnderscoreToken;