wikiparser-node 1.8.0 → 1.9.0-b

package/dist/lib/node.d.ts

@@ -1,166 +0,0 @@
-import type { LintError, AstNode as AstNodeBase, TokenTypes } from '../base';
-import type { AstText, Token } from '../internal';
-export type AstNodes = AstText | Token;
-export interface Dimension {
-    readonly height: number;
-    readonly width: number;
-}
-export interface Position {
-    readonly top: number;
-    readonly left: number;
-}
-export interface CaretPosition {
-    readonly offsetNode: AstNodes;
-    readonly offset: number;
-}
-/** 类似Node */
-export declare abstract class AstNode implements AstNodeBase {
-    #private;
-    type: TokenTypes | 'text';
-    data?: string | undefined;
-    readonly childNodes: readonly AstNodes[];
-    abstract text(): string;
-    abstract lint(): LintError[];
-    abstract print(): string;
-    /** 首位子节点 */
-    get firstChild(): AstNodes | undefined;
-    /** 末位子节点 */
-    get lastChild(): AstNodes | undefined;
-    /** 父节点 */
-    get parentNode(): Token | undefined;
-    /** 后一个兄弟节点 */
-    get nextSibling(): AstNodes | undefined;
-    /** 前一个兄弟节点 */
-    get previousSibling(): AstNodes | undefined;
-    /** 行数 */
-    get offsetHeight(): number;
-    /** 最后一行的列数 */
-    get offsetWidth(): number;
-    /** 后一个非文本兄弟节点 */
-    get nextElementSibling(): Token | undefined;
-    /** 前一个非文本兄弟节点 */
-    get previousElementSibling(): Token | undefined;
-    /** 后一个可见的兄弟节点 */
-    get nextVisibleSibling(): AstNodes | undefined;
-    /** 前一个可见的兄弟节点 */
-    get previousVisibleSibling(): AstNodes | undefined;
-    /** 是否具有根节点 */
-    get isConnected(): boolean;
-    /** 后方是否还有其他节点（不含后代） */
-    get eof(): boolean | undefined;
-    /** 相对于父容器的行号 */
-    get offsetTop(): number;
-    /** 相对于父容器的列号 */
-    get offsetLeft(): number;
-    /** 位置、大小和padding */
-    get style(): Position & Dimension & {
-        padding: number;
-    };
-    /** 字体样式 */
-    get font(): {
-        bold: boolean;
-        italic: boolean;
-    };
-    /** 是否粗体 */
-    get bold(): boolean;
-    /** 是否斜体 */
-    get italic(): boolean;
-    constructor();
-    /** 获取根节点 */
-    getRootNode(): Token | this;
-    /**
-     * 将字符位置转换为行列号
-     * @param index 字符位置
-     */
-    posFromIndex(index: number): Position | undefined;
-    /**
-     * 获取当前节点的相对字符位置，或其第`j`个子节点的相对字符位置
-     * @param j 子节点序号
-     */
-    getRelativeIndex(j?: number): number;
-    /** 获取当前节点的绝对位置 */
-    getAbsoluteIndex(): number;
-    /**
-     * 是否是全同节点
-     * @param node 待比较的节点
-     * @throws `assert.AssertionError`
-     */
-    isEqualNode(node: AstNode): boolean;
-    /**
-     * 在后方批量插入兄弟节点
-     * @param nodes 插入节点
-     */
-    after(...nodes: (AstNodes | string)[]): void;
-    /**
-     * 在前方批量插入兄弟节点
-     * @param nodes 插入节点
-     */
-    before(...nodes: (AstNodes | string)[]): void;
-    /** 移除当前节点 */
-    remove(): void;
-    /**
-     * 将当前节点批量替换为新的节点
-     * @param nodes 插入节点
-     */
-    replaceWith(...nodes: (AstNodes | string)[]): void;
-    /**
-     * 是自身或后代节点
-     * @param node 待检测节点
-     */
-    contains(node: AstNode): boolean;
-    /**
-     * 添加事件监听
-     * @param types 事件类型
-     * @param listener 监听函数
-     * @param options 选项
-     * @param options.once 仅执行一次
-     */
-    addEventListener(types: string | string[], listener: (...args: any[]) => void, options?: {
-        once?: boolean;
-    }): void;
-    /**
-     * 移除事件监听
-     * @param types 事件类型
-     * @param listener 监听函数
-     */
-    removeEventListener(types: string | string[], listener: (...args: any[]) => void): void;
-    /**
-     * 移除事件的所有监听
-     * @param types 事件类型
-     */
-    removeAllEventListeners(types: string | string[]): void;
-    /**
-     * 列举事件监听
-     * @param type 事件类型
-     */
-    listEventListeners(type: string): Function[];
-    /**
-     * 触发事件
-     * @param e 事件对象
-     * @param data 事件数据
-     */
-    dispatchEvent(e: Event, data: unknown): void;
-    /** 获取所有祖先节点 */
-    getAncestors(): Token[];
-    /**
-     * 比较和另一个节点的相对位置
-     * @param other 待比较的节点
-     * @throws `RangeError` 不在同一个语法树
-     */
-    compareDocumentPosition(other: AstNodes): number;
-    /**
-     * 将行列号转换为字符位置
-     * @param top 行号
-     * @param left 列号
-     */
-    indexFromPos(top: number, left: number): number | undefined;
-    /** 获取当前节点的行列位置和大小 */
-    getBoundingClientRect(): Dimension & Position;
-    /** 销毁 */
-    destroy(): void;
-    /**
-     * 获取某一行的wikitext
-     * @param n 行号
-     */
-    getLine(n: number): string | undefined;
-}

package/dist/lib/node.js

@@ -1,480 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AstNode = void 0;
-const assert = require("assert/strict");
-const EventEmitter = require("events");
-const constants_1 = require("../util/constants");
-const debug_1 = require("../util/debug");
-/**
- * 计算字符串的行列数
- * @param str 字符串
- */
-const getDimension = (str) => {
-    const lines = str.split('\n'), height = lines.length;
-    return { height, width: lines[height - 1].length };
-};
-/**
- * 获取子节点相对于父节点的字符位置
- * @param j 子节点序号
- * @param parent 父节点
- */
-const getIndex = (j, parent) => parent.childNodes.slice(0, j).reduce((acc, cur, i) => acc + String(cur).length + parent.getGaps(i), 0)
-    + parent.getAttribute('padding');
-/* NOT FOR BROWSER */
-/**
- * 定制TypeError消息
- * @param {Function} Constructor 类
- * @param method
- * @param args 可接受的参数类型
- * @throws `TypeError`
- */
-const typeError = ({ name }, method, ...args) => {
-    throw new TypeError(`${name}.${method} method only accepts ${args.join('、')} as input parameters!`);
-};
-/* NOT FOR BROWSER END */
-/** 类似Node */
-class AstNode {
-    childNodes = [];
-    #parentNode;
-    /* NOT FOR BROWSER */
-    #optional = new Set();
-    #events = new EventEmitter();
-    /** 首位子节点 */
-    get firstChild() {
-        return this.childNodes[0];
-    }
-    /** 末位子节点 */
-    get lastChild() {
-        return this.childNodes[this.childNodes.length - 1];
-    }
-    /** 父节点 */
-    get parentNode() {
-        return this.#parentNode;
-    }
-    /** 后一个兄弟节点 */
-    get nextSibling() {
-        const childNodes = this.parentNode?.childNodes;
-        return childNodes && childNodes[childNodes.indexOf(this) + 1];
-    }
-    /** 前一个兄弟节点 */
-    get previousSibling() {
-        const childNodes = this.parentNode?.childNodes;
-        return childNodes && childNodes[childNodes.indexOf(this) - 1];
-    }
-    /** 行数 */
-    get offsetHeight() {
-        return this.#getDimension().height;
-    }
-    /** 最后一行的列数 */
-    get offsetWidth() {
-        return this.#getDimension().width;
-    }
-    /* NOT FOR BROWSER */
-    /** 后一个非文本兄弟节点 */
-    get nextElementSibling() {
-        const childNodes = this.parentNode?.childNodes, i = childNodes?.indexOf(this);
-        return childNodes?.slice(i + 1).find((child) => child.type !== 'text');
-    }
-    /** 前一个非文本兄弟节点 */
-    get previousElementSibling() {
-        const childNodes = this.parentNode?.childNodes, i = childNodes?.indexOf(this);
-        return childNodes?.slice(0, i).reverse().find((child) => child.type !== 'text');
-    }
-    /** 后一个可见的兄弟节点 */
-    get nextVisibleSibling() {
-        let { nextSibling } = this;
-        while (nextSibling?.text() === '') {
-            ({ nextSibling } = nextSibling);
-        }
-        return nextSibling;
-    }
-    /** 前一个可见的兄弟节点 */
-    get previousVisibleSibling() {
-        let { previousSibling } = this;
-        while (previousSibling?.text() === '') {
-            ({ previousSibling } = previousSibling);
-        }
-        return previousSibling;
-    }
-    /** 是否具有根节点 */
-    get isConnected() {
-        return this.getRootNode().type === 'root';
-    }
-    /** 后方是否还有其他节点（不含后代） */
-    get eof() {
-        const { parentNode } = this;
-        if (!parentNode) {
-            return true;
-        }
-        let { nextSibling } = this;
-        while (nextSibling?.type === 'text' && nextSibling.data.trim() === '') {
-            ({ nextSibling } = nextSibling);
-        }
-        return nextSibling === undefined && parentNode.eof;
-    }
-    /** 相对于父容器的行号 */
-    get offsetTop() {
-        return this.#getPosition().top;
-    }
-    /** 相对于父容器的列号 */
-    get offsetLeft() {
-        return this.#getPosition().left;
-    }
-    /** 位置、大小和padding */
-    get style() {
-        return { ...this.#getPosition(), ...this.#getDimension(), padding: this.getAttribute('padding') };
-    }
-    /** @private */
-    get fixed() {
-        return false;
-    }
-    /** 字体样式 */
-    get font() {
-        const { parentNode } = this, acceptable = parentNode?.getAttribute('acceptable');
-        if (!parentNode || acceptable && !('QuoteToken' in acceptable)) {
-            return { bold: false, italic: false };
-        }
-        const { childNodes } = parentNode, index = childNodes.indexOf(this), isQuote = (0, debug_1.isToken)('quote');
-        let bold = false, italic = false;
-        for (let i = index - 1; i >= 0; i--) {
-            const child = childNodes[i];
-            if (isQuote(child)) {
-                bold = child.bold ? !bold : bold;
-                italic = child.italic ? !italic : italic;
-            }
-            else if (child.type === 'text' && child.data.includes('\n')) {
-                break;
-            }
-        }
-        return { bold, italic };
-    }
-    /** 是否粗体 */
-    get bold() {
-        return this.font.bold;
-    }
-    /** 是否斜体 */
-    get italic() {
-        return this.font.italic;
-    }
-    constructor() {
-        Object.defineProperty(this, 'childNodes', { writable: false });
-        Object.freeze(this.childNodes);
-    }
-    /* NOT FOR BROWSER END */
-    /** @private */
-    getAttribute(key) {
-        if (key === 'padding') {
-            return 0;
-            /* NOT FOR BROWSER */
-        }
-        else if (key === 'optional') {
-            return new Set(this.#optional);
-            /* NOT FOR BROWSER END */
-        }
-        return this[key];
-    }
-    /** @private */
-    setAttribute(key, value) {
-        if (key === 'parentNode') {
-            this.#parentNode = value;
-            /* NOT FOR BROWSER */
-        }
-        else if (Object.prototype.hasOwnProperty.call(this, key)) {
-            const descriptor = Object.getOwnPropertyDescriptor(this, key);
-            if (this.#optional.has(key)) {
-                descriptor.enumerable = Boolean(value);
-            }
-            const oldValue = this[key], frozen = typeof oldValue === 'object' && Object.isFrozen(oldValue);
-            Object.defineProperty(this, key, { ...descriptor, value });
-            if (frozen && typeof value === 'object') {
-                Object.freeze(value);
-            }
-            /* NOT FOR BROWSER END */
-        }
-        else {
-            this[key] = value; // eslint-disable-line @typescript-eslint/no-explicit-any
-        }
-    }
-    /** 获取根节点 */
-    getRootNode() {
-        let { parentNode } = this;
-        while (parentNode?.parentNode) {
-            ({ parentNode } = parentNode);
-        }
-        return parentNode ?? this;
-    }
-    /**
-     * 将字符位置转换为行列号
-     * @param index 字符位置
-     */
-    posFromIndex(index) {
-        const str = String(this);
-        if (index >= -str.length && index <= str.length) {
-            const { height, width } = getDimension(str.slice(0, index));
-            return { top: height - 1, left: width };
-        }
-        return undefined;
-    }
-    /** 获取行数和最后一行的列数 */
-    #getDimension() {
-        return getDimension(String(this));
-    }
-    /** @private */
-    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-    getGaps(i) {
-        return 0;
-    }
-    /**
-     * 获取当前节点的相对字符位置，或其第`j`个子节点的相对字符位置
-     * @param j 子节点序号
-     */
-    getRelativeIndex(j) {
-        if (j === undefined) {
-            const { parentNode } = this;
-            return parentNode ? getIndex(parentNode.childNodes.indexOf(this), parentNode) : 0;
-        }
-        /* NOT FOR BROWSER */
-        this.verifyChild(j, 1);
-        /* NOT FOR BROWSER END */
-        return getIndex(j, this);
-    }
-    /** 获取当前节点的绝对位置 */
-    getAbsoluteIndex() {
-        const { parentNode } = this;
-        return parentNode ? parentNode.getAbsoluteIndex() + this.getRelativeIndex() : 0;
-    }
-    /** @private */
-    seal(key, permanent) {
-        /* NOT FOR BROWSER */
-        if (!permanent) {
-            this.#optional.add(key);
-        }
-        /* NOT FOR BROWSER END */
-        Object.defineProperty(this, key, {
-            enumerable: !permanent && Boolean(this[key]),
-            configurable: true,
-            /* NOT FOR BROWSER */
-            writable: false,
-        });
-    }
-    /* NOT FOR BROWSER */
-    /** @private */
-    typeError(method, ...types) {
-        return typeError(this.constructor, method, ...types);
-    }
-    /** @private */
-    constructorError(msg) {
-        throw new Error(`${this.constructor.name} ${msg}！`);
-    }
-    /**
-     * 是否是全同节点
-     * @param node 待比较的节点
-     * @throws `assert.AssertionError`
-     */
-    isEqualNode(node) {
-        try {
-            assert.deepEqual(this, node);
-        }
-        catch (e) {
-            if (e instanceof assert.AssertionError) {
-                return false;
-            }
-            throw e;
-        }
-        return true;
-    }
-    /**
-     * 在当前节点前后插入兄弟节点
-     * @param nodes 插入节点
-     * @param offset 插入的相对位置
-     * @throws `Error` 不存在父节点
-     */
-    #insertAdjacent(nodes, offset) {
-        const { parentNode } = this;
-        if (!parentNode) {
-            throw new Error('The node has no parent!');
-        }
-        const i = parentNode.childNodes.indexOf(this) + offset;
-        for (let j = 0; j < nodes.length; j++) {
-            parentNode.insertAt(nodes[j], i + j);
-        }
-    }
-    /**
-     * 在后方批量插入兄弟节点
-     * @param nodes 插入节点
-     */
-    after(...nodes) {
-        this.#insertAdjacent(nodes, 1);
-    }
-    /**
-     * 在前方批量插入兄弟节点
-     * @param nodes 插入节点
-     */
-    before(...nodes) {
-        this.#insertAdjacent(nodes, 0);
-    }
-    /** 移除当前节点 */
-    remove() {
-        this.parentNode?.removeChild(this);
-    }
-    /**
-     * 将当前节点批量替换为新的节点
-     * @param nodes 插入节点
-     */
-    replaceWith(...nodes) {
-        this.after(...nodes);
-        this.remove();
-    }
-    /**
-     * 是自身或后代节点
-     * @param node 待检测节点
-     */
-    contains(node) {
-        return node === this || this.childNodes.some(child => child.contains(node));
-    }
-    /** @private */
-    verifyChild(i, addition = 0) {
-        const { childNodes: { length } } = this;
-        if (i < -length || i >= length + addition) {
-            throw new RangeError(`The ${i}th child does not exist!`);
-        }
-    }
-    /**
-     * 添加事件监听
-     * @param types 事件类型
-     * @param listener 监听函数
-     * @param options 选项
-     * @param options.once 仅执行一次
-     */
-    addEventListener(types, listener, options) {
-        if (Array.isArray(types)) {
-            for (const type of types) {
-                this.addEventListener(type, listener, options);
-            }
-        }
-        else {
-            this.#events[options?.once ? 'once' : 'on'](types, listener);
-        }
-    }
-    /**
-     * 移除事件监听
-     * @param types 事件类型
-     * @param listener 监听函数
-     */
-    removeEventListener(types, listener) {
-        if (Array.isArray(types)) {
-            for (const type of types) {
-                this.removeEventListener(type, listener);
-            }
-        }
-        else {
-            this.#events.off(types, listener);
-        }
-    }
-    /**
-     * 移除事件的所有监听
-     * @param types 事件类型
-     */
-    removeAllEventListeners(types) {
-        if (Array.isArray(types)) {
-            for (const type of types) {
-                this.removeAllEventListeners(type);
-            }
-        }
-        else if (typeof types === 'string') {
-            this.#events.removeAllListeners(types);
-        }
-    }
-    /**
-     * 列举事件监听
-     * @param type 事件类型
-     */
-    listEventListeners(type) {
-        return this.#events.listeners(type);
-    }
-    /**
-     * 触发事件
-     * @param e 事件对象
-     * @param data 事件数据
-     */
-    dispatchEvent(e, data) {
-        if (!e.target) { // 初始化
-            Object.defineProperty(e, 'target', { value: this, enumerable: true });
-        }
-        Object.defineProperties(e, {
-            prevTarget: { value: e.currentTarget, enumerable: true, configurable: true },
-            currentTarget: { value: this, enumerable: true, configurable: true },
-        });
-        this.#events.emit(e.type, e, data);
-        if (e.bubbles && !e.cancelBubble && this.parentNode) {
-            this.parentNode.dispatchEvent(e, data);
-        }
-    }
-    /** 获取所有祖先节点 */
-    getAncestors() {
-        const ancestors = [];
-        let { parentNode } = this;
-        while (parentNode) {
-            ancestors.push(parentNode);
-            ({ parentNode } = parentNode);
-        }
-        return ancestors;
-    }
-    /**
-     * 比较和另一个节点的相对位置
-     * @param other 待比较的节点
-     * @throws `RangeError` 不在同一个语法树
-     */
-    compareDocumentPosition(other) {
-        if (this === other) {
-            return 0;
-        }
-        else if (this.contains(other)) {
-            return -1;
-        }
-        else if (other.contains(this)) {
-            return 1;
-        }
-        else if (this.getRootNode() !== other.getRootNode()) {
-            throw new RangeError('不在同一个语法树！');
-        }
-        const aAncestors = [...this.getAncestors().reverse(), this], bAncestors = [...other.getAncestors().reverse(), other], depth = aAncestors.findIndex((ancestor, i) => bAncestors[i] !== ancestor), { childNodes } = aAncestors[depth - 1];
-        return childNodes.indexOf(aAncestors[depth]) - childNodes.indexOf(bAncestors[depth]);
-    }
-    /**
-     * 将行列号转换为字符位置
-     * @param top 行号
-     * @param left 列号
-     */
-    indexFromPos(top, left) {
-        const lines = String(this).split('\n');
-        return top >= 0 && left >= 0 && top <= lines.length - 1 && left <= lines[top].length
-            ? lines.slice(0, top).reduce((acc, cur) => acc + cur.length + 1, 0) + left
-            : undefined;
-    }
-    /** 获取当前节点的相对位置 */
-    #getPosition() {
-        return this.parentNode?.posFromIndex(this.getRelativeIndex()) ?? { top: 0, left: 0 };
-    }
-    /** 获取当前节点的行列位置和大小 */
-    getBoundingClientRect() {
-        return { ...this.#getDimension(), ...this.getRootNode().posFromIndex(this.getAbsoluteIndex()) };
-    }
-    /** 销毁 */
-    destroy() {
-        this.parentNode?.destroy();
-        for (const child of this.childNodes) {
-            child.setAttribute('parentNode', undefined);
-        }
-        Object.setPrototypeOf(this, null);
-    }
-    /**
-     * 获取某一行的wikitext
-     * @param n 行号
-     */
-    getLine(n) {
-        return String(this).split('\n', n + 1)[n];
-    }
-}
-exports.AstNode = AstNode;
-constants_1.classes['AstNode'] = __filename;