wikiparser-node 1.0.3 → 1.1.0

package/dist/lib/range.js

@@ -19,7 +19,6 @@ class AstRange {
      * @param start 是否未初始化起点
      * @throws `Error` 未初始化
      */
-    // eslint-disable-next-line class-methods-use-this
     #notInit(start) {
         throw new Error(`请先指定${start ? '起始' : '终止'}位置！`);
     }
@@ -57,72 +56,111 @@ class AstRange {
     }
     /** 起始和终止位置是否重合 */
     get collapsed() {
-        return this.startIndex === this.endIndex;
+        return this.startContainer === this.endContainer && this.startOffset === this.endOffset;
     }
     /** 最近的公共祖先 */
     get commonAncestorContainer() {
         const { startContainer, endContainer } = this;
-        let parentNode = startContainer;
-        while (!parentNode.contains(endContainer)) {
-            ({ parentNode } = parentNode);
+        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('起点不能位于终点之后！');
         }
-        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) {
+        const { length } = startNode;
+        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;
+        if (this.#endContainer) {
+            try {
+                this.#check();
+            }
+            catch (e) {
+                this.#startContainer = undefined;
+                this.#startOffset = undefined;
+                throw e;
+            }
+        }
     }
     /**
      * 设置终点
      * @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) {
+        const { length } = endNode;
+        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;
+        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) {
-            this[method](parentNode, parentNode.childNodes.indexOf(referenceNode) + 1);
-        }
-        else {
-            this[method](referenceNode, referenceNode.length);
+        if (!parentNode) {
+            throw new RangeError('参考节点没有父节点！');
         }
+        this[method](parentNode, parentNode.childNodes.indexOf(referenceNode) + 1);
     }
     /**
      * 在节点后设置起点
@@ -142,15 +180,14 @@ class AstRange {
      * 在节点前设置
      * @param method 方法名
      * @param referenceNode 节点
+     * @throws `RangeError` 参考节点没有父节点
      */
     #setBefore(method, referenceNode) {
         const { parentNode } = referenceNode;
-        if (parentNode) {
-            this[method](parentNode, parentNode.childNodes.indexOf(referenceNode));
-        }
-        else {
-            this[method](referenceNode, 0);
+        if (!parentNode) {
+            throw new RangeError('参考节点没有父节点！');
         }
+        this[method](parentNode, parentNode.childNodes.indexOf(referenceNode));
     }
     /**
      * 在节点前设置起点
@@ -179,19 +216,18 @@ class AstRange {
     /**
      * 设置Range包含整个节点
      * @param referenceNode 节点
+     * @throws `RangeError` 参考节点没有父节点
      */
     selectNode(referenceNode) {
         const { parentNode } = referenceNode;
-        if (parentNode) {
-            const i = parentNode.childNodes.indexOf(referenceNode);
-            this.#startContainer = parentNode;
-            this.#startOffset = i;
-            this.#endContainer = parentNode;
-            this.#endOffset = i + 1;
-        }
-        else {
-            this.selectNodeContents(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;
     }
     /**
      * 使起始和终止位置重合
@@ -214,38 +250,24 @@ class AstRange {
      * @throws `RangeError` 不在同一个文档
      */
     comparePoint(referenceNode, offset) {
-        const { startContainer, startIndex, endIndex } = this;
+        const { startContainer, startIndex, endContainer, endIndex } = this;
         if (startContainer.getRootNode() !== referenceNode.getRootNode()) {
             throw new RangeError('待比较的端点不在同一个文档中！');
         }
         const index = getIndex(referenceNode, offset);
-        if (index < startIndex) {
+        if (index < startIndex || index === startIndex && !startContainer.contains(referenceNode)) {
             return -1;
         }
-        return index > endIndex ? 1 : 0;
+        return index < endIndex || index === endIndex && endContainer.contains(referenceNode) ? 0 : 1;
     }
     /**
      * 端点是否在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;
-    }
     /** 复制AstRange对象 */
     cloneRange() {
         const range = new AstRange();
@@ -255,38 +277,26 @@ class AstRange {
     }
     /** 删除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;
+        const { startContainer, endContainer, commonAncestorContainer } = this, { childNodes } = commonAncestorContainer;
+        let { startOffset, endOffset } = this;
+        if (commonAncestorContainer.type === 'text') {
+            commonAncestorContainer.deleteData(startOffset, endOffset);
+            return;
         }
-        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;
+        else if (startContainer.type === 'text') {
+            startContainer.deleteData(startOffset, Infinity);
+            startOffset = childNodes.indexOf(startContainer) + 1;
         }
         if (endContainer.type === 'text') {
-            endContainer.deleteData(startOffset, endOffset);
+            endContainer.deleteData(0, endOffset);
+            endOffset = childNodes.indexOf(endContainer);
         }
-        else {
-            for (let i = endOffset - 1; i >= startOffset; i--) {
-                endContainer.removeAt(i);
-            }
+        for (let i = endOffset - 1; i >= startOffset; i--) {
+            commonAncestorContainer.removeAt(i);
         }
-        this.#endContainer = endContainer;
+        this.#startContainer = commonAncestorContainer;
+        this.#startOffset = startOffset;
+        this.#endContainer = commonAncestorContainer;
         this.#endOffset = startOffset;
     }
     /** 获取行列位置和大小 */
@@ -299,50 +309,73 @@ class AstRange {
      * @param newNode 插入的节点
      */
     insertNode(newNode) {
-        const { startContainer, startOffset } = this;
+        const { startContainer, startOffset } = this, endContainer = this.#endContainer;
         if (startContainer.type === 'text') {
-            startContainer.splitText(startOffset);
-            startContainer.after(newNode);
+            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() {
-        return String(this.startContainer.getRootNode()).slice(this.startIndex, this.endIndex);
+        const { startContainer, startIndex, endIndex } = this;
+        return String(startContainer.getRootNode()).slice(startIndex, endIndex);
     }
-    /**
-     * 在满足条件时获取范围内的全部节点
-     * @throws `Error` 不是某个节点的连续子节点
-     */
+    /** 获取范围内的全部节点 */
     extractContents() {
-        if (this.collapsed) {
-            return [];
-        }
-        const { startContainer, endContainer, commonAncestorContainer } = this;
-        let { startOffset, endOffset } = this;
+        const { startContainer, startOffset, endContainer, endOffset, commonAncestorContainer } = this, { childNodes } = commonAncestorContainer;
         if (commonAncestorContainer.type === 'text') {
+            if (startOffset === endOffset) {
+                return [];
+            }
             commonAncestorContainer.splitText(endOffset);
             commonAncestorContainer.splitText(startOffset);
-            return [commonAncestorContainer.nextSibling];
+            const { nextSibling } = commonAncestorContainer;
+            this.#startContainer = nextSibling;
+            this.#startOffset = 0;
+            this.#endContainer = nextSibling;
+            this.#endOffset -= startOffset;
+            return [nextSibling];
         }
-        else if (startContainer !== commonAncestorContainer
-            && (startContainer.type !== 'text' || startContainer.parentNode !== commonAncestorContainer)
-            || endContainer !== commonAncestorContainer
-                && (endContainer.type !== 'text' || endContainer.parentNode !== commonAncestorContainer)) {
-            throw new Error('extractContents 方法只能用于获取某个节点的连续子节点！');
-        }
-        if (endContainer.type === 'text' && endContainer.parentNode === commonAncestorContainer) {
-            endContainer.splitText(endOffset);
-            endOffset = commonAncestorContainer.childNodes.indexOf(endContainer);
+        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' && startContainer.parentNode === commonAncestorContainer) {
-            startContainer.splitText(startOffset);
-            startOffset = commonAncestorContainer.childNodes.indexOf(startContainer) + 1;
-            endOffset++;
+        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(startOffset, endOffset);
+        return commonAncestorContainer.childNodes.slice(this.#startOffset, this.#endOffset);
     }
     /** 在满足条件时拷贝范围内的全部节点 */
     cloneContents() {

package/dist/lib/ranges.d.ts

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

package/dist/lib/ranges.js

@@ -4,6 +4,9 @@ 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` 起点、终点和步长均应为整数
@@ -11,10 +14,6 @@ class Range {
      * @throws `RangeError` 应使用CSS选择器或Python切片的格式
      */
     constructor(str) {
-        if (str instanceof Range) {
-            Object.assign(this, str);
-            return;
-        }
         str = str.trim();
         if (str === 'odd') {
             Object.assign(this, { start: 1, end: Infinity, step: 2 });
@@ -24,17 +23,17 @@ class Range {
         }
         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} 应为整数！`);
+            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 (this.#end !== Infinity && !Number.isInteger(this.#end)) {
+                throw new RangeError(`终点 ${this.#end} 应为整数！`);
             }
-            else if (!Number.isInteger(this.step)) {
-                throw new RangeError(`步长 ${this.step} 应为整数！`);
+            else if (!Number.isInteger(this.#step)) {
+                throw new RangeError(`步长 ${this.#step} 应为整数！`);
             }
         }
         else {
@@ -42,21 +41,21 @@ class Range {
                 .exec(str);
             if (mt) {
                 const [, sgnA = '+', a = 1, sgnB = '+'] = mt, b = Number(mt[4] ?? 0);
-                this.step = Number(a);
-                if (this.step === 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;
+                    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;
+                    this.#start = 0;
+                    this.#end = b > 0 ? 0 : this.#step;
                 }
                 else {
-                    this.start = b % this.step;
-                    this.end = this.step + b;
+                    this.#start = b % this.#step;
+                    this.#end = this.#step + b;
                 }
             }
             else {
@@ -66,12 +65,10 @@ class Range {
     }
     /**
      * 将Range转换为针对特定数组的下标集
-     * @param arr 参考数组
+     * @param arr 参考数组`[0, 1, 2, ...]`
      */
     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);
+        return arr.slice(this.#start, this.#end).filter((_, j) => j % this.#step === 0);
     }
 }
 exports.Range = Range;
@@ -85,7 +82,7 @@ class Ranges extends Array {
         }
         for (const ele of Array.isArray(a) ? a : [a]) {
             if (ele instanceof Range) {
-                this.push(new Range(ele));
+                this.push(ele);
                 continue;
             }
             const number = Number(ele);
@@ -105,13 +102,13 @@ class Ranges extends Array {
      * @param arr 参考数组
      */
     applyTo(arr) {
-        const length = typeof arr === 'number' ? arr : arr.length;
+        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(length);
+                return ele.applyTo(a);
             })),
         ].filter(i => i >= 0 && i < length).sort();
     }

package/dist/lib/text.js

@@ -96,8 +96,9 @@ class AstText extends node_1.AstNode {
             return errors
                 .map(({ 0: error, 1: prefix, 2: tag, index }) => {
                 if (prefix) {
-                    index += prefix.length;
-                    error = error.slice(prefix.length);
+                    const { length } = prefix;
+                    index += length;
+                    error = error.slice(length);
                 }
                 const startIndex = start + index, lines = data.slice(0, index).split('\n'), startLine = lines.length + top - 1, line = lines.at(-1), startCol = lines.length === 1 ? left + line.length : line.length, { 0: char, length } = error, endIndex = startIndex + length, end = char === '}' || char === ']' ? endIndex + 1 : startIndex + 49, rootStr = String(root), nextChar = rootStr[endIndex], previousChar = rootStr[startIndex - 1], severity = length > 1 && (char !== '<' || /[\s/>]/u.test(nextChar ?? ''))
                     || char === '{' && (nextChar === char || previousChar === '-')

package/dist/lib/title.d.ts

@@ -5,7 +5,6 @@ export declare class Title {
     valid: boolean;
     ns: number;
     fragment: string | undefined;
-    encoded: boolean;
     interwiki: string;
     /** 不含命名空间的标题主体部分 */
     get main(): string;
@@ -14,6 +13,9 @@ export declare class Title {
     get prefix(): string;
     /** 完整标题 */
     get title(): string;
+    /** 扩展名 */
+    get extension(): string | undefined;
+    set extension(extension: string | undefined);
     /**
      * @param title 标题（含或不含命名空间前缀）
      * @param defaultNs 命名空间
@@ -23,4 +25,14 @@ export declare class Title {
     constructor(title: string, defaultNs?: number, config?: Parser.Config, decode?: boolean, selfLink?: boolean);
     /** 执行单向转换 */
     autoConvert(): void;
+    /** 转换为主页面 */
+    toSubjectPage(): void;
+    /** 转换为讨论页面 */
+    toTalkPage(): void;
+    /** 是否是讨论页 */
+    isTalkPage(): boolean;
+    /** 转换为上一级页面 */
+    toBasePage(): void;
+    /** 转换为根页面 */
+    toRootPage(): void;
 }