wikiparser-node 0.11.0 → 1.0.0-beta.1

package/dist/src/paramTag/inputbox.js

@@ -0,0 +1,19 @@
+"use strict";
+const parseBrackets = require("../../parser/brackets");
+const Parser = require("../../index");
+const ParamTagToken = require(".");
+/** `<inputbox>` */
+class InputboxToken extends ParamTagToken {
+    /** @browser */
+    constructor(wikitext, config = Parser.getConfig(), accum = []) {
+        const placeholder = Symbol('InputboxToken');
+        accum.push(placeholder);
+        const text = wikitext && parseBrackets(wikitext, config, accum);
+        accum.splice(accum.indexOf(placeholder), 1);
+        super(text, config, accum, {
+            ArgToken: ':', TranscludeToken: ':',
+        });
+    }
+}
+Parser.classes['InputboxToken'] = __filename;
+module.exports = InputboxToken;

package/dist/src/parameter.d.ts

@@ -1,75 +1,96 @@
-export = ParameterToken;
+import * as Parser from '../index';
+import Token = require('.');
+import AtomToken = require('./atom');
+import SyntaxToken = require('./syntax');
+declare const ParameterToken_base: ((abstract new (...args: any[]) => {
+    removeAt(): never;
+    insertAt(token: string, i?: number | undefined): import("../lib/text");
+    insertAt<T extends import("../lib/node").AstNodeTypes>(token: T, i?: number | undefined): T;
+    length: number;
+    toString(selector?: string | undefined, separator?: string | undefined): string;
+    text(separator?: string | undefined): string;
+}) & {
+    readonly fixed: true;
+}) & typeof Token;
 /**
  * 模板或魔术字参数
  * @classdesc `{childNodes: [Token, Token]}`
  */
-declare class ParameterToken extends Token {
+declare abstract class ParameterToken extends ParameterToken_base {
+    /** @browser */
+    readonly type = "parameter";
+    name: string;
+    childNodes: [Token, Token];
+    abstract get children(): [Token, Token];
+    abstract get firstChild(): Token;
+    abstract get firstElementChild(): Token;
+    abstract get lastChild(): Token;
+    abstract get lastElementChild(): Token;
+    abstract get parentNode(): import('./transclude') | undefined;
+    abstract get parentElement(): import('./transclude') | undefined;
+    abstract get nextSibling(): this | undefined;
+    abstract get nextElementSibling(): this | undefined;
+    abstract get previousSibling(): AtomToken | SyntaxToken | this;
+    abstract get previousElementSibling(): AtomToken | SyntaxToken | this;
     /**
-     * @param {string|number} key 参数名
-     * @param {string} value 参数值
-     * @param {import('../../typings/token').accum} accum
+     * 是否是匿名参数
+     * @browser
      */
-    constructor(key: string | number, value: string, config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
-    /** 是否是匿名参数 */
     get anon(): boolean;
-    set value(arg: string);
     /** getValue()的getter */
     get value(): string;
+    set value(value: string);
+    /** 是否是重复参数 */
+    get duplicated(): boolean;
     /**
-     * 是否是重复参数
-     * @this {ParameterToken & {parentNode: TranscludeToken}}
+     * @browser
+     * @param key 参数名
+     * @param value 参数值
      */
-    get duplicated(): boolean;
+    constructor(key?: string | number, value?: string, config?: Parser.Config, accum?: Token[]);
     /**
      * @override
-     * @param {string} selector
-     * @returns {string}
+     * @browser
      */
-    override toString(selector: string): string;
+    toString(selector?: string): string;
     /**
      * @override
-     * @returns {string}
+     * @browser
      */
-    override text(): string;
-    /** @override */
-    override getGaps(): 1 | 0;
-    /** @override */
-    override print(): string;
+    text(): string;
     /**
-     * 获取参数值
-     * @this {ParameterToken & {parentNode: TranscludeToken}}
+     * @override
+     * @browser
      */
-    getValue(this: ParameterToken & {
-        parentNode: import("./transclude");
-    }): string;
+    print(): string;
+    /**
+     * @override
+     * @browser
+     */
+    lint(start?: number): Parser.LintError[];
     /** @override */
-    override cloneNode(): ParameterToken;
+    cloneNode(): this;
     /**
      * @override
-     * @param {ParameterToken} token 待替换的节点
-     * @complexity `n`
+     * @param token 待替换的节点
      */
-    override safeReplaceWith(token: ParameterToken): void;
+    safeReplaceWith(token: this): void;
+    /** 获取参数值 */
+    getValue(): string;
     /**
      * 设置参数值
-     * @this {ParameterToken & {parentNode: TranscludeToken}}
-     * @param {string} value 参数值
+     * @param value 参数值
      * @throws `SyntaxError` 非法的模板参数
      */
-    setValue(this: ParameterToken & {
-        parentNode: import("./transclude");
-    }, value: string): void;
+    setValue(value: string): void;
     /**
      * 修改参数名
-     * @this {ParameterToken & {parentNode: TranscludeToken}}
-     * @param {string} key 新参数名
-     * @param {boolean} force 是否无视冲突命名
+     * @param key 新参数名
+     * @param force 是否无视冲突命名
      * @throws `Error` 仅用于模板参数
      * @throws `SyntaxError` 非法的模板参数名
      * @throws `RangeError` 更名造成重复参数
      */
-    rename(this: ParameterToken & {
-        parentNode: import("./transclude");
-    }, key: string, force: boolean): void;
+    rename(key: string, force?: boolean): void;
 }
-import Token = require(".");
+export = ParameterToken;

package/dist/src/parameter.js

@@ -0,0 +1,201 @@
+"use strict";
+const string_1 = require("../util/string");
+const lint_1 = require("../util/lint");
+const fixed = require("../mixin/fixed");
+const Parser = require("../index");
+const Token = require(".");
+/**
+ * 模板或魔术字参数
+ * @classdesc `{childNodes: [Token, Token]}`
+ */
+class ParameterToken extends fixed(Token) {
+    /** @browser */
+    type = 'parameter';
+    /**
+     * 是否是匿名参数
+     * @browser
+     */
+    get anon() {
+        return this.firstChild.length === 0;
+    }
+    /** getValue()的getter */
+    get value() {
+        return this.getValue();
+    }
+    set value(value) {
+        this.setValue(value);
+    }
+    /** 是否是重复参数 */
+    get duplicated() {
+        try {
+            return Boolean(this.parentNode?.getDuplicatedArgs()?.some(([key]) => key === this.name));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * @browser
+     * @param key 参数名
+     * @param value 参数值
+     */
+    constructor(key, value, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, true, accum);
+        const keyToken = new Token(typeof key === 'number' ? undefined : key, config, true, accum, {
+            'Stage-11': ':', '!HeadingToken': '',
+        }), token = new Token(value, config, true, accum);
+        keyToken.type = 'parameter-key';
+        token.type = 'parameter-value';
+        this.append(keyToken, token.setAttribute('stage', 2));
+    }
+    /** @private */
+    afterBuild() {
+        if (!this.anon) {
+            const name = this.firstChild.toString('comment, noinclude, include')
+                .replace(/^[ \t\n\0\v]+|(?<=[^ \t\n\0\v])[ \t\n\0\v]+$/gu, ''), { parentNode } = this;
+            this.setAttribute('name', name);
+            if (parentNode) {
+                parentNode.getAttribute('keys').add(name);
+                parentNode.getArgs(name, false, false).add(this);
+            }
+        }
+        const /** @implements */ parameterListener = ({ prevTarget }, data) => {
+            if (!this.anon) { // 匿名参数不管怎么变动还是匿名
+                const { firstChild, name } = this;
+                if (prevTarget === firstChild) {
+                    const newKey = firstChild.toString('comment, noinclude, include')
+                        .replace(/^[ \t\n\0\v]+|(?<=[^ \t\n\0\v])[ \t\n\0\v]+$/gu, '');
+                    data.oldKey = name;
+                    data.newKey = newKey;
+                    this.setAttribute('name', newKey);
+                }
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'replace', 'text'], parameterListener);
+    }
+    /**
+     * @override
+     * @browser
+     */
+    toString(selector) {
+        return this.anon && !(selector && this.matches(selector))
+            ? this.lastChild.toString(selector)
+            : super.toString(selector, '=');
+    }
+    /**
+     * @override
+     * @browser
+     */
+    text() {
+        return this.anon ? this.lastChild.text() : super.text('=');
+    }
+    /** @private */
+    getGaps() {
+        return this.anon ? 0 : 1;
+    }
+    /**
+     * @override
+     * @browser
+     */
+    print() {
+        return super.print({ sep: this.anon ? '' : '=' });
+    }
+    /**
+     * @override
+     * @browser
+     */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start), { firstChild, lastChild } = this, link = new RegExp(`https?://${string_1.extUrlCharFirst}${string_1.extUrlChar}$`, 'iu')
+            .exec(firstChild.toString('comment, noinclude, include'))?.[0];
+        if (link && new URL(link).search) {
+            const e = (0, lint_1.generateForChild)(firstChild, { start }, 'unescaped query string in an anonymous parameter');
+            errors.push({
+                ...e,
+                startIndex: e.endIndex,
+                endIndex: e.endIndex + 1,
+                startLine: e.endLine,
+                startCol: e.endCol,
+                endCol: e.endCol + 1,
+                excerpt: `${String(firstChild).slice(-25)}=${String(lastChild).slice(0, 25)}`,
+            });
+        }
+        return errors;
+    }
+    /** @override */
+    cloneNode() {
+        const [key, value] = this.cloneChildNodes(), config = this.getAttribute('config');
+        return Parser.run(() => {
+            const token = new ParameterToken(this.anon ? Number(this.name) : undefined, undefined, config);
+            token.firstChild.safeReplaceWith(key);
+            token.lastChild.safeReplaceWith(value);
+            token.afterBuild();
+            return token;
+        });
+    }
+    /**
+     * @override
+     * @param token 待替换的节点
+     */
+    safeReplaceWith(token) {
+        Parser.warn(`${this.constructor.name}.safeReplaceWith 方法退化到 replaceWith。`);
+        this.replaceWith(token);
+    }
+    /** 获取参数值 */
+    getValue() {
+        const value = this.lastChild.text();
+        return this.anon && this.parentNode?.isTemplate() !== false ? value : value.trim();
+    }
+    /**
+     * 设置参数值
+     * @param value 参数值
+     * @throws `SyntaxError` 非法的模板参数
+     */
+    setValue(value) {
+        const templateLike = this.parentNode?.isTemplate() !== false, wikitext = `{{${templateLike ? ':T|' : 'lc:'}${this.anon ? '' : '1='}${value}}}`, root = Parser.parse(wikitext, this.getAttribute('include'), 2, this.getAttribute('config')), { length, firstChild: transclude } = root, targetType = templateLike ? 'template' : 'magic-word';
+        if (length !== 1 || transclude.type !== targetType) {
+            throw new SyntaxError(`非法的模板参数：${(0, string_1.noWrap)(value)}`);
+        }
+        const { lastChild: parameter, name } = transclude, targetName = templateLike ? 'T' : 'lc';
+        if (name !== targetName || transclude.length !== 2 || parameter.anon !== this.anon || parameter.name !== '1') {
+            throw new SyntaxError(`非法的模板参数：${(0, string_1.noWrap)(value)}`);
+        }
+        const { lastChild } = parameter;
+        parameter.destroy();
+        this.lastChild.safeReplaceWith(lastChild);
+    }
+    /**
+     * 修改参数名
+     * @param key 新参数名
+     * @param force 是否无视冲突命名
+     * @throws `Error` 仅用于模板参数
+     * @throws `SyntaxError` 非法的模板参数名
+     * @throws `RangeError` 更名造成重复参数
+     */
+    rename(key, force = false) {
+        const { parentNode } = this;
+        // 必须检测是否是TranscludeToken
+        if (parentNode?.isTemplate() === false) {
+            throw new Error(`${this.constructor.name}.rename 方法仅用于模板参数！`);
+        }
+        const root = Parser.parse(`{{:T|${key}=}}`, this.getAttribute('include'), 2, this.getAttribute('config')), { length, firstChild: template } = root;
+        if (length !== 1 || template.type !== 'template' || template.name !== 'T' || template.length !== 2) {
+            throw new SyntaxError(`非法的模板参数名：${key}`);
+        }
+        const { lastChild: parameter } = template, { name, firstChild } = parameter;
+        if (this.name === name) {
+            Parser.warn('未改变实际参数名', name);
+        }
+        else if (parentNode?.hasArg(name)) {
+            if (force) {
+                Parser.warn('参数更名造成重复参数', name);
+            }
+            else {
+                throw new RangeError(`参数更名造成重复参数：${name}`);
+            }
+        }
+        parameter.destroy();
+        this.firstChild.safeReplaceWith(firstChild);
+    }
+}
+Parser.classes['ParameterToken'] = __filename;
+module.exports = ParameterToken;

package/dist/src/pre.d.ts

@@ -0,0 +1,32 @@
+import * as Parser from '../index';
+import AstText = require('../lib/text');
+import Token = require('.');
+import NoincludeToken = require('./nowiki/noinclude');
+import AttributesToken = require('./attributes');
+import ExtToken = require('./tagPair/ext');
+import ConverterToken = require('./converter');
+/**
+ * `<pre>`
+ * @classdesc `{childNodes: [...AstText|NoincludeToken|ConverterToken]}`
+ */
+declare abstract class PreToken extends Token {
+    /** @browser */
+    readonly type = "ext-inner";
+    childNodes: (AstText | NoincludeToken | ConverterToken)[];
+    abstract get children(): (NoincludeToken | ConverterToken)[];
+    abstract get firstChild(): AstText | NoincludeToken | ConverterToken | undefined;
+    abstract get firstElementChild(): NoincludeToken | ConverterToken | undefined;
+    abstract get lastChild(): AstText | NoincludeToken | ConverterToken | undefined;
+    abstract get lastElementChild(): NoincludeToken | ConverterToken | undefined;
+    abstract get nextSibling(): undefined;
+    abstract get nextElementSibling(): undefined;
+    abstract get previousSibling(): AttributesToken;
+    abstract get previousElementSibling(): AttributesToken;
+    abstract get parentNode(): ExtToken | undefined;
+    abstract get parentElement(): ExtToken | undefined;
+    /** @browser */
+    constructor(wikitext?: string, config?: Parser.Config, accum?: Token[]);
+    /** @override */
+    cloneNode(): this;
+}
+export = PreToken;

package/dist/src/pre.js

@@ -0,0 +1,39 @@
+"use strict";
+const Parser = require("../index");
+const Token = require(".");
+const NoincludeToken = require("./nowiki/noinclude");
+/**
+ * `<pre>`
+ * @classdesc `{childNodes: [...AstText|NoincludeToken|ConverterToken]}`
+ */
+class PreToken extends Token {
+    /** @browser */
+    type = 'ext-inner';
+    /** @browser */
+    constructor(wikitext, config = Parser.getConfig(), accum = []) {
+        const text = wikitext?.replace(/(<nowiki>)(.*?)(<\/nowiki>)/giu, (_, opening, inner, closing) => {
+            new NoincludeToken(opening, config, accum);
+            new NoincludeToken(closing, config, accum);
+            return `\0${accum.length - 1}c\x7F${inner}\0${accum.length}c\x7F`;
+        });
+        super(text, config, true, accum, {
+            AstText: ':', NoincludeToken: ':', ConverterToken: ':',
+        });
+        this.setAttribute('stage', Parser.MAX_STAGE - 1);
+    }
+    /** @private */
+    isPlain() {
+        return true;
+    }
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes();
+        return Parser.run(() => {
+            const token = new PreToken(undefined, this.getAttribute('config'));
+            token.append(...cloned);
+            return token;
+        });
+    }
+}
+Parser.classes['PreToken'] = __filename;
+module.exports = PreToken;

package/dist/src/syntax.d.ts

@@ -1,20 +1,23 @@
-export = SyntaxToken;
-/**
- * 满足特定语法格式的plain Token
- * @classdesc `{childNodes: ...AstText|Token}`
- */
+import * as Parser from '../index';
+import Token = require('.');
+import type { TokenAttributeGetter, AstNodeTypes } from '../lib/node';
+declare type SyntaxTypes = 'plain' | 'heading-trail' | 'magic-word-name' | 'table-syntax';
+/** 满足特定语法格式的plain Token */
 declare class SyntaxToken extends Token {
+    #private;
+    type: SyntaxTypes;
     /**
-     * @param {string} wikitext 语法wikitext
-     * @param {RegExp} pattern 语法正则
-     * @param {string} type Token.type
-     * @param {import('../../typings/token').accum} accum
-     * @param {import('../../typings/token').acceptable} acceptable 可接受的子节点设置
+     * @browser
+     * @param pattern 语法正则
      * @throws `RangeError` 含有g修饰符的语法正则
      */
-    constructor(wikitext: string, pattern: RegExp, type?: string, config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum, acceptable?: import('../../typings/token').acceptable);
+    constructor(wikitext: string | undefined, pattern: RegExp, type?: SyntaxTypes, config?: Parser.Config, accum?: Token[], acceptable?: Acceptable);
     /** @override */
-    override cloneNode(): SyntaxToken;
-    #private;
+    cloneNode(): this;
+    /**
+     * @override
+     * @param elements 待替换的子节点
+     */
+    replaceChildren(...elements: (AstNodeTypes | string)[]): void;
 }
-import Token = require(".");
+export = SyntaxToken;

package/dist/src/syntax.js

@@ -0,0 +1,65 @@
+"use strict";
+const Parser = require("../index");
+const debug_1 = require("../util/debug");
+const string_1 = require("../util/string");
+const Token = require(".");
+/** 满足特定语法格式的plain Token */
+class SyntaxToken extends Token {
+    #pattern;
+    /**
+     * @browser
+     * @param pattern 语法正则
+     * @throws `RangeError` 含有g修饰符的语法正则
+     */
+    constructor(wikitext, pattern, type = 'plain', config = Parser.getConfig(), accum = [], acceptable) {
+        if (pattern.global) {
+            throw new RangeError(`SyntaxToken 的语法正则不能含有 g 修饰符：${String(pattern)}`);
+        }
+        super(wikitext, config, true, accum, acceptable);
+        this.type = type;
+        this.#pattern = pattern;
+    }
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), config = this.getAttribute('config'), acceptable = this.getAttribute('acceptable');
+        return Parser.run(() => {
+            const token = new SyntaxToken(undefined, this.#pattern, this.type, config, [], acceptable);
+            token.append(...cloned);
+            token.afterBuild();
+            return token;
+        });
+    }
+    /** @private */
+    afterBuild() {
+        const /** @implements */ syntaxListener = (e, data) => {
+            const pattern = this.#pattern;
+            if (!Parser.running && !pattern.test(this.text())) {
+                (0, debug_1.undo)(e, data);
+                Parser.error(`不可修改 ${this.constructor.name} 的语法！`, pattern);
+                throw new Error(`不可修改 ${this.constructor.name} 的语法！`);
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'replace', 'text'], syntaxListener);
+    }
+    /** @private */
+    getAttribute(key) {
+        return key === 'pattern' ? this.#pattern : super.getAttribute(key);
+    }
+    /** @private */
+    hasAttribute(key) {
+        return key === 'pattern' || super.hasAttribute(key);
+    }
+    /**
+     * @override
+     * @param elements 待替换的子节点
+     */
+    replaceChildren(...elements) {
+        if (this.#pattern.test((0, string_1.text)(elements))) {
+            Parser.run(() => {
+                super.replaceChildren(...elements);
+            });
+        }
+    }
+}
+Parser.classes['SyntaxToken'] = __filename;
+module.exports = SyntaxToken;

package/dist/src/table/base.d.ts

@@ -0,0 +1,55 @@
+import * as Parser from '../../index';
+import Token = require('..');
+import SyntaxToken = require('../syntax');
+import AttributesToken = require('../attributes');
+declare const TableBaseToken_base: (abstract new (...args: any[]) => {
+    childNodes: import("../../lib/node").AstNodeTypes[];
+    readonly "__#12@#attributesChild": AttributesToken;
+    readonly attributes: Record<string, string | true>;
+    className: string;
+    readonly classList: Set<string>;
+    id: string;
+    hasAttr(key: string): boolean;
+    getAttr(key: string): string | true | undefined;
+    getAttrNames(): Set<string>;
+    hasAttrs(): boolean;
+    getAttrs(): Record<string, string | true>;
+    setAttr(key: string, value: string | boolean): void;
+    removeAttr(key: string): void;
+    toggleAttr(key: string, force?: boolean | undefined): void;
+    length: number;
+    toString(selector?: string | undefined, separator?: string | undefined): string;
+    text(separator?: string | undefined): string;
+    insertAt(token: unknown, i?: number | undefined): unknown;
+}) & typeof Token;
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
+ */
+declare abstract class TableBaseToken extends TableBaseToken_base {
+    type: 'table' | 'tr' | 'td';
+    childNodes: [SyntaxToken, AttributesToken, ...Token[]];
+    abstract get children(): [SyntaxToken, AttributesToken, ...Token[]];
+    abstract get firstChild(): SyntaxToken;
+    abstract get firstElementChild(): SyntaxToken;
+    abstract get lastChild(): Token;
+    abstract get lastElementChild(): Token;
+    /**
+     * @browser
+     * @param pattern 表格语法正则
+     * @param syntax 表格语法
+     * @param attr 表格属性
+     */
+    constructor(pattern: RegExp, syntax: string | undefined, attr?: string, config?: Parser.Config, accum?: Token[], acceptable?: Acceptable);
+    /** @override */
+    cloneNode(): this;
+    /** 转义表格语法 */
+    escape(): void;
+    /**
+     * 设置表格语法
+     * @param syntax 表格语法
+     * @param esc 是否需要转义
+     */
+    setSyntax(syntax: string, esc?: boolean): void;
+}
+export = TableBaseToken;

package/dist/src/table/base.js

@@ -0,0 +1,77 @@
+"use strict";
+const attributesParent = require("../../mixin/attributesParent");
+const Parser = require("../../index");
+const Token = require("..");
+const SyntaxToken = require("../syntax");
+const AttributesToken = require("../attributes");
+/**
+ * 转义表格语法
+ * @param syntax 表格语法节点
+ */
+const escapeTable = (syntax) => {
+    const templates = { '{|': '(!', '|}': '!)', '||': '!!', '|': '!' }, wikitext = syntax.childNodes.map(child => child.type === 'text'
+        ? String(child).replace(/\{\||\|\}|\|{1,2}/gu, p => `{{${templates[p]}}}`)
+        : String(child)).join(''), token = Parser.parse(wikitext, syntax.getAttribute('include'), 2, syntax.getAttribute('config'));
+    syntax.replaceChildren(...token.childNodes);
+};
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
+ */
+class TableBaseToken extends attributesParent(Token, 1) {
+    /**
+     * @browser
+     * @param pattern 表格语法正则
+     * @param syntax 表格语法
+     * @param attr 表格属性
+     */
+    constructor(pattern, syntax, attr = '', config = Parser.getConfig(), accum = [], acceptable = {}) {
+        super(undefined, config, true, accum, acceptable);
+        this.append(new SyntaxToken(syntax, pattern, 'table-syntax', config, accum, {
+            'Stage-1': ':', '!ExtToken': '', TranscludeToken: ':',
+        }), 
+        new AttributesToken(attr, 'table-attrs', this.type, config, accum));
+        this.protectChildren(0, 1);
+    }
+    /** @override */
+    cloneNode() {
+        const [syntax, attr, ...cloned] = this.cloneChildNodes();
+        return Parser.run(() => {
+            const { constructor } = this, token = new constructor(undefined, undefined, this.getAttribute('config'));
+            token.firstChild.safeReplaceWith(syntax);
+            token.childNodes[1].safeReplaceWith(attr);
+            if (token.type === 'td') { // TdToken
+                token.childNodes[2].safeReplaceWith(cloned[0]);
+            }
+            else {
+                token.append(...cloned);
+            }
+            return token;
+        });
+    }
+    /** 转义表格语法 */
+    escape() {
+        for (const child of this.childNodes) {
+            if (child instanceof SyntaxToken) {
+                escapeTable(child);
+            }
+            else if (child instanceof TableBaseToken) {
+                child.escape();
+            }
+        }
+    }
+    /**
+     * 设置表格语法
+     * @param syntax 表格语法
+     * @param esc 是否需要转义
+     */
+    setSyntax(syntax, esc = false) {
+        const { firstChild } = this;
+        firstChild.replaceChildren(syntax);
+        if (esc) {
+            escapeTable(firstChild);
+        }
+    }
+}
+Parser.classes['TableBaseToken'] = __filename;
+module.exports = TableBaseToken;