wikiparser-node 1.9.2 → 1.9.3

package/dist/parser/selector.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSelector = void 0;
+exports.checkToken = void 0;
 const constants_1 = require("../util/constants");
 const string_1 = require("../util/string");
+const ranges_1 = require("../lib/ranges");
+const title_1 = require("../lib/title");
 const simplePseudos = new Set([
     'root',
     'first-child',
@@ -22,8 +24,7 @@ const simplePseudos = new Set([
     'invalid',
     'required',
     'optional',
-]);
-const complexPseudos = new Set([
+]), complexPseudos = new Set([
     'is',
     'not',
     'nth-child',
@@ -34,8 +35,7 @@ const complexPseudos = new Set([
     'has',
     'lang',
     'regex',
-]);
-const specialChars = [
+]), specialChars = [
     ['[', '['],
     [']', ']'],
     ['(', '('],
@@ -45,17 +45,218 @@ const specialChars = [
     [':', ':'],
     ['\\', '\'],
     ['&', '&'],
-];
-const regularRegex = /[[(,>+~]|\s+/u, attributeRegex = /^\s*(\w+)\s*(?:([~|^$*!]?=)\s*("[^"]*"|'[^']*'|[^\s[\]]+)(?:\s+(i))?\s*)?\]/u, functionRegex = /^(\s*"[^"]*"\s*|\s*'[^']*'\s*|[^()]*)\)/u, grouping = new Set([',', '>', '+', '~']), combinator = new Set(['>', '+', '~', '']), sanitizeRegex = specialChars.map(([c, escaped]) => [new RegExp((0, string_1.escapeRegExp)(`\\${c}`), 'gu'), escaped]), desanitizeRegex = specialChars.map(([c, escaped]) => [c, new RegExp(escaped, 'gu')]);
+], regularRegex = /[[(,>+~]|\s+/u, attributeRegex = /^\s*(\w+)\s*(?:([~|^$*!]?=)\s*("[^"]*"|'[^']*'|[^\s[\]]+)(?:\s+(i))?\s*)?\]/u, functionRegex = /^(\s*"[^"]*"\s*|\s*'[^']*'\s*|[^()]*)\)/u, grouping = new Set([',', '>', '+', '~']), combinator = new Set(['>', '+', '~', '']), sanitizeRegex = specialChars.map(([c, escaped]) => [new RegExp((0, string_1.escapeRegExp)(`\\${c}`), 'gu'), escaped]), desanitizeRegex = specialChars.map(([c, escaped]) => [c, new RegExp(escaped, 'gu')]), primitives = new Set(['string', 'number', 'boolean', 'undefined']);
 /**
- * 清理转义符号
- * @param selector
+ * optionally convert to lower cases
+ * @param val 属性值
+ * @param i 是否对大小写不敏感
  */
-const sanitize = (selector) => {
-    for (const [re, escaped] of sanitizeRegex) {
-        selector = selector.replace(re, escaped);
+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);
+/**
+ * 是否受保护。保护条件来自Token，这里仅提前用于:required和:optional伪选择器。
+ * @param token 节点
+ */
+const isProtected = (token) => {
+    const { parentNode } = token;
+    if (!parentNode) {
+        return undefined;
+    }
+    const { childNodes, fixed } = parentNode;
+    return fixed
+        || parentNode.getAttribute('protectedChildren').applyTo(childNodes).includes(childNodes.indexOf(token));
+};
+/**
+ * 获取属性
+ * @param token 节点
+ * @param key 属性键
+ */
+const getAttr = (token, key) => {
+    if (typeof token.getAttr === 'function') {
+        const attr = token.getAttr(key);
+        if (attr !== undefined) {
+            return attr;
+        }
     }
-    return selector;
+    const val = token[key];
+    return val instanceof RegExp ? val.source : val;
+};
+/**
+ * 检查是否符合解析后的选择器，不含节点关系
+ * @param token 节点
+ * @param step 解析后的选择器
+ * @throws `SyntaxError` 错误的正则伪选择器
+ * @throws `SyntaxError` 未定义的伪选择器
+ */
+const matches = (token, step) => {
+    const { parentNode, type, name, childNodes, link } = token, children = parentNode?.children, childrenOfType = children?.filter(({ type: t }) => t === type), siblingsCount = children?.length ?? 1, siblingsCountOfType = childrenOfType?.length ?? 1, index = (children?.indexOf(token) ?? 0) + 1, indexOfType = (childrenOfType?.indexOf(token) ?? 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 token.text() === '';
+                case ':visible':
+                    return token.text() !== '';
+                case ':only-whitespace':
+                    return token.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 isProtected(token) === true;
+                case ':optional':
+                    return isProtected(token) === false;
+                default: {
+                    const [t, n] = selector.split('#');
+                    return (!t || t === type) && (!n || n === name);
+                }
+            }
+        }
+        else if (selector.length === 4) { // 情形2：属性选择器
+            const [key, equal, val = '', i] = selector, isAttr = typeof token.hasAttr === 'function' && typeof token.getAttr === 'function';
+            if (!(key in token) && (!isAttr || !token.hasAttr(key))) {
+                return equal === '!=';
+            }
+            const v = toCase(val, i), thisVal = getAttr(token, 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;
+            }
+        }
+        const [s, pseudo] = selector; // 情形3：复杂伪选择器
+        switch (pseudo) {
+            case 'is':
+                return token.matches(s);
+            case 'not':
+                return !token.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 token.text().includes(s);
+            case 'has':
+                return Boolean(token.querySelector(s));
+            case 'lang': {
+                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                /^zh(?:-|$)/iu;
+                const regex = new RegExp(`^${s}(?:-|$)`, 'iu');
+                let node = token;
+                for (; node; node = node.parentNode) {
+                    const lang = node.attributes?.['lang'];
+                    if (lang !== undefined) {
+                        return typeof lang === 'string' && regex.test(lang);
+                    }
+                }
+                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(getAttr(token, mt[1].trim())));
+                }
+                catch {
+                    throw new SyntaxError(`Invalid regular expression: /${mt[2]}/${mt[3]}`);
+                }
+            }
+            default:
+                throw new SyntaxError(`Undefined pseudo-selector: ${pseudo}`);
+        }
+    });
+};
+/**
+ * 检查是否符合解析后的选择器
+ * @param token 节点
+ * @param copy 解析后的选择器
+ */
+const matchesArray = (token, copy) => {
+    const condition = [...copy];
+    if (matches(token, condition.pop())) {
+        const { parentNode, previousElementSibling } = token;
+        switch (condition[condition.length - 1]?.relation) {
+            case undefined:
+                return true;
+            case '>':
+                return Boolean(parentNode && matchesArray(parentNode, condition));
+            case '+':
+                return Boolean(previousElementSibling && matchesArray(previousElementSibling, condition));
+            case '~': {
+                if (!parentNode) {
+                    return false;
+                }
+                const { children } = parentNode;
+                return children.slice(0, children.indexOf(token)).some(child => matchesArray(child, condition));
+            }
+            default: // ' '
+                return token.getAncestors().some(ancestor => matchesArray(ancestor, condition));
+        }
+    }
+    return false;
 };
 /**
  * 还原转义符号
@@ -73,14 +274,16 @@ const desanitize = (selector) => {
  */
 const deQuote = (val) => /^(["']).*\1$/u.test(val) ? val.slice(1, -1) : val.trim();
 /**
- * 解析选择器
+ * 检查节点是否符合选择器
  * @param selector
- * @throws `SyntaxError` 非法的选择器
  */
-const parseSelector = (selector) => {
-    selector = selector.trim();
+const checkToken = (selector) => (token) => {
+    let sanitized = selector.trim();
+    for (const [re, escaped] of sanitizeRegex) {
+        sanitized = sanitized.replace(re, escaped);
+    }
     const stack = [[[]]];
-    let sanitized = sanitize(selector), regex = regularRegex, mt = regex.exec(sanitized), [condition] = stack, [step] = condition;
+    let regex = regularRegex, mt = regex.exec(sanitized), [condition] = stack, [step] = condition;
     /**
      * 解析简单伪选择器
      * @param index 伪选择器的终点位置
@@ -182,9 +385,9 @@ const parseSelector = (selector) => {
     if (regex === regularRegex) {
         pushSimple();
         needUniversal();
-        return stack;
+        return stack.some(copy => matchesArray(token, copy));
     }
     throw new SyntaxError(`Unclosed '${regex === attributeRegex ? '[' : '('}' in the selector!\n${desanitize(sanitized)}`);
 };
-exports.parseSelector = parseSelector;
+exports.checkToken = checkToken;
 constants_1.parsers['parseSelector'] = __filename;

package/dist/parser/table.js

@@ -102,19 +102,19 @@ const parseTable = ({ firstChild: { data }, type, name }, config, accum) => {
              * 创建表格单元格
              * @param tr 当前表格行
              */
-            const createTd = (tr) => {
+            const newTd = (tr) => {
                 // @ts-expect-error abstract class
                 const td = new td_1.TdToken(lastSyntax, attr.slice(lastIndex, mt?.index), config, accum);
                 tr.insertAt(td);
                 return td;
             };
             while (mt) {
-                createTd(top);
+                newTd(top);
                 ({ lastIndex } = regex);
                 [lastSyntax] = mt;
                 mt = regex.exec(attr);
             }
-            stack.push(top, createTd(top));
+            stack.push(top, newTd(top));
         }
     }
     return out.slice(1);

package/dist/src/arg.d.ts

@@ -9,7 +9,6 @@ import type { LintError, AST } from '../base';
  */
 export declare abstract class ArgToken extends Token {
     #private;
-    readonly type = "arg";
     readonly name: string;
     readonly childNodes: readonly [AtomToken] | readonly [AtomToken, Token, ...HiddenToken[]];
     abstract get firstChild(): AtomToken;
@@ -17,6 +16,7 @@ export declare abstract class ArgToken extends Token {
     abstract get children(): [AtomToken] | [AtomToken, Token, ...HiddenToken[]];
     abstract get firstElementChild(): AtomToken;
     abstract get lastElementChild(): Token;
+    get type(): 'arg';
     /** 预设值 */
     get default(): string | false;
     set default(value: string | false);
@@ -24,7 +24,6 @@ export declare abstract class ArgToken extends Token {
     constructor(parts: readonly string[], config?: Parser.Config, accum?: Token[]);
     /** @override */
     json(): AST;
-    /** @override */
     cloneNode(): this;
     /** 移除无效部分 */
     removeRedundant(): void;

package/dist/src/arg.js

@@ -15,8 +15,10 @@ const hidden_1 = require("./hidden");
  * @classdesc `{childNodes: [AtomToken, ?Token, ...HiddenToken]}`
  */
 class ArgToken extends index_2.Token {
-    type = 'arg';
     /* NOT FOR BROWSER END */
+    get type() {
+        return 'arg';
+    }
     /** 预设值 */
     get default() {
         return this.childNodes[1]?.text() ?? false;
@@ -119,7 +121,6 @@ class ArgToken extends index_2.Token {
         return json;
     }
     /* NOT FOR BROWSER */
-    /** @override */
     cloneNode() {
         const [name, ...cloned] = this.cloneChildNodes();
         return debug_1.Shadow.run(() => {

package/dist/src/atom.d.ts

@@ -1,12 +1,14 @@
 import { Token } from './index';
 import type { Config } from '../base';
-declare type AtomTypes = 'arg-name' | 'attr-key' | 'attr-value' | 'ext-attr-dirty' | 'html-attr-dirty' | 'table-attr-dirty' | 'converter-flag' | 'converter-rule-variant' | 'converter-rule-to' | 'converter-rule-from' | 'invoke-function' | 'invoke-module' | 'template-name' | 'link-target' | 'param-line';
+declare const atomTypes: readonly ["arg-name", "attr-key", "attr-value", "ext-attr-dirty", "html-attr-dirty", "table-attr-dirty", "converter-flag", "converter-rule-variant", "converter-rule-to", "converter-rule-from", "invoke-function", "invoke-module", "template-name", "link-target", "param-line"];
+declare type AtomTypes = typeof atomTypes[number];
 /** 不会被继续解析的plain Token */
 export declare class AtomToken extends Token {
-    type: AtomTypes;
+    #private;
+    get type(): AtomTypes;
+    set type(value: AtomTypes);
     /** @class */
     constructor(wikitext: string | undefined, type: AtomTypes, config?: Config, accum?: Token[], acceptable?: Acceptable);
-    /** @override */
     cloneNode(): this;
 }
 export {};

package/dist/src/atom.js

@@ -4,15 +4,41 @@ exports.AtomToken = void 0;
 const debug_1 = require("../util/debug");
 const constants_1 = require("../util/constants");
 const index_1 = require("./index");
+const atomTypes = [
+    'arg-name',
+    'attr-key',
+    'attr-value',
+    'ext-attr-dirty',
+    'html-attr-dirty',
+    'table-attr-dirty',
+    'converter-flag',
+    'converter-rule-variant',
+    'converter-rule-to',
+    'converter-rule-from',
+    'invoke-function',
+    'invoke-module',
+    'template-name',
+    'link-target',
+    'param-line',
+];
 /** 不会被继续解析的plain Token */
 class AtomToken extends index_1.Token {
+    #type;
+    get type() {
+        return this.#type;
+    }
+    set type(value) {
+        if (!atomTypes.includes(value)) {
+            throw new RangeError(`"${value}" is not a valid type for AtomToken!`);
+        }
+        this.#type = value;
+    }
     /** @class */
     constructor(wikitext, type, config, accum, acceptable) {
         super(wikitext, config, accum, acceptable);
-        this.type = type;
+        this.#type = type;
     }
     /* NOT FOR BROWSER */
-    /** @override */
     cloneNode() {
         const cloned = this.cloneChildNodes(), config = this.getAttribute('config'), acceptable = this.getAcceptable();
         return debug_1.Shadow.run(() => {

package/dist/src/attribute.d.ts

@@ -10,7 +10,6 @@ export type AttributeTypes = 'ext-attr' | 'html-attr' | 'table-attr';
  */
 export declare abstract class AttributeToken extends Token {
     #private;
-    type: AttributeTypes;
     readonly name: string;
     readonly childNodes: readonly [AtomToken, Token];
     abstract get firstChild(): AtomToken;
@@ -24,6 +23,7 @@ export declare abstract class AttributeToken extends Token {
     abstract get parentElement(): AttributesToken | undefined;
     abstract get nextElementSibling(): AtomToken | this | undefined;
     abstract get previousElementSibling(): AtomToken | this | undefined;
+    get type(): AttributeTypes;
     /** 标签名 */
     get tag(): string;
     /** 引号是否匹配 */
@@ -43,7 +43,6 @@ export declare abstract class AttributeToken extends Token {
     constructor(type: AttributeTypes, tag: string, key: string, equal?: string, value?: string, quotes?: readonly [string?, string?], config?: Parser.Config, accum?: Token[]);
     /** 获取属性值 */
     getValue(): string | true;
-    /** @override */
     cloneNode(): this;
     /** 转义等号 */
     escape(): void;

package/dist/src/attribute.js

@@ -223,10 +223,14 @@ let AttributeToken = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
+        #type;
         #tag;
         #equal;
         #quotes;
         /* NOT FOR BROWSER END */
+        get type() {
+            return this.#type;
+        }
         /** 标签名 */
         get tag() {
             return this.#tag;
@@ -305,7 +309,7 @@ let AttributeToken = (() => {
                 });
             }
             super(undefined, config, accum);
-            this.type = type;
+            this.#type = type;
             this.append(keyToken, valueToken);
             this.#equal = equal;
             this.#quotes = [...quotes];
@@ -409,7 +413,6 @@ let AttributeToken = (() => {
             return this.#equal ? super.print({ sep: (0, string_1.escape)(this.#equal) + quoteStart, post: quoteEnd }) : super.print();
         }
         /* NOT FOR BROWSER */
-        /** @override */
         cloneNode() {
             const [key, value] = this.cloneChildNodes(), config = this.getAttribute('config');
             return debug_1.Shadow.run(() => {

package/dist/src/attributes.d.ts

@@ -12,7 +12,6 @@ declare type AttributesTypes = `${AttributeTypes}s`;
  */
 export declare abstract class AttributesToken extends Token {
     #private;
-    type: AttributesTypes;
     readonly name: string;
     readonly childNodes: readonly (AtomToken | AttributeToken)[];
     abstract get firstChild(): AtomToken | AttributeToken | undefined;
@@ -22,6 +21,7 @@ export declare abstract class AttributesToken extends Token {
     abstract get firstElementChild(): AtomToken | AttributeToken | undefined;
     abstract get lastElementChild(): AtomToken | AttributeToken | undefined;
     abstract get parentElement(): ExtToken | HtmlToken | TableToken | TrToken | TdToken | undefined;
+    get type(): AttributesTypes;
     /** getAttrs()方法的getter写法 */
     get attributes(): Record<string, string | true>;
     set attributes(attrs: Record<string, string | true>);
@@ -60,7 +60,6 @@ export declare abstract class AttributesToken extends Token {
     getAttr(key: string): string | true | undefined;
     /** 清理无效属性 */
     sanitize(): void;
-    /** @override */
     cloneNode(): this;
     /**
      * @override

package/dist/src/attributes.js

@@ -29,6 +29,12 @@ const toDirty = (type) => `${toAttributeType(type)}-dirty`;
  * @classdesc `{childNodes: ...AtomToken|AttributeToken}`
  */
 class AttributesToken extends index_2.Token {
+    #type;
+    /* NOT FOR BROWSER END */
+    get type() {
+        return this.#type;
+    }
+    /* NOT FOR BROWSER */
     /** getAttrs()方法的getter写法 */
     get attributes() {
         return this.getAttrs();
@@ -79,7 +85,7 @@ class AttributesToken extends index_2.Token {
         super(undefined, config, accum, {
             AtomToken: ':', AttributeToken: ':',
         });
-        this.type = type;
+        this.#type = type;
         this.setAttribute('name', name);
         if (attr) {
             regex.lastIndex = 0;
@@ -202,7 +208,6 @@ class AttributesToken extends index_2.Token {
             index_1.default.warn('AttributesToken.sanitize will remove invalid attributes!');
         }
     }
-    /** @override */
     cloneNode() {
         const cloned = this.cloneChildNodes();
         return debug_1.Shadow.run(() => {

package/dist/src/converter.d.ts

@@ -10,13 +10,13 @@ export interface ConverterToken extends FlagsParentBase {
  * @classdesc `{childNodes: [ConverterFlagsToken, ...ConverterRuleToken]}`
  */
 export declare abstract class ConverterToken extends Token {
-    readonly type = "converter";
     readonly childNodes: readonly [ConverterFlagsToken, ...ConverterRuleToken[]];
     abstract get firstChild(): ConverterFlagsToken;
     abstract get lastChild(): ConverterFlagsToken | ConverterRuleToken;
     abstract get children(): [ConverterFlagsToken, ...ConverterRuleToken[]];
     abstract get firstElementChild(): ConverterFlagsToken;
     abstract get lastElementChild(): ConverterFlagsToken | ConverterRuleToken;
+    get type(): 'converter';
     /** 是否不转换 */
     get noConvert(): boolean;
     /**
@@ -24,6 +24,5 @@ export declare abstract class ConverterToken extends Token {
      * @param rules 转换规则
      */
     constructor(flags: readonly string[], rules: readonly [string, ...string[]], config?: Parser.Config, accum?: Token[]);
-    /** @override */
     cloneNode(): this;
 }

package/dist/src/converter.js

@@ -62,7 +62,11 @@ let ConverterToken = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        type = 'converter';
+        /* NOT FOR BROWSER END */
+        get type() {
+            return 'converter';
+        }
+        /* NOT FOR BROWSER */
         /** 是否不转换 */
         get noConvert() {
             return this.hasFlag('R') || this.length === 2 && this.lastChild.length === 1;
@@ -115,7 +119,6 @@ let ConverterToken = (() => {
             return `<span class="wpb-converter">-{${flags.print()}${flags.length > 0 ? '|' : ''}${(0, string_1.print)(rules, { sep: ';' })}}-</span>`;
         }
         /* NOT FOR BROWSER */
-        /** @override */
         cloneNode() {
             const [flags, ...rules] = this.cloneChildNodes();
             return debug_1.Shadow.run(() => {

package/dist/src/converterFlags.d.ts

@@ -9,7 +9,6 @@ import type { ConverterToken, ConverterRuleToken } from '../internal';
  */
 export declare abstract class ConverterFlagsToken extends Token {
     #private;
-    readonly type = "converter-flags";
     readonly childNodes: readonly AtomToken[];
     abstract get firstChild(): AtomToken | undefined;
     abstract get lastChild(): AtomToken | undefined;
@@ -22,6 +21,7 @@ export declare abstract class ConverterFlagsToken extends Token {
     abstract get parentElement(): ConverterToken | undefined;
     abstract get previousElementSibling(): undefined;
     abstract get nextElementSibling(): ConverterRuleToken | undefined;
+    get type(): 'converter-flags';
     /** 所有转换类型标记 */
     get flags(): Set<string>;
     set flags(value: Set<string>);
@@ -31,7 +31,6 @@ export declare abstract class ConverterFlagsToken extends Token {
     getUnknownFlags(): Set<string>;
     /** 获取指定语言变体的转换标记 */
     getVariantFlags(): Set<string>;
-    /** @override */
     cloneNode(): this;
     /**
      * @override

package/dist/src/converterFlags.js

@@ -14,8 +14,12 @@ const definedFlags = new Set(['A', 'T', 'R', 'D', '-', 'H', 'N']);
  * @classdesc `{childNodes: ...AtomToken}`
  */
 class ConverterFlagsToken extends index_2.Token {
-    type = 'converter-flags';
     #flags;
+    /* NOT FOR BROWSER END */
+    get type() {
+        return 'converter-flags';
+    }
+    /* NOT FOR BROWSER */
     /** 所有转换类型标记 */
     get flags() {
         return this.getAllFlags();
@@ -106,7 +110,6 @@ class ConverterFlagsToken extends index_2.Token {
         return super.print({ sep: ';' });
     }
     /* NOT FOR BROWSER */
-    /** @override */
     cloneNode() {
         const cloned = this.cloneChildNodes();
         return debug_1.Shadow.run(() => {

package/dist/src/converterRule.d.ts

@@ -7,7 +7,6 @@ import type { ConverterToken, ConverterFlagsToken } from '../internal';
  * @classdesc `{childNodes: ...AtomToken}`
  */
 export declare abstract class ConverterRuleToken extends Token {
-    readonly type = "converter-rule";
     readonly childNodes: readonly [AtomToken] | readonly [AtomToken, AtomToken] | readonly [AtomToken, AtomToken, AtomToken];
     abstract get firstChild(): AtomToken;
     abstract get lastChild(): AtomToken;
@@ -20,6 +19,7 @@ export declare abstract class ConverterRuleToken extends Token {
     abstract get parentElement(): ConverterToken | undefined;
     abstract get previousElementSibling(): ConverterFlagsToken | this;
     abstract get nextElementSibling(): this | undefined;
+    get type(): 'converter-rule';
     /** 语言变体 */
     get variant(): string;
     set variant(variant: string);
@@ -36,14 +36,12 @@ export declare abstract class ConverterRuleToken extends Token {
      * @param hasColon 是否带有":"
      */
     constructor(rule: string, hasColon?: boolean, config?: Parser.Config, accum?: Token[]);
-    /** @override */
     cloneNode(): this;
     /**
      * @override
      * @param i 移除位置
      */
     removeAt(i: number): AtomToken;
-    /** @override */
     insertAt(): never;
     /** 修改为不转换 */
     noConvert(): void;