wikiparser-node 1.2.0-b → 1.2.0

package/dist/lib/range.js

@@ -0,0 +1,385 @@
+"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);
+/** 模拟Range对象 */
+class AstRange {
+    #startContainer;
+    #startOffset;
+    #endContainer;
+    #endOffset;
+    /**
+     * 未初始化时抛出错误
+     * @param start 是否未初始化起点
+     * @throws `Error` 未初始化
+     */
+    #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 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;
+    }
+    /**
+     * 检查起点和终点的设置是否有效
+     * @throws `RangeError` 起点和终点不是兄弟节点
+     * @throws `RangeError` 起点位于终点之后
+     */
+    #check() {
+        const { startContainer, startOffset, endContainer, endOffset } = this;
+        if (startContainer === endContainer) {
+            if (startOffset > endOffset) {
+                throw new RangeError('起点不能位于终点之后！');
+            }
+            return;
+        }
+        const { type: startType, parentNode: startParent } = startContainer, { type: endType, parentNode: endParent } = endContainer;
+        if (startType !== 'text') {
+            if (endType !== 'text' || startContainer !== endParent) {
+                throw new RangeError('起点和终点不是兄弟节点！');
+            }
+            else if (startOffset > endParent.childNodes.indexOf(endContainer)) {
+                throw new RangeError('起点不能位于终点之后！');
+            }
+        }
+        else if (endType === 'text') {
+            if (!startParent || startParent !== endParent) {
+                throw new RangeError('起点和终点不是兄弟节点！');
+            }
+            const { childNodes } = startParent;
+            if (childNodes.indexOf(startContainer) > childNodes.indexOf(endContainer)) {
+                throw new RangeError('起点不能位于终点之后！');
+            }
+        }
+        else if (startParent !== endContainer) {
+            throw new RangeError('起点和终点不是兄弟节点！');
+        }
+        else if (endOffset <= startParent.childNodes.indexOf(startContainer)) {
+            throw new RangeError('起点不能位于终点之后！');
+        }
+    }
+    /**
+     * 设置起点
+     * @param startNode 起点容器
+     * @param startOffset 起点位置
+     * @throws `RangeError` offset取值超出范围
+     */
+    setStart(startNode, startOffset) {
+        const { length } = startNode;
+        if (startOffset < 0 || startOffset > length) {
+            throw new RangeError(`offset取值范围应为 0 ~ ${length}`);
+        }
+        this.#startContainer = startNode;
+        this.#startOffset = startOffset;
+        if (this.#endContainer) {
+            try {
+                this.#check();
+            }
+            catch (e) {
+                this.#startContainer = undefined;
+                this.#startOffset = undefined;
+                throw e;
+            }
+        }
+    }
+    /**
+     * 设置终点
+     * @param endNode 终点容器
+     * @param endOffset 终点位置
+     * @throws `RangeError` offset取值超出范围
+     */
+    setEnd(endNode, endOffset) {
+        const { length } = endNode;
+        if (endOffset < 0 || endOffset > length) {
+            throw new RangeError(`offset取值范围应为 0 ~ ${length}`);
+        }
+        this.#endContainer = endNode;
+        this.#endOffset = endOffset;
+        if (this.#startContainer) {
+            try {
+                this.#check();
+            }
+            catch (e) {
+                this.#endContainer = undefined;
+                this.#endOffset = undefined;
+                throw e;
+            }
+        }
+    }
+    /**
+     * 在节点后设置
+     * @param method 方法名
+     * @param referenceNode 节点
+     * @throws `RangeError` 参考节点没有父节点
+     */
+    #setAfter(method, referenceNode) {
+        const { parentNode } = referenceNode;
+        if (!parentNode) {
+            throw new RangeError('参考节点没有父节点！');
+        }
+        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 节点
+     * @throws `RangeError` 参考节点没有父节点
+     */
+    #setBefore(method, referenceNode) {
+        const { parentNode } = referenceNode;
+        if (!parentNode) {
+            throw new RangeError('参考节点没有父节点！');
+        }
+        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 节点
+     * @throws `RangeError` 参考节点没有父节点
+     */
+    selectNode(referenceNode) {
+        const { parentNode } = referenceNode;
+        if (!parentNode) {
+            throw new RangeError('参考节点没有父节点！');
+        }
+        const 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, endContainer, endIndex } = this;
+        if (startContainer.getRootNode() !== referenceNode.getRootNode()) {
+            throw new RangeError('待比较的端点不在同一个文档中！');
+        }
+        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中的内容 */
+    deleteContents() {
+        const { startContainer, endContainer, commonAncestorContainer } = this, { childNodes } = commonAncestorContainer;
+        let { startOffset, endOffset } = this;
+        if (commonAncestorContainer.type === 'text') {
+            commonAncestorContainer.deleteData(startOffset, endOffset);
+            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 && endContainer.type !== 'text') {
+                    this.#endOffset += 2;
+                }
+            }
+            else {
+                startContainer.before(newNode);
+                if (endContainer && endContainer.type !== 'text') {
+                    this.#endOffset++;
+                }
+            }
+        }
+        else {
+            startContainer.insertAt(newNode, startOffset);
+            this.#startOffset++;
+            if (endContainer === startContainer) {
+                this.#endOffset++;
+            }
+        }
+    }
+    /** @private */
+    toString() {
+        const { startContainer, startIndex, endIndex } = this;
+        return String(startContainer.getRootNode()).slice(startIndex, endIndex);
+    }
+    /** 获取范围内的全部节点 */
+    extractContents() {
+        const { startContainer, startOffset, endContainer, endOffset, commonAncestorContainer } = this, { childNodes } = commonAncestorContainer;
+        if (commonAncestorContainer.type === 'text') {
+            if (startOffset === endOffset) {
+                return [];
+            }
+            commonAncestorContainer.splitText(endOffset);
+            const nextSibling = commonAncestorContainer.splitText(startOffset);
+            this.#startContainer = nextSibling;
+            this.#startOffset = 0;
+            this.#endContainer = nextSibling;
+            this.#endOffset -= startOffset;
+            return [nextSibling];
+        }
+        else if (endContainer.type === 'text') {
+            if (endOffset && endOffset < endContainer.length) {
+                endContainer.splitText(endOffset);
+            }
+            this.#endContainer = commonAncestorContainer;
+            this.#endOffset = childNodes.indexOf(endContainer) + (endOffset && 1);
+        }
+        if (startContainer.type === 'text') {
+            if (startOffset && startOffset < startContainer.length) {
+                startContainer.splitText(startOffset);
+                this.#endOffset++;
+            }
+            this.#startContainer = commonAncestorContainer;
+            this.#startOffset = childNodes.indexOf(startContainer) + (startOffset && 1);
+        }
+        return commonAncestorContainer.childNodes.slice(this.#startOffset, this.#endOffset);
+    }
+    /** 在满足条件时拷贝范围内的全部节点 */
+    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,26 @@
+/** 模拟Python的Range对象。除`step`至少为`1`外，允许负数、小数或`end < start`的情形。 */
+export declare class Range {
+    #private;
+    /**
+     * @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[]): readonly 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[]): readonly number[];
+}

package/dist/lib/ranges.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ranges = exports.Range = void 0;
+const constants_1 = require("../util/constants");
+/** 模拟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 || 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 参考数组`[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;
+            }
+            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 { }
+            }
+        }
+    }
+    /**
+     * 将Ranges转换为针对特定Array的下标集
+     * @param arr 参考数组
+     */
+    applyTo(arr) {
+        const length = typeof arr === 'number' ? arr : arr.length, a = new Array(length).fill(undefined).map((_, 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/text.d.ts

@@ -0,0 +1,62 @@
+import { AstNode } from './node';
+import type { LintError } from '../base';
+/** 文本节点 */
+export declare class AstText extends AstNode {
+    #private;
+    readonly type = "text";
+    readonly name: undefined;
+    readonly data: string;
+    /** 文本长度 */
+    get length(): number;
+    /** @param text 包含文本 */
+    constructor(text: string);
+    /** 可见部分 */
+    text(): string;
+    /**
+     * @override
+     * @param start
+     * @throws `Error` 孤立文本节点
+     */
+    lint(start?: number): LintError[];
+    /**
+     * 替换字符串
+     * @param text 替换的字符串
+     */
+    replaceData(text: string): void;
+    /** @override */
+    print(): string;
+    /** 复制 */
+    cloneNode(): AstText;
+    /**
+     * 在后方添加字符串
+     * @param text 添加的字符串
+     */
+    appendData(text: string): void;
+    /**
+     * 删减字符串
+     * @param offset 起始位置
+     * @param count 删减字符数
+     */
+    deleteData(offset: number, count: number): void;
+    /**
+     * 插入字符串
+     * @param offset 插入位置
+     * @param text 待插入的字符串
+     */
+    insertData(offset: number, text: string): void;
+    /**
+     * 提取子串
+     * @param offset 起始位置
+     * @param count 字符数
+     */
+    substringData(offset: number, count: number): string;
+    /**
+     * 将文本子节点分裂为两部分
+     * @param offset 分裂位置
+     * @throws `RangeError` 错误的断开位置
+     * @throws `Error` 没有父节点
+     */
+    splitText(offset: number): AstText;
+    /** 转义 `=` */
+    escape(): void;
+}