wikiparser-node 1.6.2 → 1.7.0-b

package/dist/lib/range.js

@@ -1,385 +0,0 @@
-"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) {
-        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

@@ -1,28 +0,0 @@
-/** 模拟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

@@ -1,126 +0,0 @@
-"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/text.d.ts

@@ -1,63 +0,0 @@
-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
-     * @param errorRegex 正则表达式
-     * @throws `Error` 孤立文本节点
-     */
-    lint(start?: number, errorRegex?: RegExp): 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;
-}