wikiparser-node 1.0.0-beta.3 → 1.0.1-b

package/dist/src/converterFlags.js

@@ -1,238 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConverterFlagsToken = void 0;
-const lint_1 = require("../util/lint");
-const index_1 = require("../index");
-const _1 = require(".");
-const atom_1 = require("./atom");
-const definedFlags = new Set(['A', 'T', 'R', 'D', '-', 'H', 'N']);
-/**
- * 转换flags
- * @classdesc `{childNodes: ...AtomToken}`
- */
-class ConverterFlagsToken extends _1.Token {
-    /** @browser */
-    type = 'converter-flags';
-    /** @browser */
-    #flags;
-    /**
-     * @browser
-     * @param flags 转换类型标记
-     */
-    constructor(flags, config = index_1.default.getConfig(), accum = []) {
-        super(undefined, config, true, accum, {
-            AtomToken: ':',
-        });
-        this.append(...flags.map(flag => new atom_1.AtomToken(flag, 'converter-flag', config, accum)));
-    }
-    /** @private */
-    afterBuild() {
-        this.#flags = this.childNodes.map(child => child.text().trim());
-        const /** @implements */ converterFlagsListener = ({ prevTarget }) => {
-            if (prevTarget) {
-                this.#flags[this.childNodes.indexOf(prevTarget)] = prevTarget.text().trim();
-            }
-        };
-        this.addEventListener(['remove', 'insert', 'text', 'replace'], converterFlagsListener);
-    }
-    /**
-     * @override
-     * @browser
-     */
-    toString(selector) {
-        return super.toString(selector, ';');
-    }
-    /**
-     * @override
-     * @browser
-     */
-    text() {
-        return super.text(';');
-    }
-    /** @private */
-    getGaps(i) {
-        return i < this.length - 1 ? 1 : 0;
-    }
-    /**
-     * @override
-     * @browser
-     */
-    print() {
-        return super.print({ sep: ';' });
-    }
-    /**
-     * 获取未知的转换类型标记
-     * @browser
-     */
-    getUnknownFlags() {
-        return new Set(this.#flags.filter(flag => /\{{3}[^{}]+\}{3}/u.test(flag)));
-    }
-    /**
-     * 获取指定语言变体的转换标记
-     * @browser
-     */
-    getVariantFlags() {
-        const variants = new Set(this.getAttribute('config').variants);
-        return new Set(this.#flags.filter(flag => variants.has(flag)));
-    }
-    /**
-     * @override
-     * @browser
-     */
-    lint(start = this.getAbsoluteIndex()) {
-        const variantFlags = this.getVariantFlags(), unknownFlags = this.getUnknownFlags(), validFlags = new Set(this.#flags.filter(flag => definedFlags.has(flag))), { length: emptyFlagCount } = this.#flags.filter(flag => !flag), knownFlagCount = this.#flags.length - unknownFlags.size - emptyFlagCount, errors = super.lint(start);
-        if (variantFlags.size === knownFlagCount || validFlags.size === knownFlagCount) {
-            return errors;
-        }
-        const rect = { start, ...this.getRootNode().posFromIndex(start) }, { childNodes, length } = this;
-        for (let i = 0; i < length; i++) {
-            const child = childNodes[i], flag = child.text().trim();
-            if (flag && !variantFlags.has(flag) && !unknownFlags.has(flag)
-                && (variantFlags.size > 0 || !validFlags.has(flag))) {
-                const error = (0, lint_1.generateForChild)(child, rect, 'invalid conversion flag');
-                errors.push({ ...error, excerpt: childNodes.slice(0, i + 1).map(String).join(';').slice(-50) });
-            }
-        }
-        return errors;
-    }
-    /** @override */
-    cloneNode() {
-        const cloned = this.cloneChildNodes();
-        return index_1.default.run(() => {
-            // @ts-expect-error abstract class
-            const token = new ConverterFlagsToken([], this.getAttribute('config'));
-            token.append(...cloned);
-            token.afterBuild();
-            return token;
-        });
-    }
-    /** @private */
-    getAttribute(key) {
-        return key === 'flags' ? this.#flags : super.getAttribute(key);
-    }
-    /** @private */
-    hasAttribute(key) {
-        return key === 'flags' || super.hasAttribute(key);
-    }
-    /**
-     * @override
-     * @param i 移除位置
-     */
-    removeAt(i) {
-        const token = super.removeAt(i);
-        this.#flags?.splice(i, 1);
-        return token;
-    }
-    /**
-     * @override
-     * @param token 待插入的子节点
-     * @param i 插入位置
-     */
-    insertAt(token, i = this.length) {
-        super.insertAt(token, i);
-        this.#flags?.splice(i, 0, token.text().trim());
-        return token;
-    }
-    /** 获取所有转换类型标记 */
-    getAllFlags() {
-        return new Set(this.#flags);
-    }
-    /**
-     * 获取转换类型标记节点
-     * @param flag 转换类型标记
-     */
-    getFlagToken(flag) {
-        return this.#flags.includes(flag) ? this.childNodes.filter(child => child.text().trim() === flag) : [];
-    }
-    /** 获取有效的转换类型标记 */
-    getEffectiveFlags() {
-        const variantFlags = this.getVariantFlags(), unknownFlags = this.getUnknownFlags();
-        if (variantFlags.size > 0) {
-            return new Set([...variantFlags, ...unknownFlags]);
-        }
-        const flags = new Set([...this.#flags.filter(flag => definedFlags.has(flag)), ...unknownFlags]);
-        if (flags.size === 0) {
-            return new Set('S');
-        }
-        else if (flags.has('R')) {
-            return new Set('R');
-        }
-        else if (flags.has('N')) {
-            return new Set('N');
-        }
-        else if (flags.has('-')) {
-            return new Set('-');
-        }
-        else if (flags.has('H')) {
-            const hasT = flags.has('T'), hasD = flags.has('D');
-            return hasT && hasD
-                ? new Set(['+', 'H', 'T', 'D'])
-                : new Set(['+', 'H', ...hasT ? ['T'] : [], ...hasD ? ['D'] : [], ...unknownFlags]);
-        }
-        if (flags.size === 1 && flags.has('T')) {
-            flags.add('H');
-        }
-        if (flags.has('A')) {
-            flags.add('+');
-            flags.add('S');
-        }
-        if (flags.has('D')) {
-            flags.delete('S');
-        }
-        return flags;
-    }
-    /**
-     * 是否具有某转换类型标记
-     * @param flag 转换类型标记
-     */
-    hasFlag(flag) {
-        return this.#flags.includes(flag);
-    }
-    /**
-     * 是否具有某有效的转换类型标记
-     * @param flag 转换类型标记
-     */
-    hasEffectiveFlag(flag) {
-        return this.getEffectiveFlags().has(flag);
-    }
-    /**
-     * 移除某转换类型标记
-     * @param flag 转换类型标记
-     */
-    removeFlag(flag) {
-        for (const token of this.getFlagToken(flag)) {
-            token.remove();
-        }
-    }
-    /**
-     * 添加转换类型标记
-     * @param flag 转换类型标记
-     */
-    #newFlag(flag) {
-        const token = index_1.default.run(() => new atom_1.AtomToken(flag, 'converter-flag', this.getAttribute('config')));
-        this.insertAt(token);
-    }
-    /**
-     * 设置转换类型标记
-     * @param flag 转换类型标记
-     */
-    setFlag(flag) {
-        if (!this.#flags.includes(flag)) {
-            this.#newFlag(flag);
-        }
-    }
-    /**
-     * 开关转换类型标记
-     * @param flag 转换类型标记
-     */
-    toggleFlag(flag) {
-        if (this.#flags.includes(flag)) {
-            this.removeFlag(flag);
-        }
-        else {
-            this.#newFlag(flag);
-        }
-    }
-}
-exports.ConverterFlagsToken = ConverterFlagsToken;
-index_1.default.classes['ConverterFlagsToken'] = __filename;

package/dist/src/converterRule.d.ts

@@ -1,96 +0,0 @@
-import { Token } from '.';
-import { AtomToken } from './atom';
-import type { ConverterToken, ConverterFlagsToken } from '../internal';
-/**
- * 转换规则
- * @classdesc `{childNodes: ...AtomToken}`
- */
-export declare abstract class ConverterRuleToken extends Token {
-    /** @browser */
-    readonly type = "converter-rule";
-    childNodes: [AtomToken] | [AtomToken, AtomToken] | [AtomToken, AtomToken, AtomToken];
-    abstract get children(): [AtomToken] | [AtomToken, AtomToken] | [AtomToken, AtomToken, AtomToken];
-    abstract get firstChild(): AtomToken;
-    abstract get firstElementChild(): AtomToken;
-    abstract get lastChild(): AtomToken;
-    abstract get lastElementChild(): AtomToken;
-    abstract get parentNode(): ConverterToken | undefined;
-    abstract get parentElement(): ConverterToken | undefined;
-    abstract get previousSibling(): ConverterFlagsToken | this;
-    abstract get previousElementSibling(): ConverterFlagsToken | this;
-    abstract get nextSibling(): this | undefined;
-    abstract get nextElementSibling(): this | undefined;
-    /** 语言变体 */
-    get variant(): string;
-    set variant(variant: string);
-    /** 是否是单向转换 */
-    get unidirectional(): boolean;
-    /** @throws `Error` 不能用于将双向转换或不转换更改为单向转换 */
-    set unidirectional(flag: boolean);
-    /** 是否是双向转换 */
-    get bidirectional(): boolean;
-    /** @throws `Error` 不能用于将双向转换更改为单向转换或将不转换更改为双向转换 */
-    set bidirectional(flag: boolean);
-    /**
-     * @browser
-     * @param rule 转换规则
-     * @param hasColon 是否带有":"
-     */
-    constructor(rule: string, hasColon?: boolean, config?: import("../index").Config, accum?: Token[]);
-    /**
-     * @override
-     * @browser
-     */
-    toString(selector?: string): string;
-    /**
-     * @override
-     * @browser
-     */
-    text(): string;
-    /**
-     * @override
-     * @browser
-     */
-    print(): string;
-    /** @override */
-    cloneNode(): this;
-    /**
-     * @override
-     * @param i 移除位置
-     * @throws `Error` 至少保留1个子节点
-     */
-    removeAt(i: number): AtomToken;
-    /**
-     * @override
-     * @throws `Error` 请勿手动插入子节点
-     */
-    insertAt(): never;
-    /** 修改为不转换 */
-    noConvert(): void;
-    /**
-     * 设置转换目标
-     * @param to 转换目标
-     * @throws `SyntaxError` 非法的转换目标
-     */
-    setTo(to: string): void;
-    /**
-     * 设置语言变体
-     * @param variant 语言变体
-     * @throws `RangeError` 无效的语言变体
-     */
-    setVariant(variant: string): void;
-    /**
-     * 设置转换原文
-     * @param from 转换原文
-     * @throws `Error` 尚未指定语言变体
-     * @throws `SyntaxError` 非法的转换原文
-     */
-    setFrom(from: string): void;
-    /**
-     * 修改为单向转换
-     * @param from 转换原文
-     */
-    makeUnidirectional(from: string): void;
-    /** 修改为双向转换 */
-    makeBidirectional(): void;
-}

package/dist/src/converterRule.js

@@ -1,255 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConverterRuleToken = void 0;
-const debug_1 = require("../util/debug");
-const string_1 = require("../util/string");
-const index_1 = require("../index");
-const _1 = require(".");
-const atom_1 = require("./atom");
-/**
- * 转换规则
- * @classdesc `{childNodes: ...AtomToken}`
- */
-class ConverterRuleToken extends _1.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 = index_1.default.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 atom_1.AtomToken(v, 'converter-rule-variant', config, accum));
-                super.insertAt(new atom_1.AtomToken(rule.slice(i + 1), 'converter-rule-to', config, accum));
-                if (j !== -1) {
-                    super.insertAt(new atom_1.AtomToken(rule.slice(0, j), 'converter-rule-from', config, accum), 0);
-                }
-            }
-            else {
-                super.insertAt(new atom_1.AtomToken(rule, 'converter-rule-noconvert', config, accum));
-            }
-        }
-        else {
-            super.insertAt(new atom_1.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) {
-        const { length } = this;
-        return i === 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 index_1.default.run(() => {
-            // @ts-expect-error abstract class
-            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 = index_1.default.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) {
-        const config = this.getAttribute('config'), v = variant.trim();
-        if (!config.variants.includes(v)) {
-            throw new RangeError(`无效的语言变体：${v}`);
-        }
-        else if (this.length === 1) {
-            super.insertAt(index_1.default.run(() => new atom_1.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 = index_1.default.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);
-        }
-    }
-}
-exports.ConverterRuleToken = ConverterRuleToken;
-index_1.default.classes['ConverterRuleToken'] = __filename;

package/dist/src/extLink.d.ts

@@ -1,63 +0,0 @@
-import { Token } from '.';
-import { MagicLinkToken } from './magicLink';
-/**
- * 外链
- * @classdesc `{childNodes: [MagicLinkToken, ?Token]}`
- */
-export 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;
-    /**
-     * @browser
-     * @param url 网址
-     * @param space 空白字符
-     * @param text 链接文字
-     */
-    constructor(url: string, space?: string, text?: string, config?: import("../index").Config, accum?: Token[]);
-    /**
-     * @override
-     * @browser
-     */
-    toString(selector?: string): string;
-    /**
-     * @override
-     * @browser
-     */
-    text(): string;
-    /**
-     * @override
-     * @browser
-     */
-    print(): string;
-    /** @override */
-    cloneNode(): this;
-    /** 获取网址 */
-    getUrl(): URL;
-    /**
-     * 设置链接目标
-     * @param url 网址
-     * @throws `SyntaxError` 非法的外链目标
-     */
-    setTarget(url: string | URL): void;
-    /**
-     * 设置链接显示文字
-     * @param str 链接显示文字
-     * @throws `SyntaxError` 非法的链接显示文字
-     */
-    setLinkText(str: string): void;
-}