wikiparser-node 1.9.2 → 1.9.3

package/dist/base.d.ts

@@ -53,8 +53,14 @@ export interface AstNode {
     /** 以HTML格式打印 */
     print(): string;
 }
-/** 类似HTMLElement */
-interface AstElement extends AstNode {
+/** 所有节点的基类 */
+interface Token extends AstNode {
+    readonly name?: string;
+    /**
+     * 符合选择器的所有后代节点
+     * @param selector 选择器
+     */
+    querySelectorAll<T = Token>(selector: string): T[];
     /** 保存为JSON */
     json(): AST;
 }
@@ -68,6 +74,6 @@ export interface Parser {
      * @param include 是否嵌入
      * @param maxStage 最大解析层级
      */
-    parse(wikitext: string, include?: boolean, maxStage?: number, config?: Config): AstElement;
+    parse(wikitext: string, include?: boolean, maxStage?: number, config?: Config): Token;
 }
 export {};

package/dist/index.js

@@ -159,7 +159,6 @@ const Parser = {
             ...Object.entries(constants_1.classes),
             ...Object.entries(constants_1.mixins),
             ...Object.entries(constants_1.parsers),
-            ...Object.entries(constants_1.constants),
         ];
         for (const [, filePath] of entries) {
             try {

package/dist/lib/element.d.ts

@@ -8,6 +8,7 @@ export declare abstract class AstElement extends AstNode {
     readonly data: undefined;
     /** 子节点总数 */
     get length(): number;
+    set length(n: number);
     /** 全部非文本子节点 */
     get children(): Token[];
     /** 首位非文本子节点 */

package/dist/lib/element.js

@@ -6,34 +6,21 @@ const path = require("path");
 const string_1 = require("../util/string");
 const debug_1 = require("../util/debug");
 const constants_1 = require("../util/constants");
-const ranges_1 = require("./ranges");
-const title_1 = require("./title");
 const node_1 = require("./node");
-/* NOT FOR BROWSER */
 /**
- * optionally convert to lower cases
- * @param val 属性值
- * @param i 是否对大小写不敏感
+ * 将选择器转化为类型谓词
+ * @param selector 选择器
  */
-const toCase = (val, i) => i ? val.toLowerCase() : val;
-/**
- * 检查某个下标是否符合表达式
- * @param str 表达式
- * @param i 待检查的下标
- */
-const nth = (str, i) => new ranges_1.Ranges(str).applyTo(i + 1).includes(i);
-/**
- * 检测:lang()伪选择器
- * @param node 节点
- * @param node.attributes 节点属性
- * @param regex 语言正则
- */
-const matchesLang = ({ attributes }, regex) => {
-    const lang = attributes?.['lang'];
-    return lang === undefined ? undefined : typeof lang === 'string' && regex.test(lang);
+const getCondition = (selector) => {
+    /* NOT FOR BROWSER */
+    if (/[^a-z\-,\s]/u.test(selector)) {
+        const { checkToken } = require('../parser/selector');
+        return checkToken(selector);
+    }
+    /* NOT FOR BROWSER END */
+    const types = new Set(selector.split(',').map(str => str.trim()));
+    return (({ type }) => types.has(type));
 };
-const primitives = new Set(['string', 'number', 'boolean', 'undefined']);
-/* NOT FOR BROWSER END */
 /** 类似HTMLElement */
 class AstElement extends node_1.AstNode {
     /** 子节点总数 */
@@ -41,6 +28,13 @@ class AstElement extends node_1.AstNode {
         return this.childNodes.length;
     }
     /* NOT FOR BROWSER */
+    set length(n) {
+        if (n >= 0 && n < this.length) {
+            for (let i = this.length - 1; i >= n; i--) {
+                this.removeAt(i);
+            }
+        }
+    }
     /** 全部非文本子节点 */
     get children() {
         return this.childNodes.filter((child) => child.type !== 'text');
@@ -153,27 +147,12 @@ class AstElement extends node_1.AstNode {
         (0, debug_1.setChildNodes)(this, i, 0, [node]);
         return node;
     }
-    /**
-     * 将选择器转化为类型谓词
-     * @param selector 选择器
-     */
-    #getCondition(selector) {
-        /* NOT FOR BROWSER */
-        if (/[^a-z\-,\s]/u.test(selector)) {
-            const { parseSelector } = require('../parser/selector');
-            const stack = parseSelector(selector);
-            return (token => stack.some(copy => token.#matchesArray(copy)));
-        }
-        /* NOT FOR BROWSER END */
-        const types = new Set(selector.split(',').map(str => str.trim()));
-        return (({ type }) => types.has(type));
-    }
     /**
      * 最近的祖先节点
      * @param selector 选择器
      */
     closest(selector) {
-        const condition = this.#getCondition(selector);
+        const condition = getCondition(selector);
         let { parentNode } = this;
         while (parentNode) {
             if (condition(parentNode)) {
@@ -207,7 +186,7 @@ class AstElement extends node_1.AstNode {
      * @param selector 选择器
      */
     querySelector(selector) {
-        const condition = this.#getCondition(selector);
+        const condition = getCondition(selector);
         return this.#getElementBy(condition);
     }
     /**
@@ -232,7 +211,7 @@ class AstElement extends node_1.AstNode {
      * @param selector 选择器
      */
     querySelectorAll(selector) {
-        const condition = this.#getCondition(selector);
+        const condition = getCondition(selector);
         return this.#getElementsBy(condition);
     }
     /**
@@ -302,6 +281,7 @@ class AstElement extends node_1.AstNode {
     json(file, start = this.getAbsoluteIndex()) {
         const json = {
             ...this,
+            type: this.type,
             range: [start, start + this.toString().length],
             childNodes: [],
         };
@@ -320,218 +300,12 @@ class AstElement extends node_1.AstNode {
         return json;
     }
     /* NOT FOR BROWSER */
-    /** 是否受保护。保护条件来自Token，这里仅提前用于:required和:optional伪选择器。 */
-    #isProtected() {
-        const { parentNode } = this;
-        if (!parentNode) {
-            return undefined;
-        }
-        const { childNodes, fixed } = parentNode;
-        return fixed
-            || parentNode.getAttribute('protectedChildren').applyTo(childNodes)
-                .includes(childNodes.indexOf(this));
-    }
-    /**
-     * 获取属性
-     * @param key 属性键
-     */
-    #getAttr(key) {
-        if (typeof this.getAttr === 'function') {
-            const attr = this.getAttr(key);
-            if (attr !== undefined) {
-                return attr;
-            }
-        }
-        const val = this.getAttribute(key);
-        return val instanceof RegExp ? val.source : val;
-    }
-    /**
-     * 检查是否符合属性选择器
-     * @param key 属性键
-     * @param equal 比较符
-     * @param val 属性值
-     * @param i 是否对大小写不敏感
-     * @throws `RangeError` 复杂属性不能用于选择器
-     */
-    #matchesAttr(key, equal, val = '', i) {
-        const isAttr = typeof this.hasAttr === 'function' && typeof this.getAttr === 'function';
-        if (!(key in this) && (!isAttr || !this.hasAttr(key))) {
-            return equal === '!=';
-        }
-        const v = toCase(val, i), thisVal = this.#getAttr(key);
-        if (!equal) {
-            return thisVal !== undefined && thisVal !== false;
-        }
-        if (equal === '~=') {
-            const thisVals = typeof thisVal === 'string' ? thisVal.split(/\s/u) : thisVal;
-            return Boolean(thisVals?.[Symbol.iterator])
-                && [...thisVals].some(w => typeof w === 'string' && toCase(w, i) === v);
-        }
-        else if (!primitives.has(typeof thisVal) && !(thisVal instanceof title_1.Title)) {
-            throw new RangeError(`The complex attribute ${key} cannot be used in a selector!`);
-        }
-        const stringVal = toCase(String(thisVal), i);
-        switch (equal) {
-            case '|=':
-                return stringVal === v || stringVal.startsWith(`${v}-`);
-            case '^=':
-                return stringVal.startsWith(v);
-            case '$=':
-                return stringVal.endsWith(v);
-            case '*=':
-                return stringVal.includes(v);
-            case '!=':
-                return stringVal !== v;
-            default: // `=`
-                return stringVal === v;
-        }
-    }
-    /**
-     * 检查是否符合解析后的选择器，不含节点关系
-     * @param step 解析后的选择器
-     * @throws `SyntaxError` 错误的正则伪选择器
-     * @throws `SyntaxError` 未定义的伪选择器
-     */
-    #matches(step) {
-        const { parentNode, type, name, childNodes, link } = this, children = parentNode?.children, childrenOfType = children?.filter(({ type: t }) => t === type), siblingsCount = children?.length ?? 1, siblingsCountOfType = childrenOfType?.length ?? 1, index = (children?.indexOf(this) ?? 0) + 1, indexOfType = (childrenOfType?.indexOf(this) ?? 0) + 1, lastIndex = siblingsCount - index + 1, lastIndexOfType = siblingsCountOfType - indexOfType + 1;
-        return step.every(selector => {
-            if (typeof selector === 'string') {
-                switch (selector) { // 情形1：简单伪选择器、type和name
-                    case '*':
-                        return true;
-                    case ':root':
-                        return !parentNode;
-                    case ':first-child':
-                        return index === 1;
-                    case ':first-of-type':
-                        return indexOfType === 1;
-                    case ':last-child':
-                        return lastIndex === 1;
-                    case ':last-of-type':
-                        return lastIndexOfType === 1;
-                    case ':only-child':
-                        return siblingsCount === 1;
-                    case ':only-of-type':
-                        return siblingsCountOfType === 1;
-                    case ':empty':
-                        return !childNodes.some(({ type: t, data }) => t !== 'text' || data);
-                    case ':parent':
-                        return childNodes.some(({ type: t, data }) => t !== 'text' || data);
-                    case ':header':
-                        return type === 'heading';
-                    case ':hidden':
-                        return this.text() === '';
-                    case ':visible':
-                        return this.text() !== '';
-                    case ':only-whitespace':
-                        return this.text().trim() === '';
-                    case ':any-link':
-                        return type === 'link'
-                            || type === 'free-ext-link'
-                            || type === 'magic-link'
-                            || type === 'ext-link'
-                            || (type === 'file' || type === 'gallery-image') && link;
-                    case ':local-link':
-                        return (type === 'link' || type === 'file' || type === 'gallery-image')
-                            && link instanceof title_1.Title
-                            && link.title === '';
-                    case ':invalid':
-                        return type === 'table-inter' || type === 'image-parameter' && name === 'invalid';
-                    case ':required':
-                        return this.#isProtected() === true;
-                    case ':optional':
-                        return this.#isProtected() === false;
-                    default: {
-                        const [t, n] = selector.split('#');
-                        return (!t || t === type) && (!n || n === name);
-                    }
-                }
-            }
-            else if (selector.length === 4) { // 情形2：属性选择器
-                return this.#matchesAttr(...selector);
-            }
-            const [s, pseudo] = selector; // 情形3：复杂伪选择器
-            switch (pseudo) {
-                case 'is':
-                    return this.matches(s);
-                case 'not':
-                    return !this.matches(s);
-                case 'nth-child':
-                    return nth(s, index);
-                case 'nth-of-type':
-                    return nth(s, indexOfType);
-                case 'nth-last-child':
-                    return nth(s, lastIndex);
-                case 'nth-last-of-type':
-                    return nth(s, lastIndexOfType);
-                case 'contains':
-                    return this.text().includes(s);
-                case 'has':
-                    return Boolean(this.querySelector(s));
-                case 'lang': {
-                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-                    /^zh(?:-|$)/iu;
-                    const regex = new RegExp(`^${s}(?:-|$)`, 'iu');
-                    for (let node = this; node; node = node.parentNode) {
-                        const result = matchesLang(node, regex);
-                        if (result !== undefined) {
-                            return result;
-                        }
-                    }
-                    return false;
-                }
-                case 'regex': {
-                    const mt = /^([^,]+),\s*\/(.+)\/([a-z]*)$/u.exec(s);
-                    if (!mt) {
-                        throw new SyntaxError(`Wrong usage of the regex pseudo-selector. Use ":regex('attr, /re/i')" format.`);
-                    }
-                    try {
-                        return new RegExp(mt[2], mt[3]).test(String(this.#getAttr(mt[1].trim())));
-                    }
-                    catch {
-                        throw new SyntaxError(`Invalid regular expression: /${mt[2]}/${mt[3]}`);
-                    }
-                }
-                default:
-                    throw new SyntaxError(`Undefined pseudo-selector: ${pseudo}`);
-            }
-        });
-    }
-    /**
-     * 检查是否符合解析后的选择器
-     * @param copy 解析后的选择器
-     */
-    #matchesArray(copy) {
-        const condition = [...copy], step = condition.pop();
-        if (this.#matches(step)) {
-            const { parentNode, previousElementSibling } = this;
-            switch (condition[condition.length - 1]?.relation) {
-                case undefined:
-                    return true;
-                case '>':
-                    return Boolean(parentNode && parentNode.#matchesArray(condition));
-                case '+':
-                    return Boolean(previousElementSibling && previousElementSibling.#matchesArray(condition));
-                case '~': {
-                    if (!parentNode) {
-                        return false;
-                    }
-                    const { children } = parentNode;
-                    return children.slice(0, children.indexOf(this))
-                        .some(child => child.#matchesArray(condition));
-                }
-                default: // ' '
-                    return this.getAncestors().some(ancestor => ancestor.#matchesArray(condition));
-            }
-        }
-        return false;
-    }
     /**
      * 检查是否符合选择器
      * @param selector 选择器
      */
     matches(selector) {
-        return selector === undefined || this.#getCondition(selector)(this);
+        return selector === undefined || getCondition(selector)(this);
     }
     /**
      * 类型选择器

package/dist/lib/node.d.ts

@@ -16,9 +16,11 @@ export interface CaretPosition {
 /** 类似Node */
 export declare abstract class AstNode implements AstNodeBase {
     #private;
-    type: TokenTypes | 'text';
     data?: string | undefined;
     readonly childNodes: readonly AstNodes[];
+    /** 节点类型 */
+    abstract get type(): TokenTypes | 'text';
+    abstract set type(value: TokenTypes | 'text');
     text(): string;
     lint(): LintError[];
     print(): string;

package/dist/lib/range.js

@@ -20,6 +20,14 @@ const getParent = (node) => {
     }
     throw new RangeError('The reference node has no parent node!');
 };
+/**
+ * 未初始化时抛出错误
+ * @param start 是否未初始化起点
+ * @throws `Error` 未初始化
+ */
+const notInit = (start) => {
+    throw new Error(`Please set the ${start ? 'start' : 'end'} position first!`);
+};
 /** 模拟Range对象 */
 class AstRange {
     #startContainer;
@@ -28,11 +36,11 @@ class AstRange {
     #endOffset;
     /** 起点容器 */
     get startContainer() {
-        return this.#startContainer ?? this.#notInit(true);
+        return this.#startContainer ?? notInit(true);
     }
     /** 起点位置 */
     get startOffset() {
-        return this.#startOffset ?? this.#notInit(true);
+        return this.#startOffset ?? notInit(true);
     }
     /** 起点绝对位置 */
     get startIndex() {
@@ -44,11 +52,11 @@ class AstRange {
     }
     /** 终点容器 */
     get endContainer() {
-        return this.#endContainer ?? this.#notInit(false);
+        return this.#endContainer ?? notInit(false);
     }
     /** 终点位置 */
     get endOffset() {
-        return this.#endOffset ?? this.#notInit(false);
+        return this.#endOffset ?? notInit(false);
     }
     /** 终点绝对位置 */
     get endIndex() {
@@ -67,14 +75,6 @@ class AstRange {
         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` 起点和终点不是兄弟节点

package/dist/lib/text.d.ts

@@ -3,11 +3,12 @@ import type { LintError } from '../base';
 /** 文本节点 */
 export declare class AstText extends AstNode {
     #private;
-    readonly type = "text";
     readonly name: undefined;
     readonly data: string;
+    get type(): 'text';
     /** 文本长度 */
     get length(): number;
+    set length(n: number);
     /** @param text 包含文本 */
     constructor(text: string);
     /** 可见部分 */

package/dist/lib/text.js

@@ -76,20 +76,26 @@ const source = String.raw `<\s*(?:/\s*)?([a-z]\w*)|\{+|\}+|\[{2,}|\[(?![^[]*?\])
 ];
 /** 文本节点 */
 class AstText extends node_1.AstNode {
-    type = 'text';
     data = '';
+    get type() {
+        return 'text';
+    }
     /* NOT FOR BROWSER */
     /** 文本长度 */
     get length() {
         return this.data.length;
     }
+    set length(n) {
+        if (n >= 0 && n < this.length) {
+            this.replaceData(this.data.slice(0, n));
+        }
+    }
     /* NOT FOR BROWSER END */
     /** @param text 包含文本 */
     constructor(text) {
         super();
         Object.defineProperties(this, {
             childNodes: { enumerable: false, configurable: false },
-            type: { enumerable: false, writable: false },
             data: {
                 value: text,
                 /* NOT FOR BROWSER */

package/dist/mixin/hidden.js

@@ -21,6 +21,11 @@ const hiddenToken = (linter) => (constructor, _) => {
             // @ts-expect-error private argument
             return linter ? [] : super.lint(start);
         }
+        /* NOT FOR BROWSER */
+        /** @private */
+        dispatchEvent() {
+            //
+        }
     }
     (0, debug_1.mixin)(AnyHiddenToken, constructor);
     return AnyHiddenToken;

package/dist/mixin/syntax.js

@@ -23,8 +23,9 @@ const syntax = (pattern) => (constructor, _) => {
         }
         /** @private */
         afterBuild() {
+            super.afterBuild();
             const /** @implements */ syntaxListener = (e, data) => {
-                if (!debug_1.Shadow.running && !this.pattern.test(this.text())) {
+                if (!debug_1.Shadow.running && !this.pattern.test((0, string_1.text)(this.childNodes))) {
                     (0, debug_1.undo)(e, data);
                     this.constructorError('cannot modify the syntax pattern');
                 }