wikiparser-node 1.9.1-b → 1.9.1

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[];
+}

package/dist/lib/range.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstRange = void 0;
+const constants_1 = require("../util/constants");
+/**
+ * 计算绝对位置
+ * @param referenceNode 容器
+ * @param offset 相对位置
+ */
+const getIndex = (referenceNode, offset) => referenceNode.getAbsoluteIndex() + referenceNode.getRelativeIndex(offset);
+/**
+ * 获取父节点或抛出错误
+ * @param node 参考节点
+ * @throws `RangeError` 参考节点没有父节点
+ */
+const getParent = (node) => {
+    const { parentNode } = node;
+    if (parentNode) {
+        return parentNode;
+    }
+    throw new RangeError('The reference node has no parent node!');
+};
+/** 模拟Range对象 */
+class AstRange {
+    #startContainer;
+    #startOffset;
+    #endContainer;
+    #endOffset;
+    /** 起点容器 */
+    get startContainer() {
+        return this.#startContainer ?? this.#notInit(true);
+    }
+    /** 起点位置 */
+    get startOffset() {
+        return this.#startOffset ?? this.#notInit(true);
+    }
+    /** 起点绝对位置 */
+    get startIndex() {
+        return getIndex(this.startContainer, this.startOffset);
+    }
+    /** 起点行列位置 */
+    get startPos() {
+        return this.startContainer.getRootNode().posFromIndex(this.startIndex);
+    }
+    /** 终点容器 */
+    get endContainer() {
+        return this.#endContainer ?? this.#notInit(false);
+    }
+    /** 终点位置 */
+    get endOffset() {
+        return this.#endOffset ?? this.#notInit(false);
+    }
+    /** 终点绝对位置 */
+    get endIndex() {
+        return getIndex(this.endContainer, this.endOffset);
+    }
+    /** 终点行列位置 */
+    get endPos() {
+        return this.endContainer.getRootNode().posFromIndex(this.endIndex);
+    }
+    /** 起始和终止位置是否重合 */
+    get collapsed() {
+        return this.startContainer === this.endContainer && this.startOffset === this.endOffset;
+    }
+    /** 最近的公共祖先 */
+    get commonAncestorContainer() {
+        const { startContainer, endContainer } = this;
+        return startContainer.contains(endContainer) ? startContainer : startContainer.parentNode;
+    }
+    /**
+     * 未初始化时抛出错误
+     * @param start 是否未初始化起点
+     * @throws `Error` 未初始化
+     */
+    #notInit(start) {
+        throw new Error(`Please set the ${start ? 'start' : 'end'} position first!`);
+    }
+    /**
+     * 检查起点和终点的设置是否有效
+     * @throws `RangeError` 起点和终点不是兄弟节点
+     * @throws `RangeError` 起点位于终点之后
+     */
+    #check() {
+        const { startContainer, startOffset, endContainer, endOffset } = this, msg1 = 'The start and end positions are not siblings!', msg2 = 'The start position cannot be after the end position!';
+        if (startContainer === endContainer) {
+            if (startOffset > endOffset) {
+                throw new RangeError(msg2);
+            }
+            return;
+        }
+        const { type: startType, parentNode: startParent } = startContainer, { type: endType, parentNode: endParent } = endContainer;
+        if (startType !== 'text') {
+            if (endType !== 'text' || startContainer !== endParent) {
+                throw new RangeError(msg1);
+            }
+            else if (startOffset > endParent.childNodes.indexOf(endContainer)) {
+                throw new RangeError(msg2);
+            }
+        }
+        else if (endType === 'text') {
+            if (!startParent || startParent !== endParent) {
+                throw new RangeError(msg1);
+            }
+            const { childNodes } = startParent;
+            if (childNodes.indexOf(startContainer) > childNodes.indexOf(endContainer)) {
+                throw new RangeError(msg2);
+            }
+        }
+        else if (startParent !== endContainer) {
+            throw new RangeError(msg1);
+        }
+        else if (endOffset <= startParent.childNodes.indexOf(startContainer)) {
+            throw new RangeError(msg2);
+        }
+    }
+    /**
+     * 设置起点
+     * @param startNode 起点容器
+     * @param offset 起点位置
+     * @throws `RangeError` offset取值超出范围
+     */
+    setStart(startNode, offset) {
+        const { length } = startNode;
+        if (offset < 0 || offset > length) {
+            throw new RangeError(`The range of startOffset should be 0 ~ ${length}`);
+        }
+        const startContainer = this.#startContainer, startOffset = this.#startOffset;
+        this.#startContainer = startNode;
+        this.#startOffset = offset;
+        if (this.#endContainer) {
+            try {
+                this.#check();
+            }
+            catch (e) {
+                this.#startContainer = startContainer;
+                this.#startOffset = startOffset;
+                throw e;
+            }
+        }
+    }
+    /**
+     * 设置终点
+     * @param endNode 终点容器
+     * @param offset 终点位置
+     * @throws `RangeError` offset取值超出范围
+     */
+    setEnd(endNode, offset) {
+        const { length } = endNode;
+        if (offset < 0 || offset > length) {
+            throw new RangeError(`The range of endOffset should be 0 ~ ${length}`);
+        }
+        const endContainer = this.#endContainer, endOffset = this.#endOffset;
+        this.#endContainer = endNode;
+        this.#endOffset = offset;
+        if (this.#startContainer) {
+            try {
+                this.#check();
+            }
+            catch (e) {
+                this.#endContainer = endContainer;
+                this.#endOffset = endOffset;
+                throw e;
+            }
+        }
+    }
+    /**
+     * 在节点后设置
+     * @param method 方法名
+     * @param referenceNode 节点
+     */
+    #setAfter(method, referenceNode) {
+        const parentNode = getParent(referenceNode);
+        this[method](parentNode, parentNode.childNodes.indexOf(referenceNode) + 1);
+    }
+    /**
+     * 在节点后设置起点
+     * @param referenceNode 节点
+     */
+    setStartAfter(referenceNode) {
+        this.#setAfter('setStart', referenceNode);
+    }
+    /**
+     * 在节点后设置终点
+     * @param referenceNode 节点
+     */
+    setEndAfter(referenceNode) {
+        this.#setAfter('setEnd', referenceNode);
+    }
+    /**
+     * 在节点前设置
+     * @param method 方法名
+     * @param referenceNode 节点
+     */
+    #setBefore(method, referenceNode) {
+        const parentNode = getParent(referenceNode);
+        this[method](parentNode, parentNode.childNodes.indexOf(referenceNode));
+    }
+    /**
+     * 在节点前设置起点
+     * @param referenceNode 节点
+     */
+    setStartBefore(referenceNode) {
+        this.#setBefore('setStart', referenceNode);
+    }
+    /**
+     * 在节点前设置终点
+     * @param referenceNode 节点
+     */
+    setEndBefore(referenceNode) {
+        this.#setBefore('setEnd', referenceNode);
+    }
+    /**
+     * 设置Range包含整个节点的内容
+     * @param referenceNode 节点
+     */
+    selectNodeContents(referenceNode) {
+        this.#startContainer = referenceNode;
+        this.#startOffset = 0;
+        this.#endContainer = referenceNode;
+        this.#endOffset = referenceNode.length;
+    }
+    /**
+     * 设置Range包含整个节点
+     * @param referenceNode 节点
+     */
+    selectNode(referenceNode) {
+        const parentNode = getParent(referenceNode), i = parentNode.childNodes.indexOf(referenceNode);
+        this.#startContainer = parentNode;
+        this.#startOffset = i;
+        this.#endContainer = parentNode;
+        this.#endOffset = i + 1;
+    }
+    /**
+     * 使起始和终止位置重合
+     * @param toStart 重合至起始位置
+     */
+    collapse(toStart) {
+        if (toStart) {
+            this.#endContainer = this.startContainer;
+            this.#endOffset = this.startOffset;
+        }
+        else {
+            this.#startContainer = this.endContainer;
+            this.#startOffset = this.endOffset;
+        }
+    }
+    /**
+     * 比较端点和Range的位置
+     * @param referenceNode 端点容器
+     * @param offset 端点位置
+     * @throws `RangeError` 不在同一个文档
+     */
+    comparePoint(referenceNode, offset) {
+        const { startContainer, startIndex, endContainer, endIndex } = this;
+        if (startContainer.getRootNode() !== referenceNode.getRootNode()) {
+            throw new RangeError('The point to be compared is not in the same document!');
+        }
+        const index = getIndex(referenceNode, offset);
+        if (index < startIndex || index === startIndex && !startContainer.contains(referenceNode)) {
+            return -1;
+        }
+        return index < endIndex || index === endIndex && endContainer.contains(referenceNode) ? 0 : 1;
+    }
+    /**
+     * 端点是否在Range中
+     * @param referenceNode 端点容器
+     * @param offset 端点位置
+     */
+    isPointInRange(referenceNode, offset) {
+        return this.comparePoint(referenceNode, offset) === 0;
+    }
+    /** 复制AstRange对象 */
+    cloneRange() {
+        const range = new AstRange();
+        range.setStart(this.startContainer, this.startOffset);
+        range.setEnd(this.endContainer, this.endOffset);
+        return range;
+    }
+    /** 清空Range */
+    detach() {
+        this.#startContainer = undefined;
+        this.#startOffset = undefined;
+        this.#endContainer = undefined;
+        this.#endOffset = undefined;
+    }
+    /** 删除Range中的内容 */
+    deleteContents() {
+        const { startContainer, endContainer, commonAncestorContainer } = this, { childNodes } = commonAncestorContainer;
+        let { startOffset, endOffset } = this;
+        if (commonAncestorContainer.type === 'text') {
+            commonAncestorContainer.deleteData(startOffset, endOffset);
+            this.#endOffset = this.#startOffset;
+            return;
+        }
+        else if (startContainer.type === 'text') {
+            startContainer.deleteData(startOffset, Infinity);
+            startOffset = childNodes.indexOf(startContainer) + 1;
+        }
+        if (endContainer.type === 'text') {
+            endContainer.deleteData(0, endOffset);
+            endOffset = childNodes.indexOf(endContainer);
+        }
+        for (let i = endOffset - 1; i >= startOffset; i--) {
+            commonAncestorContainer.removeAt(i);
+        }
+        this.#startContainer = commonAncestorContainer;
+        this.#startOffset = startOffset;
+        this.#endContainer = commonAncestorContainer;
+        this.#endOffset = startOffset;
+    }
+    /** 获取行列位置和大小 */
+    getBoundingClientRect() {
+        const { startPos: { top, left }, endPos: { top: bottom, left: right } } = this;
+        return { top, left, height: bottom - top + 1, width: bottom === top ? right - left : right };
+    }
+    /**
+     * 在起始位置插入节点
+     * @param newNode 插入的节点
+     */
+    insertNode(newNode) {
+        const { startContainer, startOffset } = this, endContainer = this.#endContainer;
+        if (startContainer.type === 'text') {
+            if (startOffset) {
+                startContainer.splitText(startOffset);
+                this.#startContainer = startContainer.nextSibling;
+                this.#startOffset = 0;
+                startContainer.after(newNode);
+                if (endContainer === startContainer) {
+                    this.#endContainer = this.#startContainer;
+                    this.#endOffset -= startOffset;
+                }
+                else if (endContainer) {
+                    this.#endOffset += 2;
+                }
+            }
+            else {
+                startContainer.before(newNode);
+                if (endContainer && endContainer !== startContainer) {
+                    this.#endOffset++;
+                }
+            }
+        }
+        else {
+            startContainer.insertAt(newNode, startOffset);
+            this.#startOffset++;
+            if (endContainer === startContainer) {
+                this.#endOffset++;
+            }
+        }
+    }
+    /** @private */
+    toString() {
+        const { startContainer, startIndex, endIndex } = this;
+        return startContainer.getRootNode().toString().slice(startIndex, endIndex);
+    }
+    /** 获取范围内的全部节点 */
+    extractContents() {
+        const { startContainer, startOffset, endContainer, endOffset, commonAncestorContainer } = this, { childNodes } = commonAncestorContainer;
+        let from, to;
+        if (commonAncestorContainer.type === 'text') {
+            if (startOffset === endOffset) {
+                return [];
+            }
+            else if (endOffset < commonAncestorContainer.length) {
+                commonAncestorContainer.splitText(endOffset);
+            }
+            if (startOffset) {
+                const nextSibling = commonAncestorContainer.splitText(startOffset);
+                this.#startContainer = nextSibling;
+                this.#startOffset = 0;
+                this.#endContainer = nextSibling;
+                this.#endOffset -= startOffset;
+                return [nextSibling];
+            }
+            return [commonAncestorContainer];
+        }
+        else if (endContainer.type === 'text') {
+            if (endOffset && endOffset < endContainer.length) {
+                endContainer.splitText(endOffset);
+            }
+            to = childNodes.indexOf(endContainer) + (endOffset && 1);
+        }
+        else {
+            to = endOffset;
+        }
+        if (startContainer.type === 'text') {
+            if (startOffset && startOffset < startContainer.length) {
+                this.#startContainer = startContainer.splitText(startOffset);
+                this.#startOffset = 0;
+                this.#endOffset++;
+                to++;
+            }
+            from = childNodes.indexOf(startContainer) + (startOffset && 1);
+        }
+        else {
+            from = startOffset;
+        }
+        return commonAncestorContainer.childNodes.slice(from, to);
+    }
+    /** 拷贝范围内的全部节点 */
+    cloneContents() {
+        return this.extractContents().map(node => node.cloneNode());
+    }
+}
+exports.AstRange = AstRange;
+constants_1.classes['AstRange'] = __filename;

package/dist/lib/ranges.d.ts

@@ -0,0 +1,28 @@
+/** 模拟Python的Range对象。除`step`至少为`1`外，允许负数、小数或`end < start`的情形。 */
+export declare class Range {
+    readonly start: number;
+    readonly end: number;
+    readonly step: number;
+    /**
+     * @param s 表达式
+     * @throws `RangeError` 起点、终点和步长均应为整数
+     * @throws `RangeError` n的系数不能为0
+     * @throws `RangeError` 应使用CSS选择器或Python切片的格式
+     */
+    constructor(str: string);
+    /**
+     * 将Range转换为针对特定数组的下标集
+     * @param arr 参考数组`[0, 1, 2, ...]`
+     */
+    applyTo(arr: readonly number[]): number[];
+}
+/** @extends {Array<number|Range>} */
+export declare class Ranges extends Array<number | Range> {
+    /** @param a 表达式数组 */
+    constructor(a?: number | string | Range | readonly (number | string | Range)[]);
+    /**
+     * 将Ranges转换为针对特定Array的下标集
+     * @param arr 参考数组
+     */
+    applyTo(arr: number | readonly unknown[]): number[];
+}

package/dist/lib/ranges.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ranges = exports.Range = void 0;
+const constants_1 = require("../util/constants");
+const debug_1 = require("../util/debug");
+const diff_1 = require("../util/diff");
+/** 模拟Python的Range对象。除`step`至少为`1`外，允许负数、小数或`end < start`的情形。 */
+class Range {
+    start;
+    end;
+    step;
+    /**
+     * @param s 表达式
+     * @throws `RangeError` 起点、终点和步长均应为整数
+     * @throws `RangeError` n的系数不能为0
+     * @throws `RangeError` 应使用CSS选择器或Python切片的格式
+     */
+    constructor(str) {
+        str = str.trim();
+        if (str === 'odd') {
+            Object.assign(this, { start: 1, end: Infinity, step: 2 });
+        }
+        else if (str === 'even') {
+            Object.assign(this, { start: 0, end: Infinity, step: 2 });
+        }
+        else if (str.includes(':')) {
+            const [start, end, step = '1'] = str.split(':', 3);
+            this.start = Number(start);
+            this.end = Number(end?.trim() || Infinity);
+            this.step = Math.max(Number(step), 1);
+            if (!Number.isInteger(this.start)) {
+                throw new RangeError(`The start of a range, \`${start}\`, should be an integer!`);
+            }
+            else if (this.end !== Infinity && !Number.isInteger(this.end)) {
+                throw new RangeError(`The end of a range, \`${end}\`, should be an integer!`);
+            }
+            else if (!Number.isInteger(this.step)) {
+                throw new RangeError(`The step of a range, \`${step}\`, should be an integer!`);
+            }
+        }
+        else {
+            const mt = /^([+-])?(\d+)?n(?:\s*([+-])\s*(\d+))?$/u
+                .exec(str);
+            if (mt) {
+                const [, sgnA = '+', a = 1, sgnB = '+'] = mt, b = Number(mt[4] ?? 0);
+                this.step = Number(a);
+                if (this.step === 0) {
+                    throw new RangeError(`In the argument \`${str}\`, the coefficient of "n" must not be 0!`);
+                }
+                else if (sgnA === '+') { // `an+b` or `an-b`
+                    this.start = sgnB === '+' || b === 0 ? b : this.step - 1 - (b - 1) % this.step;
+                    this.end = Infinity;
+                }
+                else if (sgnB === '-') { // `-an-b`
+                    this.start = 0;
+                    this.end = b > 0 ? 0 : this.step;
+                }
+                else { // `-an+b`
+                    this.start = b % this.step;
+                    this.end = this.step + b;
+                }
+            }
+            else {
+                throw new RangeError(`The argument \`${str}\` should be either in the form of "an+b" as in CSS selectors or Python slices!`);
+            }
+        }
+    }
+    /**
+     * 将Range转换为针对特定数组的下标集
+     * @param arr 参考数组`[0, 1, 2, ...]`
+     */
+    applyTo(arr) {
+        return arr.slice(this.start, this.end).filter((_, j) => j % this.step === 0);
+    }
+}
+exports.Range = Range;
+/** @extends {Array<number|Range>} */
+class Ranges extends Array {
+    /** @param a 表达式数组 */
+    constructor(a) {
+        super();
+        if (a === undefined) {
+            return;
+        }
+        for (const ele of (Array.isArray(a) ? a : [a])) {
+            if (ele instanceof Range) {
+                this.push(ele);
+                continue;
+            }
+            else if (typeof ele === 'string' && !ele.trim()) {
+                continue;
+            }
+            const number = Number(ele);
+            if (Number.isInteger(number)) {
+                this.push(number);
+            }
+            else if (typeof ele === 'string' && Number.isNaN(number)) {
+                try {
+                    this.push(new Range(ele));
+                }
+                catch (e) {
+                    if (e instanceof RangeError) {
+                        (0, diff_1.error)(e.message);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 将Ranges转换为针对特定Array的下标集
+     * @param arr 参考数组
+     */
+    applyTo(arr) {
+        const length = typeof arr === 'number' ? arr : arr.length, a = (0, debug_1.emptyArray)(length, i => i);
+        return [
+            ...new Set([...this].flatMap(ele => {
+                if (typeof ele === 'number') {
+                    return ele < 0 ? ele + length : ele;
+                }
+                return ele.applyTo(a);
+            })),
+        ].filter(i => i >= 0 && i < length).sort();
+    }
+}
+exports.Ranges = Ranges;
+constants_1.classes['Ranges'] = __filename;

package/dist/lib/rect.d.ts

@@ -0,0 +1,18 @@
+import type { AstNodes, Position } from './node';
+/** 节点位置 */
+export declare class BoundingRect {
+    #private;
+    readonly token: AstNodes;
+    readonly start: number;
+    /** 起点行 */
+    get top(): number;
+    /** 起点列 */
+    get left(): number;
+    /**
+     * @param token 节点
+     * @param start 起点
+     */
+    constructor(token: AstNodes, start: number);
+    /** 计算位置 */
+    getPosition(): Position;
+}