wikiparser-node 1.11.1 → 1.12.0-b

package/dist/lib/node.js

@@ -1,477 +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");
-/**
- * 计算字符串的行列数
- * @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 + cur.toString().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?.getAcceptable();
-        if (!parentNode || acceptable && !('QuoteToken' in acceptable)) {
-            return { bold: false, italic: false };
-        }
-        const { childNodes, type } = parentNode;
-        let { bold = false, italic = false } = type === 'ext-link-text' && parentNode.parentNode || {};
-        for (let i = childNodes.indexOf(this) - 1; i >= 0; i--) {
-            const child = childNodes[i];
-            if (child.is('quote')) {
-                bold = child.bold !== bold;
-                italic = child.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) {
-        return (key === 'padding' ? 0 : this[key]);
-    }
-    /** @private */
-    setAttribute(key, value) {
-        if (key === 'parentNode') {
-            this.#parentNode = value;
-            /* NOT FOR BROWSER */
-        }
-        else if (Object.hasOwn(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 */
-    getGaps(_) {
-        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,
-        });
-    }
-    /**
-     * 是否是某种类型的节点
-     * @param type 节点类型
-     */
-    is(type) {
-        return this.type === type;
-    }
-    /* 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('There is no parent node!');
-        }
-        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 child node at position ${i} 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('Nodes to be compared are not in the same document!');
-        }
-        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;

package/dist/lib/range.d.ts

@@ -1,105 +0,0 @@
-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[];
-}