wikiparser-node 1.4.0 → 1.4.1-b

package/dist/lib/node.d.ts

@@ -1,145 +0,0 @@
-import type { LintError, AstNode as AstNodeBase } from '../base';
-import type { AstText, Token } from '../internal';
-import type { TokenTypes } from '../util/constants';
-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 {
-    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

@@ -1,419 +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");
-/* NOT FOR BROWSER */
-/**
- * 定制TypeError消息
- * @param {Function} Constructor 类
- * @param method
- * @param args 可接受的参数类型
- * @throws `TypeError`
- */
-const typeError = ({ name }, method, ...args) => {
-    throw new TypeError(`${name}.${method} 方法仅接受 ${args.join('、')} 作为输入参数！`);
-};
-/* 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).findLast((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;
-        }
-        else if (key === 'optional') {
-            return new Set(this.#optional);
-        }
-        return key in this
-            ? String(this[key])
-            : undefined;
-    }
-    /** @private */
-    setAttribute(key, value) {
-        if (key === 'parentNode') {
-            this.#parentNode = value;
-        }
-        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);
-            }
-        }
-        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 lines = str.slice(0, index).split('\n'), top = lines.length - 1;
-            return { top, left: lines[top].length };
-        }
-        return undefined;
-    }
-    /** 获取行数和最后一行的列数 */
-    #getDimension() {
-        const lines = String(this).split('\n'), height = lines.length;
-        return { height, width: lines[height - 1].length };
-    }
-    /** @private */
-    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
-    getGaps(i) {
-        return 0;
-    }
-    /**
-     * 获取当前节点的相对字符位置，或其第`j`个子节点的相对字符位置
-     * @param j 子节点序号
-     */
-    getRelativeIndex(j) {
-        let childNodes;
-        /**
-         * 获取子节点相对于父节点的字符位置，使用前需要先给`childNodes`赋值
-         * @param end 子节点序号
-         * @param parent 父节点
-         */
-        const getIndex = (end, parent) => childNodes.slice(0, end).reduce((acc, cur, i) => acc + String(cur).length + parent.getGaps(i), 0)
-            + parent.getAttribute('padding');
-        if (j === undefined) {
-            const { parentNode } = this;
-            if (parentNode) {
-                ({ childNodes } = parentNode);
-                return getIndex(childNodes.indexOf(this), parentNode);
-            }
-            return 0;
-        }
-        this.verifyChild(j, 1);
-        ({ childNodes } = this);
-        return getIndex(j, this);
-    }
-    /** 获取当前节点的绝对位置 */
-    getAbsoluteIndex() {
-        const { parentNode } = this;
-        return parentNode ? parentNode.getAbsoluteIndex() + this.getRelativeIndex() : 0;
-    }
-    /* NOT FOR BROWSER */
-    /** @private */
-    typeError(method, ...types) {
-        return typeError(this.constructor, method, ...types);
-    }
-    /** @private */
-    constructorError(msg) {
-        throw new Error(`${this.constructor.name} ${msg}！`);
-    }
-    /** @private */
-    seal(key, permanent) {
-        if (!permanent) {
-            this.#optional.add(key);
-        }
-        Object.defineProperty(this, key, {
-            writable: false,
-            enumerable: !permanent && Boolean(this[key]),
-            configurable: true,
-        });
-    }
-    /**
-     * 是否是全同节点
-     * @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('不存在父节点！');
-        }
-        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() {
-        const { parentNode } = this;
-        if (parentNode) {
-            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(`不存在第 ${i} 个子节点！`);
-        }
-    }
-    /**
-     * 添加事件监听
-     * @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 {
-            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 });
-            /** 终止冒泡 */
-            e.stopPropagation = function () {
-                Object.defineProperty(this, 'bubbles', { value: false });
-            };
-        }
-        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 && 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), commonAncestor = aAncestors[depth - 1], { childNodes } = commonAncestor;
-        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 && lines.length >= top + 1 && lines[top].length >= left
-            ? lines.slice(0, top).reduce((acc, curLine) => acc + curLine.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

@@ -1,103 +0,0 @@
-import type { AstNodes } from '../internal';
-import type { Dimension, Position } from './node';
-/** 模拟Range对象 */
-export declare class AstRange {
-    /** 起点容器 */
-    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 startOffset 起点位置
-     * @throws `RangeError` offset取值超出范围
-     */
-    setStart(startNode: AstNodes, startOffset: number): void;
-    /**
-     * 设置终点
-     * @param endNode 终点容器
-     * @param endOffset 终点位置
-     * @throws `RangeError` offset取值超出范围
-     */
-    setEnd(endNode: AstNodes, endOffset: 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 节点
-     * @throws `RangeError` 参考节点没有父节点
-     */
-    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中的内容 */
-    deleteContents(): void;
-    /** 获取行列位置和大小 */
-    getBoundingClientRect(): Dimension & Position;
-    /**
-     * 在起始位置插入节点
-     * @param newNode 插入的节点
-     */
-    insertNode(newNode: AstNodes | string): void;
-    /** 获取范围内的全部节点 */
-    extractContents(): AstNodes[];
-    /** 在满足条件时拷贝范围内的全部节点 */
-    cloneContents(): AstNodes[];
-}