wikiparser-node 1.0.0-beta.4 → 1.0.1-b

package/dist/lib/range.d.ts

@@ -1,132 +0,0 @@
-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;
-}

package/dist/lib/range.js

@@ -1,384 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AstRange = void 0;
-const Parser = require("../index");
-/**
- * 计算绝对位置
- * @param referenceNode 容器
- * @param offset 相对位置
- */
-const getIndex = (referenceNode, offset) => referenceNode.getAbsoluteIndex() + referenceNode.getRelativeIndex(offset);
-/** 模拟Range对象 */
-class AstRange {
-    #startContainer;
-    #startOffset;
-    #endContainer;
-    #endOffset;
-    /**
-     * 未初始化时抛出错误
-     * @param start 是否未初始化起点
-     * @throws `Error` 未初始化
-     */
-    // eslint-disable-next-line class-methods-use-this
-    #notInit(start) {
-        throw new Error(`请先指定${start ? '起始' : '终止'}位置！`);
-    }
-    /** 起点容器 */
-    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 endContainer() {
-        return this.#endContainer ?? this.#notInit(false);
-    }
-    /** 终点位置 */
-    get endOffset() {
-        return this.#endOffset ?? this.#notInit(false);
-    }
-    /** 终点绝对位置 */
-    get endIndex() {
-        return getIndex(this.endContainer, this.endOffset);
-    }
-    /** 起始和终止位置是否重合 */
-    get collapsed() {
-        return this.startIndex === this.endIndex;
-    }
-    /** 最近的公共祖先 */
-    get commonAncestorContainer() {
-        const { startContainer, endContainer } = this;
-        let parentNode = startContainer;
-        while (!parentNode.contains(endContainer)) {
-            ({ parentNode } = parentNode);
-        }
-        return parentNode;
-    }
-    /**
-     * 设置起点
-     * @param startNode 起点容器
-     * @param startOffset 起点位置
-     * @throws `RangeError` 不在同一个文档
-     * @throws `RangeError` offset取值超出范围
-     */
-    setStart(startNode, startOffset) {
-        const root = this.#endContainer?.getRootNode(), { length } = startNode;
-        if (root && root !== startNode.getRootNode()) {
-            throw new RangeError('起点不在同一个文档中！');
-        }
-        else if (startOffset < 0 || startOffset > length) {
-            throw new RangeError(`offset取值范围应为 0 ~ ${length}`);
-        }
-        else if (root && getIndex(startNode, startOffset) > this.endIndex) {
-            throw new RangeError('起点不能位于终点之后！');
-        }
-        this.#startContainer = startNode;
-        this.#startOffset = startOffset;
-    }
-    /**
-     * 设置终点
-     * @param endNode 终点容器
-     * @param endOffset 终点位置
-     * @throws `RangeError` 不在同一个文档
-     * @throws `RangeError` offset取值超出范围
-     */
-    setEnd(endNode, endOffset) {
-        const root = this.#startContainer?.getRootNode(), { length } = endNode;
-        if (root && root !== endNode.getRootNode()) {
-            throw new RangeError('终点不在同一个文档中！');
-        }
-        else if (endOffset < 0 || endOffset > length) {
-            throw new RangeError(`offset取值范围应为 0 ~ ${length}`);
-        }
-        else if (root && getIndex(endNode, endOffset) < this.startIndex) {
-            throw new RangeError('终点不能位于起点之前！');
-        }
-        this.#endContainer = endNode;
-        this.#endOffset = endOffset;
-    }
-    /**
-     * 在节点后设置
-     * @param method 方法名
-     * @param referenceNode 节点
-     */
-    #setAfter(method, referenceNode) {
-        if (referenceNode.type === 'root') {
-            this[method](referenceNode, referenceNode.length);
-        }
-        else {
-            const { parentNode } = 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) {
-        if (referenceNode.type === 'root') {
-            this[method](referenceNode, 0);
-        }
-        else {
-            const { parentNode } = referenceNode;
-            this[method](parentNode, parentNode.childNodes.indexOf(referenceNode));
-        }
-    }
-    /**
-     * 在节点前设置起点
-     * @param referenceNode 节点
-     */
-    setStartBefore(referenceNode) {
-        this.#setBefore('setStart', referenceNode);
-    }
-    /**
-     * 在节点前设置终点
-     * @param referenceNode 节点
-     */
-    setEndBefore(referenceNode) {
-        this.#setBefore('setEnd', referenceNode);
-    }
-    /**
-     * 根据字符位置设置
-     * @param method 方法名
-     * @param root 根节点
-     * @param index 字符位置
-     * @throws `RangeError` 超出有效范围
-     */
-    #setIndex(method, root, index) {
-        const caretPosition = root.caretPositionFromIndex(index);
-        if (caretPosition === undefined) {
-            throw new RangeError('字符坐标超出有效的范围！');
-        }
-        const { offsetNode, offset } = caretPosition;
-        if (offsetNode.type === 'text') {
-            this[method](offsetNode, offset);
-        }
-        else {
-            const i = offsetNode.childNodes.findIndex(child => child.getRelativeIndex() >= offset);
-            this[method](offsetNode, i === -1 ? offsetNode.length : i);
-        }
-    }
-    /**
-     * 根据字符位置设置起点
-     * @param root 根节点
-     * @param index 字符位置
-     */
-    setStartIndex(root, index) {
-        this.#setIndex('setStart', root, index);
-    }
-    /**
-     * 根据字符位置设置终点
-     * @param root 根节点
-     * @param index 字符位置
-     */
-    setEndIndex(root, index) {
-        this.#setIndex('setEnd', root, index);
-    }
-    /**
-     * 根据行列号设置
-     * @param method 方法名
-     * @param root 根节点
-     * @param x 列
-     * @param y 行
-     */
-    #setPoint(method, root, x, y) {
-        this.#setIndex(method, root, root.indexFromPos(y, x));
-    }
-    /**
-     * 根据行列号设置起点
-     * @param root 根节点
-     * @param x 列
-     * @param y 行
-     */
-    setStartPoint(root, x, y) {
-        this.#setPoint('setStart', root, x, y);
-    }
-    /**
-     * 根据行列号设置终点
-     * @param root 根节点
-     * @param x 列
-     * @param y 行
-     */
-    setEndPoint(root, x, y) {
-        this.#setPoint('setEnd', root, x, y);
-    }
-    /**
-     * 设置Range包含整个节点的内容
-     * @param referenceNode 节点
-     */
-    selectNodeContents(referenceNode) {
-        this.#startContainer = referenceNode;
-        this.#startOffset = 0;
-        this.#endContainer = referenceNode;
-        this.#endOffset = referenceNode.length;
-    }
-    /**
-     * 设置Range包含整个节点
-     * @param referenceNode 节点
-     */
-    selectNode(referenceNode) {
-        if (referenceNode.type === 'root') {
-            this.selectNodeContents(referenceNode);
-        }
-        else {
-            const { parentNode } = referenceNode, i = parentNode.childNodes.indexOf(referenceNode);
-            this.#startContainer = parentNode;
-            this.#startOffset = i;
-            this.#endContainer = parentNode;
-            this.#endOffset = i + 1;
-        }
-    }
-    /**
-     * 使起始和终止位置重合
-     * @param toStart 重合至起始位置
-     */
-    collapse(toStart = false) {
-        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, endIndex } = this;
-        if (startContainer.getRootNode() !== referenceNode.getRootNode()) {
-            throw new RangeError('待比较的端点不在同一个文档中！');
-        }
-        const index = getIndex(referenceNode, offset);
-        if (index < startIndex) {
-            return -1;
-        }
-        return index > endIndex ? 1 : 0;
-    }
-    /**
-     * 端点是否在Range中
-     * @param referenceNode 端点容器
-     * @param offset 端点位置
-     * @throws `RangeError` 不在同一个文档
-     */
-    isPointInRange(referenceNode, offset) {
-        return this.comparePoint(referenceNode, offset) === 0;
-    }
-    /**
-     * 是否与节点相交
-     * @param referenceNode 节点
-     * @throws `RangeError` 不在同一个文档
-     */
-    intersectsNode(referenceNode) {
-        const { startContainer, startIndex, endIndex } = this;
-        if (startContainer.getRootNode() !== referenceNode.getRootNode()) {
-            throw new RangeError('待比较的端点不在同一个文档中！');
-        }
-        const index = referenceNode.getAbsoluteIndex();
-        return index < endIndex && index + String(referenceNode).length > startIndex;
-    }
-    /** 复制 */
-    cloneRange() {
-        const range = new AstRange();
-        range.setStart(this.startContainer, this.startOffset);
-        range.setEnd(this.endContainer, this.endOffset);
-        return range;
-    }
-    /** 删除 */
-    deleteContents() {
-        const { startContainer, startOffset } = this;
-        let { endContainer, endOffset } = this, parentNode;
-        while (!endContainer.contains(startContainer)) {
-            ({ parentNode } = endContainer);
-            if (endContainer.type === 'text') {
-                endContainer.deleteData(0, endOffset);
-            }
-            else {
-                for (let i = endOffset - 1; i >= 0; i--) {
-                    endContainer.removeAt(i);
-                }
-            }
-            endOffset = parentNode.childNodes.indexOf(endContainer);
-            endContainer = parentNode;
-        }
-        while (endContainer !== startContainer) {
-            const { childNodes } = endContainer, j = childNodes.findIndex(child => child.contains(startContainer));
-            for (let i = endOffset - 1; i > j; i--) {
-                endContainer.removeAt(i);
-            }
-            endContainer = childNodes[j];
-            endOffset = endContainer.length;
-        }
-        if (endContainer.type === 'text') {
-            endContainer.deleteData(startOffset, endOffset);
-        }
-        else {
-            for (let i = endOffset - 1; i >= startOffset; i--) {
-                endContainer.removeAt(i);
-            }
-        }
-        this.#endContainer = endContainer;
-        this.#endOffset = startOffset;
-    }
-    /** 获取行列位置和大小 */
-    getBoundingClientRect() {
-        let { startContainer, startOffset, endContainer, endOffset } = this, parentNode;
-        while (!startContainer.contains(endContainer)) {
-            ({ parentNode } = startContainer);
-            startOffset = parentNode.childNodes.indexOf(startContainer);
-            startContainer = parentNode;
-        }
-        while (endContainer !== startContainer) {
-            ({ parentNode } = endContainer);
-            endOffset = parentNode.childNodes.indexOf(endContainer) + 1;
-            endContainer = parentNode;
-        }
-        const { top, left } = startContainer.posFromIndex(startContainer.getRelativeIndex(startOffset)), { top: bottom, left: right } = startContainer.posFromIndex(startContainer.getRelativeIndex(endOffset));
-        return { top, left, height: bottom - top + 1, width: bottom === top ? right - left : right };
-    }
-    /**
-     * 在起始位置插入节点
-     * @param newNode 插入的节点
-     */
-    insertNode(newNode) {
-        const { startContainer, startOffset } = this;
-        if (startContainer.type === 'text') {
-            startContainer.splitText(startOffset);
-            startContainer.after(newNode);
-        }
-        else {
-            startContainer.insertAt(newNode, startOffset);
-        }
-    }
-    /** 范围内的全部文本 */
-    toString() {
-        return String(this.startContainer.getRootNode()).slice(this.startIndex, this.endIndex);
-    }
-}
-exports.AstRange = AstRange;
-Parser.classes['AstRange'] = __filename;

package/dist/lib/ranges.d.ts

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

package/dist/lib/ranges.js

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ranges = exports.Range = void 0;
-const Parser = require("../index");
-/** 模拟Python的Range对象。除`step`至少为`1`外，允许负数、小数或`end < start`的情形。 */
-class Range {
-    start;
-    end;
-    step;
-    /**
-     * @param s 表达式
-     * @throws `RangeError` 起点、终点和步长均应为整数
-     * @throws `RangeError` n的系数不能为0
-     * @throws `RangeError` 应使用CSS选择器或Python切片的格式
-     */
-    constructor(s) {
-        if (s instanceof Range) {
-            Object.assign(this, s);
-            return;
-        }
-        const str = s.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 || Infinity);
-            this.step = Math.max(Number(step), 1);
-            if (!Number.isInteger(this.start)) {
-                throw new RangeError(`起点 ${this.start} 应为整数！`);
-            }
-            else if (this.end !== Infinity && !Number.isInteger(this.end)) {
-                throw new RangeError(`终点 ${this.end} 应为整数！`);
-            }
-            else if (!Number.isInteger(this.step)) {
-                throw new RangeError(`步长 ${this.step} 应为整数！`);
-            }
-        }
-        else {
-            const mt = /^([+-])?(\d+)?n(?:([+-])(\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(`参数 ${str} 中 "n" 的系数不允许为 0！`);
-                }
-                else if (sgnA === '+') {
-                    this.start = sgnB === '+' || b === 0 ? b : this.step - 1 - (b - 1) % this.step;
-                    this.end = Infinity;
-                }
-                else if (sgnB === '-') {
-                    this.start = 0;
-                    this.end = b > 0 ? 0 : this.step;
-                }
-                else {
-                    this.start = b % this.step;
-                    this.end = this.step + b;
-                }
-            }
-            else {
-                throw new RangeError(`参数 ${str} 应写作CSS选择器的 "an+b" 形式或Python切片！`);
-            }
-        }
-    }
-    /**
-     * 将Range转换为针对特定数组的下标集
-     * @param arr 参考数组
-     */
-    applyTo(arr) {
-        return new Array(typeof arr === 'number' ? arr : arr.length).fill(undefined).map((_, i) => i)
-            .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;
-        }
-        const arr = Array.isArray(a) ? a : [a];
-        for (const ele of arr) {
-            if (ele instanceof Range) {
-                this.push(new Range(ele));
-                continue;
-            }
-            const number = Number(ele);
-            if (Number.isInteger(number)) {
-                this.push(number);
-            }
-            else if (typeof ele === 'string' && Number.isNaN(number)) {
-                try {
-                    const range = new Range(ele);
-                    this.push(range);
-                }
-                catch { }
-            }
-        }
-    }
-    /**
-     * 将Ranges转换为针对特定Array的下标集
-     * @param arr 参考数组
-     */
-    applyTo(arr) {
-        const length = typeof arr === 'number' ? arr : arr.length;
-        return [
-            ...new Set([...this].flatMap(ele => {
-                if (typeof ele === 'number') {
-                    return ele < 0 ? ele + length : ele;
-                }
-                return ele.applyTo(length);
-            })),
-        ].filter(i => i >= 0 && i < length).sort();
-    }
-}
-exports.Ranges = Ranges;
-Parser.classes['Ranges'] = __filename;