wikiparser-node 0.11.0 → 1.0.0-beta.0

package/dist/src/converterRule.js

@@ -0,0 +1,255 @@
+"use strict";
+const debug_1 = require("../util/debug");
+const string_1 = require("../util/string");
+const Parser = require("../index");
+const Token = require(".");
+const AtomToken = require("./atom");
+/**
+ * 转换规则
+ * @classdesc `{childNodes: ...AtomToken}`
+ */
+class ConverterRuleToken extends Token {
+    /** @browser */
+    type = 'converter-rule';
+    /** 语言变体 */
+    get variant() {
+        return this.childNodes.at(-2)?.text()?.trim() ?? '';
+    }
+    set variant(variant) {
+        this.setVariant(variant);
+    }
+    /** 是否是单向转换 */
+    get unidirectional() {
+        return this.length === 3;
+    }
+    /** @throws `Error` 不能用于将双向转换或不转换更改为单向转换 */
+    set unidirectional(flag) {
+        const { length } = this;
+        if (length === 3 && !flag) {
+            this.makeBidirectional();
+        }
+        else if (length === 2 && flag) {
+            throw new Error('想更改为单向转换请使用 makeUnidirectional 方法！');
+        }
+        else if (length === 1 && flag) {
+            throw new Error('想更改为单向转换请先使用 setVariant 方法指定语言变体！');
+        }
+    }
+    /** 是否是双向转换 */
+    get bidirectional() {
+        return this.length === 2;
+    }
+    /** @throws `Error` 不能用于将双向转换更改为单向转换或将不转换更改为双向转换 */
+    set bidirectional(flag) {
+        const { length } = this;
+        if (length === 3 && flag) {
+            this.makeBidirectional();
+        }
+        else if (length === 2 && !flag) {
+            throw new Error('想更改为单向转换请使用 makeUnidirectional 方法！');
+        }
+        else if (length === 1 && flag) {
+            throw new Error('想更改为双向转换请使用 setVariant 方法！');
+        }
+    }
+    /**
+     * @browser
+     * @param rule 转换规则
+     * @param hasColon 是否带有":"
+     */
+    constructor(rule, hasColon = true, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, true, accum);
+        if (hasColon) {
+            const i = rule.indexOf(':'), j = rule.slice(0, i).indexOf('=>'), v = j === -1 ? rule.slice(0, i) : rule.slice(j + 2, i);
+            if (config.variants.includes(v.trim())) {
+                super.insertAt(new AtomToken(v, 'converter-rule-variant', config, accum));
+                super.insertAt(new AtomToken(rule.slice(i + 1), 'converter-rule-to', config, accum));
+                if (j !== -1) {
+                    super.insertAt(new AtomToken(rule.slice(0, j), 'converter-rule-from', config, accum), 0);
+                }
+            }
+            else {
+                super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
+            }
+        }
+        else {
+            super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
+        }
+        this.protectChildren('1:');
+    }
+    /**
+     * @override
+     * @browser
+     */
+    toString(selector) {
+        const { childNodes } = this;
+        if (childNodes.length === 3 && !(selector && this.matches(selector))) {
+            const [from, variant, to] = childNodes;
+            return `${from.toString(selector)}=>${variant.toString(selector)}:${to.toString(selector)}`;
+        }
+        return super.toString(selector, ':');
+    }
+    /**
+     * @override
+     * @browser
+     */
+    text() {
+        const { childNodes } = this;
+        if (childNodes.length === 3) {
+            const [from, variant, to] = childNodes;
+            return `${from.text()}=>${variant.text()}:${to.text()}`;
+        }
+        return super.text(':');
+    }
+    /** @private */
+    getGaps(i = 0) {
+        const { length } = this, j = i < 0 ? i + length : i;
+        return j === 0 && length === 3 ? 2 : 1;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    print() {
+        const { childNodes } = this;
+        if (childNodes.length === 3) {
+            const [from, variant, to] = childNodes;
+            return `<span class="wpb-converter-rule">${from.print()}=>${variant.print()}:${to.print()}</span>`;
+        }
+        return super.print({ sep: ':' });
+    }
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), placeholders = ['', 'zh:', '=>zh:'], placeholder = placeholders[cloned.length - 1];
+        return Parser.run(() => {
+            const token = new ConverterRuleToken(placeholder, placeholder, this.getAttribute('config'));
+            for (let i = 0; i < cloned.length; i++) {
+                token.childNodes[i].safeReplaceWith(cloned[i]);
+            }
+            token.afterBuild();
+            return token;
+        });
+    }
+    /** @private */
+    afterBuild() {
+        const /** @implements */ converterRuleListener = (e, data) => {
+            const { prevTarget } = e;
+            if (this.length > 1 && this.childNodes.at(-2) === prevTarget) {
+                const v = prevTarget.text().trim(), { variants } = this.getAttribute('config');
+                if (!variants.includes(v)) {
+                    (0, debug_1.undo)(e, data);
+                    throw new Error(`无效的语言变体：${v}`);
+                }
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'text', 'replace'], converterRuleListener);
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     * @throws `Error` 至少保留1个子节点
+     */
+    removeAt(i) {
+        if (this.length === 1) {
+            throw new Error(`${this.constructor.name} 需至少保留 1 个子节点！`);
+        }
+        const removed = super.removeAt(i);
+        if (this.length === 1) {
+            this.firstChild.type = 'converter-rule-noconvert';
+        }
+        return removed;
+    }
+    /**
+     * @override
+     * @throws `Error` 请勿手动插入子节点
+     */
+    insertAt() {
+        throw new Error(`转换规则语法复杂，请勿尝试对 ${this.constructor.name} 手动插入子节点！`);
+    }
+    /** 修改为不转换 */
+    noConvert() {
+        const { length } = this;
+        for (let i = 0; i < length - 1; i++) { // ConverterRuleToken只能从前往后删除子节点
+            this.removeAt(0);
+        }
+    }
+    /**
+     * 设置转换目标
+     * @param to 转换目标
+     * @throws `SyntaxError` 非法的转换目标
+     */
+    setTo(to) {
+        const config = this.getAttribute('config'), include = this.getAttribute('include'), root = Parser.parse(`-{|${config.variants[0] ?? 'zh'}:${to}}-`, include, undefined, config), { length, firstChild: converter } = root;
+        if (length !== 1 || converter.type !== 'converter') {
+            throw new SyntaxError(`非法的转换目标：${(0, string_1.noWrap)(to)}`);
+        }
+        const { lastChild: converterRule } = converter;
+        if (converter.length !== 2 || converterRule.length !== 2) {
+            throw new SyntaxError(`非法的转换目标：${(0, string_1.noWrap)(to)}`);
+        }
+        const { lastChild } = converterRule;
+        converterRule.destroy();
+        this.lastChild.safeReplaceWith(lastChild);
+    }
+    /**
+     * 设置语言变体
+     * @param variant 语言变体
+     * @throws `RangeError` 无效的语言变体
+     */
+    setVariant(variant) {
+        if (typeof variant !== 'string') {
+            this.typeError('setVariant', 'String');
+        }
+        const config = this.getAttribute('config'), v = variant.trim();
+        if (!config.variants.includes(v)) {
+            throw new RangeError(`无效的语言变体：${v}`);
+        }
+        else if (this.length === 1) {
+            super.insertAt(Parser.run(() => new AtomToken(variant, 'converter-rule-variant', config)), 0);
+        }
+        else {
+            this.childNodes.at(-2).setText(variant);
+        }
+    }
+    /**
+     * 设置转换原文
+     * @param from 转换原文
+     * @throws `Error` 尚未指定语言变体
+     * @throws `SyntaxError` 非法的转换原文
+     */
+    setFrom(from) {
+        const { variant, unidirectional } = this;
+        if (!variant) {
+            throw new Error('请先指定语言变体！');
+        }
+        const config = this.getAttribute('config'), root = Parser.parse(`-{|${from}=>${variant}:}-`, this.getAttribute('include'), undefined, config), { length, firstChild: converter } = root;
+        if (length !== 1 || converter.type !== 'converter') {
+            throw new SyntaxError(`非法的转换原文：${(0, string_1.noWrap)(from)}`);
+        }
+        const { lastChild: converterRule } = converter;
+        if (converter.length !== 2 || converterRule.length !== 3) {
+            throw new SyntaxError(`非法的转换原文：${(0, string_1.noWrap)(from)}`);
+        }
+        else if (unidirectional) {
+            this.firstChild.safeReplaceWith(converterRule.firstChild);
+        }
+        else {
+            super.insertAt(converterRule.firstChild, 0);
+        }
+    }
+    /**
+     * 修改为单向转换
+     * @param from 转换原文
+     */
+    makeUnidirectional(from) {
+        this.setFrom(from);
+    }
+    /** 修改为双向转换 */
+    makeBidirectional() {
+        if (this.unidirectional) {
+            this.removeAt(0);
+        }
+    }
+}
+Parser.classes['ConverterRuleToken'] = __filename;
+module.exports = ConverterRuleToken;

package/dist/src/extLink.d.ts

@@ -1,62 +1,65 @@
-export = ExtLinkToken;
+import * as Parser from '../index';
+import Token = require('.');
+import MagicLinkToken = require('./magicLink');
 /**
  * 外链
  * @classdesc `{childNodes: [MagicLinkToken, ?Token]}`
  */
-declare class ExtLinkToken extends Token {
+declare abstract class ExtLinkToken extends Token {
+    #private;
+    /** @browser */
+    readonly type = "ext-link";
+    childNodes: [MagicLinkToken] | [MagicLinkToken, Token];
+    abstract get children(): [MagicLinkToken] | [MagicLinkToken, Token];
+    abstract get firstChild(): MagicLinkToken;
+    abstract get firstElementChild(): MagicLinkToken;
+    abstract get lastChild(): Token;
+    abstract get lastElementChild(): Token;
+    /** 协议 */
+    get protocol(): string | undefined;
+    set protocol(value: string | undefined);
+    /** 和内链保持一致 */
+    get link(): string;
+    set link(url: string);
+    /** 链接显示文字 */
+    get innerText(): string;
     /**
-     * @param {string} url 网址
-     * @param {string} space 空白字符
-     * @param {string} text 链接文字
-     * @param {import('../../typings/token').accum} accum
+     * @browser
+     * @param url 网址
+     * @param space 空白字符
+     * @param text 链接文字
      */
-    constructor(url: string, space?: string, text?: string, config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
-    /** @this {{firstChild: MagicLinkToken}} */
-    set protocol(arg: string);
+    constructor(url: string, space?: string, text?: string, config?: Parser.Config, accum?: Token[]);
     /**
-     * 协议
-     * @this {{firstChild: MagicLinkToken}}
+     * @override
+     * @browser
      */
-    get protocol(): string;
-    set link(arg: string);
+    toString(selector?: string): string;
     /**
-     * 和内链保持一致
-     * @this {{firstChild: MagicLinkToken}}
+     * @override
+     * @browser
      */
-    get link(): string;
-    /** 链接显示文字 */
-    get innerText(): string;
+    text(): string;
     /**
      * @override
-     * @param {string} selector
+     * @browser
      */
-    override toString(selector: string): string;
-    /** @override */
-    override text(): string;
-    /** @override */
-    override print(): string;
+    print(): string;
     /** @override */
-    override cloneNode(): ExtLinkToken;
-    /**
-     * 获取网址
-     * @this {{firstChild: MagicLinkToken}}
-     */
-    getUrl(this: {
-        firstChild: MagicLinkToken;
-    }): URL;
+    cloneNode(): this;
+    /** 获取网址 */
+    getUrl(): URL;
     /**
      * 设置链接目标
-     * @param {string|URL} url 网址
+     * @param url 网址
      * @throws `SyntaxError` 非法的外链目标
      */
     setTarget(url: string | URL): void;
     /**
      * 设置链接显示文字
-     * @param {string} text 链接显示文字
+     * @param str 链接显示文字
      * @throws `SyntaxError` 非法的链接显示文字
      */
-    setLinkText(text: string): void;
-    #private;
+    setLinkText(str: string): void;
 }
-import Token = require(".");
-import MagicLinkToken = require("./magicLink");
+export = ExtLinkToken;

package/dist/src/extLink.js

@@ -0,0 +1,154 @@
+"use strict";
+const string_1 = require("../util/string");
+const Parser = require("../index");
+const Token = require(".");
+const MagicLinkToken = require("./magicLink");
+/**
+ * 外链
+ * @classdesc `{childNodes: [MagicLinkToken, ?Token]}`
+ */
+class ExtLinkToken extends Token {
+    /** @browser */
+    type = 'ext-link';
+    /** @browser */
+    #space;
+    /** 协议 */
+    get protocol() {
+        return this.firstChild.protocol;
+    }
+    set protocol(value) {
+        this.firstChild.protocol = value;
+    }
+    /** 和内链保持一致 */
+    get link() {
+        return this.firstChild.link;
+    }
+    set link(url) {
+        this.setTarget(url);
+    }
+    /** 链接显示文字 */
+    get innerText() {
+        return this.length > 1
+            ? this.lastChild.text()
+            : `[${this.getRootNode().querySelectorAll('ext-link[childElementCount=1]').indexOf(this) + 1}]`;
+    }
+    /**
+     * @browser
+     * @param url 网址
+     * @param space 空白字符
+     * @param text 链接文字
+     */
+    constructor(url, space = '', text = '', config = Parser.getConfig(), accum = []) {
+        super(undefined, config, true, accum, {
+            MagicLinkToken: 0, Token: 1,
+        });
+        this.insertAt(new MagicLinkToken(url, true, config, accum));
+        this.#space = space;
+        if (text) {
+            const inner = new Token(text, config, true, accum, {
+                'Stage-7': ':', ConverterToken: ':',
+            });
+            inner.type = 'ext-link-text';
+            this.insertAt(inner.setAttribute('stage', Parser.MAX_STAGE - 1));
+        }
+        this.protectChildren(0);
+    }
+    /**
+     * @override
+     * @browser
+     */
+    toString(selector) {
+        if (selector && this.matches(selector)) {
+            return '';
+        }
+        else if (this.length === 1) {
+            return `[${super.toString(selector)}${this.#space}]`;
+        }
+        this.#correct();
+        (0, string_1.normalizeSpace)(this.lastChild);
+        return `[${super.toString(selector, this.#space)}]`;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    text() {
+        (0, string_1.normalizeSpace)(this.childNodes[1]);
+        return `[${super.text(' ')}]`;
+    }
+    /** @private */
+    getPadding() {
+        return 1;
+    }
+    /** @private */
+    getGaps() {
+        this.#correct();
+        return this.#space.length;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    print() {
+        return super.print(this.length > 1 ? { pre: '[', sep: this.#space, post: ']' } : { pre: '[', post: `${this.#space}]` });
+    }
+    /** @override */
+    cloneNode() {
+        const [url, text] = this.cloneChildNodes();
+        return Parser.run(() => {
+            const token = new ExtLinkToken(undefined, '', '', this.getAttribute('config'));
+            token.firstChild.safeReplaceWith(url);
+            if (text) {
+                token.insertAt(text);
+            }
+            return token;
+        });
+    }
+    /** 修正空白字符 */
+    #correct() {
+        if (!this.#space && this.length > 1
+            // 都替换成`<`肯定不对，但无妨
+            && /^[^[\]<>"{\0-\x1F\x7F\p{Zs}\uFFFD]/u.test(this.lastChild.text().replace(/&[lg]t;/u, '<'))) {
+            this.#space = ' ';
+        }
+    }
+    /** 获取网址 */
+    getUrl() {
+        return this.firstChild.getUrl();
+    }
+    /**
+     * 设置链接目标
+     * @param url 网址
+     * @throws `SyntaxError` 非法的外链目标
+     */
+    setTarget(url) {
+        const strUrl = String(url), root = Parser.parse(`[${strUrl}]`, this.getAttribute('include'), 8, this.getAttribute('config')), { length, firstChild: extLink } = root;
+        if (length !== 1 || extLink.type !== 'ext-link' || extLink.length !== 1) {
+            throw new SyntaxError(`非法的外链目标：${strUrl}`);
+        }
+        const { firstChild } = extLink;
+        extLink.destroy();
+        this.firstChild.safeReplaceWith(firstChild);
+    }
+    /**
+     * 设置链接显示文字
+     * @param str 链接显示文字
+     * @throws `SyntaxError` 非法的链接显示文字
+     */
+    setLinkText(str) {
+        const root = Parser.parse(`[//url ${str}]`, this.getAttribute('include'), 8, this.getAttribute('config')), { length, firstChild: extLink } = root;
+        if (length !== 1 || extLink.type !== 'ext-link' || extLink.length !== 2) {
+            throw new SyntaxError(`非法的外链文字：${(0, string_1.noWrap)(str)}`);
+        }
+        const { lastChild } = extLink;
+        if (this.length === 1) {
+            this.insertAt(lastChild);
+        }
+        else {
+            this.lastChild.safeReplaceWith(lastChild);
+        }
+        this.#space ||= ' ';
+    }
+}
+Parser.classes['ExtLinkToken'] = __filename;
+module.exports = ExtLinkToken;

package/dist/src/gallery.d.ts

@@ -1,33 +1,74 @@
-export = GalleryToken;
+import * as Parser from '../index';
+import AstText = require('../lib/text');
+import Token = require('.');
+import GalleryImageToken = require('./link/galleryImage');
+import HiddenToken = require('./hidden');
+import AttributesToken = require('./attributes');
+import ExtToken = require('./tagPair/ext');
+import type { AstNodeTypes } from '../lib/node';
 /**
  * gallery标签
  * @classdesc `{childNodes: ...(GalleryImageToken|HiddenToken|AstText)}`
  */
-declare class GalleryToken extends Token {
+declare abstract class GalleryToken extends Token {
+    /** @browser */
+    readonly type = "ext-inner";
+    childNodes: (GalleryImageToken | HiddenToken | AstText)[];
+    abstract get children(): (GalleryImageToken | HiddenToken)[];
+    abstract get firstChild(): GalleryImageToken | HiddenToken | AstText | undefined;
+    abstract get firstElementChild(): GalleryImageToken | HiddenToken | undefined;
+    abstract get lastChild(): GalleryImageToken | HiddenToken | AstText | undefined;
+    abstract get lastElementChild(): GalleryImageToken | HiddenToken | 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;
+    /** 所有图片 */
+    get images(): GalleryImageToken[];
     /**
-     * @param {string} inner 标签内部wikitext
-     * @param {import('../../typings/token').accum} accum
+     * @browser
+     * @param inner 标签内部wikitext
      */
-    constructor(inner: string, config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
-    /** 所有图片 */
-    get images(): this[];
+    constructor(inner?: string, 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[];
     /** @override */
-    override cloneNode(): GalleryToken;
+    cloneNode(): this;
     /**
      * 插入图片
-     * @param {string} file 图片文件名
-     * @param {number} i 插入位置
+     * @param file 图片文件名
+     * @param i 插入位置
      * @throws `SyntaxError` 非法的文件名
      */
-    insertImage(file: string, i?: number): Token;
+    insertImage(file: string, i?: number): GalleryImageToken;
+    /**
+     * @override
+     * @param token 待插入的节点
+     * @param i 插入位置
+     * @throws `RangeError` 插入不可见内容
+     */
+    insertAt(token: string, i?: number): AstText;
+    /** @ignore */
+    insertAt<T extends AstNodeTypes>(token: T, i?: number): T;
 }
-import Token = require(".");
+export = GalleryToken;