wikiparser-node 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/lib/node.js

@@ -1,8 +1,19 @@
 "use strict";
-const debug_1 = require("../util/debug");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstNode = void 0;
 const assert = require("assert/strict");
 const EventEmitter = require("events");
-const Parser = require("../index");
+const index_1 = require("../index");
+/**
+ * 定制TypeError消息
+ * @param {Function} Constructor 类
+ * @param method
+ * @param args 可接受的参数类型
+ * @throws `TypeError`
+ */
+const typeError = ({ name }, method, ...args) => {
+    throw new TypeError(`${name}.${method} 方法仅接受 ${args.join('、')} 作为输入参数！`);
+};
 /** 类似Node */
 class AstNode {
     /** @browser */
@@ -89,7 +100,7 @@ class AstNode {
             return true;
         }
         let { nextSibling } = this;
-        while (nextSibling?.type === 'text' && String(nextSibling).trim() === '') {
+        while (nextSibling?.type === 'text' && nextSibling.data.trim() === '') {
             ({ nextSibling } = nextSibling);
         }
         return nextSibling === undefined && this.parentNode?.eof;
@@ -116,7 +127,7 @@ class AstNode {
     }
     /** @private */
     hasAttribute(key) {
-        return typeof key === 'string' ? key in this : this.typeError('hasAttribute', 'String');
+        return key in this;
     }
     /** @private */
     getAttribute(key) {
@@ -124,6 +135,7 @@ class AstNode {
             return new Set(this.#optional);
         }
         return this.hasAttribute(key)
+            // @ts-expect-error noImplicitAny
             ? String(this[key])
             : undefined;
     }
@@ -137,6 +149,7 @@ class AstNode {
             if (this.#optional.has(key)) {
                 descriptor.enumerable = Boolean(value);
             }
+            // @ts-expect-error noImplicitAny
             const oldValue = this[key], frozen = oldValue !== null && typeof oldValue === 'object' && Object.isFrozen(oldValue);
             Object.defineProperty(this, key, { ...descriptor, value });
             if (frozen && typeof value === 'object') {
@@ -144,6 +157,7 @@ class AstNode {
             }
         }
         else {
+            // @ts-expect-error noImplicitAny
             this[key] = value;
         }
         return this;
@@ -165,9 +179,6 @@ class AstNode {
      * @param index 字符位置
      */
     posFromIndex(index) {
-        if (!Number.isInteger(index)) {
-            this.typeError('posFromIndex', 'Number');
-        }
         const str = String(this);
         if (index >= -str.length && index <= str.length) {
             const lines = str.slice(0, index).split('\n');
@@ -188,6 +199,7 @@ class AstNode {
         return 0;
     }
     /** @private */
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
     getGaps(i) {
         return 0;
     }
@@ -227,11 +239,12 @@ class AstNode {
     }
     /** @private */
     typeError(method, ...types) {
-        return (0, debug_1.typeError)(this.constructor, method, ...types);
+        return typeError(this.constructor, method, ...types);
     }
     /** @private */
     seal(key) {
         this.#optional.add(key);
+        // @ts-expect-error noImplicitAny
         Object.defineProperty(this, key, { writable: false, enumerable: Boolean(this[key]), configurable: true });
     }
     /**
@@ -305,15 +318,10 @@ class AstNode {
      * @param node 待检测节点
      */
     contains(node) {
-        return node instanceof AstNode
-            ? node === this || this.childNodes.some(child => child.contains(node))
-            : this.typeError('contains', 'AstNode');
+        return node === this || this.childNodes.some(child => child.contains(node));
     }
     /** @private */
     verifyChild(i, addition = 0) {
-        if (!Number.isInteger(i)) {
-            this.typeError('verifyChild', 'Number');
-        }
         const { childNodes: { length } } = this;
         if (i < -length || i >= length + addition) {
             throw new RangeError(`不存在第 ${i} 个子节点！`);
@@ -332,11 +340,8 @@ class AstNode {
                 this.addEventListener(type, listener, options);
             }
         }
-        else if (typeof types === 'string' && typeof listener === 'function') {
-            this.#events[options?.once ? 'once' : 'on'](types, listener);
-        }
         else {
-            this.typeError('addEventListener', 'String', 'Function');
+            this.#events[options?.once ? 'once' : 'on'](types, listener);
         }
     }
     /**
@@ -350,11 +355,8 @@ class AstNode {
                 this.removeEventListener(type, listener);
             }
         }
-        else if (typeof types === 'string' && typeof listener === 'function') {
-            this.#events.off(types, listener);
-        }
         else {
-            this.typeError('removeEventListener', 'String', 'Function');
+            this.#events.off(types, listener);
         }
     }
     /**
@@ -367,11 +369,8 @@ class AstNode {
                 this.removeAllEventListeners(type);
             }
         }
-        else if (types === undefined || typeof types === 'string') {
-            this.#events.removeAllListeners(types);
-        }
         else {
-            this.typeError('removeAllEventListeners', 'String');
+            this.#events.removeAllListeners(types);
         }
     }
     /**
@@ -379,7 +378,7 @@ class AstNode {
      * @param type 事件类型
      */
     listEventListeners(type) {
-        return typeof type === 'string' ? this.#events.listeners(type) : this.typeError('listEventListeners', 'String');
+        return this.#events.listeners(type);
     }
     /**
      * 触发事件
@@ -387,10 +386,7 @@ class AstNode {
      * @param data 事件数据
      */
     dispatchEvent(e, data) {
-        if (!(e instanceof Event)) {
-            this.typeError('dispatchEvent', 'Event');
-        }
-        else if (!e.target) { // 初始化
+        if (!e.target) { // 初始化
             Object.defineProperty(e, 'target', { value: this, enumerable: true });
             /** 终止冒泡 */
             e.stopPropagation = function () {
@@ -422,10 +418,7 @@ class AstNode {
      * @throws `Error` 不在同一个语法树
      */
     compareDocumentPosition(other) {
-        if (!(other instanceof AstNode)) {
-            this.typeError('compareDocumentPosition', 'AstNode');
-        }
-        else if (this === other) {
+        if (this === other) {
             return 0;
         }
         else if (this.contains(other)) {
@@ -447,27 +440,19 @@ class AstNode {
      * @param left 列号
      */
     indexFromPos(top, left) {
-        if (!Number.isInteger(top) || !Number.isInteger(left)) {
-            this.typeError('indexFromPos', 'Number');
-        }
         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;
     }
-    /**
-     * 获取当前节点的相对位置，或其第`j`个子节点的相对位置
-     * @param j 子节点序号
-     */
-    #getPosition(j) {
-        return j === undefined
-            ? this.parentNode?.posFromIndex(this.getRelativeIndex()) ?? { top: 0, left: 0 }
-            : this.posFromIndex(this.getRelativeIndex(j));
+    /** 获取当前节点的相对位置 */
+    #getPosition() {
+        return this.parentNode?.posFromIndex(this.getRelativeIndex()) ?? { top: 0, left: 0 };
     }
     /** 获取当前节点的行列位置和大小 */
     getBoundingClientRect() {
         return { ...this.#getDimension(), ...this.getRootNode().posFromIndex(this.getAbsoluteIndex()) };
     }
 }
-Parser.classes['AstNode'] = __filename;
-module.exports = AstNode;
+exports.AstNode = AstNode;
+index_1.default.classes['AstNode'] = __filename;

package/dist/lib/range.d.ts

@@ -0,0 +1,132 @@
+import type { AstNodes, Token } from '../internal';
+import type { Dimension, Position } from './node';
+/** 模拟Range对象 */
+export declare class AstRange {
+    #private;
+    /** 起点容器 */
+    get startContainer(): AstNodes;
+    /** 起点位置 */
+    get startOffset(): number;
+    /** 起点绝对位置 */
+    get startIndex(): number;
+    /** 终点容器 */
+    get endContainer(): AstNodes;
+    /** 终点位置 */
+    get endOffset(): number;
+    /** 终点绝对位置 */
+    get endIndex(): number;
+    /** 起始和终止位置是否重合 */
+    get collapsed(): boolean;
+    /** 最近的公共祖先 */
+    get commonAncestorContainer(): AstNodes;
+    /**
+     * 设置起点
+     * @param startNode 起点容器
+     * @param startOffset 起点位置
+     * @throws `RangeError` 不在同一个文档
+     * @throws `RangeError` offset取值超出范围
+     */
+    setStart(startNode: AstNodes, startOffset: number): void;
+    /**
+     * 设置终点
+     * @param endNode 终点容器
+     * @param endOffset 终点位置
+     * @throws `RangeError` 不在同一个文档
+     * @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;
+    /**
+     * 根据字符位置设置起点
+     * @param root 根节点
+     * @param index 字符位置
+     */
+    setStartIndex(root: Token, index: number): void;
+    /**
+     * 根据字符位置设置终点
+     * @param root 根节点
+     * @param index 字符位置
+     */
+    setEndIndex(root: Token, index: number): void;
+    /**
+     * 根据行列号设置起点
+     * @param root 根节点
+     * @param x 列
+     * @param y 行
+     */
+    setStartPoint(root: Token, x: number, y: number): void;
+    /**
+     * 根据行列号设置终点
+     * @param root 根节点
+     * @param x 列
+     * @param y 行
+     */
+    setEndPoint(root: Token, x: number, y: number): 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 端点位置
+     * @throws `RangeError` 不在同一个文档
+     */
+    isPointInRange(referenceNode: AstNodes, offset: number): boolean;
+    /**
+     * 是否与节点相交
+     * @param referenceNode 节点
+     * @throws `RangeError` 不在同一个文档
+     */
+    intersectsNode(referenceNode: AstNodes): boolean;
+    /** 复制 */
+    cloneRange(): AstRange;
+    /** 删除 */
+    deleteContents(): void;
+    /** 获取行列位置和大小 */
+    getBoundingClientRect(): Dimension & Position;
+    /**
+     * 在起始位置插入节点
+     * @param newNode 插入的节点
+     */
+    insertNode(newNode: AstNodes): void;
+    /** 范围内的全部文本 */
+    toString(): string;
+}