wikiparser-node 1.7.0-beta.4 → 1.7.0

package/dist/lib/node.d.ts

@@ -0,0 +1,145 @@
+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 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 isConnected(): boolean;
+    /** 后方是否还有其他节点（不含后代） */
+    get eof(): boolean | undefined;
+    /** 相对于父容器的行号 */
+    get offsetTop(): number;
+    /** 相对于父容器的列号 */
+    get offsetLeft(): number;
+    /** 位置、大小和padding */
+    get style(): Position & Dimension & {
+        padding: number;
+    };
+    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: AstEventData): 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;
+}

package/dist/lib/node.js

@@ -0,0 +1,420 @@
+"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");
+/**
+ * 计算字符串的行列数
+ * @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 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;
+    }
+    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()) };
+    }
+}
+exports.AstNode = AstNode;
+constants_1.classes['AstNode'] = __filename;

package/dist/lib/range.d.ts

@@ -0,0 +1,105 @@
+import type { AstNodes } from '../internal';
+import type { Dimension, Position } from './node';
+/** 模拟Range对象 */
+export declare class AstRange {
+    #private;
+    /** 起点容器 */
+    get startContainer(): AstNodes;
+    /** 起点位置 */
+    get startOffset(): number;
+    /** 起点绝对位置 */
+    get startIndex(): number;
+    /** 起点行列位置 */
+    get startPos(): Position;
+    /** 终点容器 */
+    get endContainer(): AstNodes;
+    /** 终点位置 */
+    get endOffset(): number;
+    /** 终点绝对位置 */
+    get endIndex(): number;
+    /** 终点行列位置 */
+    get endPos(): Position;
+    /** 起始和终止位置是否重合 */
+    get collapsed(): boolean;
+    /** 最近的公共祖先 */
+    get commonAncestorContainer(): AstNodes;
+    /**
+     * 设置起点
+     * @param startNode 起点容器
+     * @param offset 起点位置
+     * @throws `RangeError` offset取值超出范围
+     */
+    setStart(startNode: AstNodes, offset: number): void;
+    /**
+     * 设置终点
+     * @param endNode 终点容器
+     * @param offset 终点位置
+     * @throws `RangeError` offset取值超出范围
+     */
+    setEnd(endNode: AstNodes, offset: number): void;
+    /**
+     * 在节点后设置起点
+     * @param referenceNode 节点
+     */
+    setStartAfter(referenceNode: AstNodes): void;
+    /**
+     * 在节点后设置终点
+     * @param referenceNode 节点
+     */
+    setEndAfter(referenceNode: AstNodes): void;
+    /**
+     * 在节点前设置起点
+     * @param referenceNode 节点
+     */
+    setStartBefore(referenceNode: AstNodes): void;
+    /**
+     * 在节点前设置终点
+     * @param referenceNode 节点
+     */
+    setEndBefore(referenceNode: AstNodes): void;
+    /**
+     * 设置Range包含整个节点的内容
+     * @param referenceNode 节点
+     */
+    selectNodeContents(referenceNode: AstNodes): void;
+    /**
+     * 设置Range包含整个节点
+     * @param referenceNode 节点
+     */
+    selectNode(referenceNode: AstNodes): void;
+    /**
+     * 使起始和终止位置重合
+     * @param toStart 重合至起始位置
+     */
+    collapse(toStart?: boolean): void;
+    /**
+     * 比较端点和Range的位置
+     * @param referenceNode 端点容器
+     * @param offset 端点位置
+     * @throws `RangeError` 不在同一个文档
+     */
+    comparePoint(referenceNode: AstNodes, offset: number): -1 | 0 | 1;
+    /**
+     * 端点是否在Range中
+     * @param referenceNode 端点容器
+     * @param offset 端点位置
+     */
+    isPointInRange(referenceNode: AstNodes, offset: number): boolean;
+    /** 复制AstRange对象 */
+    cloneRange(): AstRange;
+    /** 清空Range */
+    detach(): void;
+    /** 删除Range中的内容 */
+    deleteContents(): void;
+    /** 获取行列位置和大小 */
+    getBoundingClientRect(): Dimension & Position;
+    /**
+     * 在起始位置插入节点
+     * @param newNode 插入的节点
+     */
+    insertNode(newNode: AstNodes | string): void;
+    /** 获取范围内的全部节点 */
+    extractContents(): AstNodes[];
+    /** 拷贝范围内的全部节点 */
+    cloneContents(): AstNodes[];
+}