wikiparser-node 1.13.1-b → 1.13.1

package/dist/src/table/td.js

@@ -0,0 +1,375 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTd = exports.TdToken = void 0;
+const lint_1 = require("../../util/lint");
+const constants_1 = require("../../util/constants");
+const debug_1 = require("../../util/debug");
+const rect_1 = require("../../lib/rect");
+const index_1 = require("../../index");
+const index_2 = require("../index");
+const base_1 = require("./base");
+/* NOT FOR BROWSER */
+const string_1 = require("../../util/string");
+const fixed_1 = require("../../mixin/fixed");
+/* NOT FOR BROWSER END */
+/**
+ * `<td>`、`<th>`和`<caption>`
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, Token]}`
+ */
+let TdToken = (() => {
+    var _a;
+    let _classDecorators = [fixed_1.fixedToken];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_1.TableBaseToken;
+    var TdToken = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            TdToken = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        #innerSyntax = '';
+        #syntax;
+        /* NOT FOR BROWSER END */
+        get type() {
+            return 'td';
+        }
+        /** rowspan */
+        get rowspan() {
+            return this.getAttr('rowspan');
+        }
+        /** colspan */
+        get colspan() {
+            return this.getAttr('colspan');
+        }
+        /** 单元格类型 */
+        get subtype() {
+            return this.#getSyntax().subtype;
+        }
+        /* NOT FOR BROWSER */
+        set subtype(subtype) {
+            this.setSyntax(subtype);
+        }
+        set rowspan(rowspan) {
+            this.setAttr('rowspan', rowspan);
+        }
+        set colspan(colspan) {
+            this.setAttr('colspan', colspan);
+        }
+        /** 内部wikitext */
+        get innerText() {
+            return this.lastChild.text().trim();
+        }
+        set innerText(text) {
+            this.lastChild.replaceChildren(...index_1.default.parse(text, true, undefined, this.getAttribute('config')).childNodes);
+        }
+        /* NOT FOR BROWSER END */
+        /**
+         * @param syntax 单元格语法
+         * @param inner 内部wikitext
+         */
+        constructor(syntax, inner, config = index_1.default.getConfig(), accum = []) {
+            let innerSyntax = /\||\0\d+!\x7F/u.exec(inner ?? ''), attr = innerSyntax ? inner.slice(0, innerSyntax.index) : '';
+            if (/\[\[|-\{/u.test(attr)) {
+                innerSyntax = null;
+                attr = '';
+            }
+            super(/^(?:\n[^\S\n]*(?:[|!]|\|\+|\{\{\s*!\s*\}\}\+?)|(?:\||\{\{\s*!\s*\}\}){2}|!!|\{\{\s*!!\s*\}\})$/u, syntax, 'td', attr, config, accum, { SyntaxToken: 0, AttributesToken: 1, Token: 2 });
+            if (innerSyntax) {
+                [this.#innerSyntax] = innerSyntax;
+            }
+            const innerToken = new index_2.Token(inner?.slice((innerSyntax?.index ?? NaN) + this.#innerSyntax.length), config, accum);
+            innerToken.type = 'td-inner';
+            innerToken.setAttribute('stage', 4);
+            this.insertAt(innerToken);
+        }
+        /** 表格语法信息 */
+        #getSyntax() {
+            const { rev } = debug_1.Shadow;
+            if (this.#syntax && this.#syntax[0] !== rev) {
+                this.#syntax = undefined;
+            }
+            if (index_1.default.viewOnly) {
+                this.#syntax ??= [rev, this.#computeSyntax()];
+                return this.#syntax[1];
+            }
+            return this.#computeSyntax();
+        }
+        /** 表格语法信息 */
+        #computeSyntax() {
+            const syntax = this.firstChild.text(), 
+            /* NOT FOR BROWSER */
+            esc = syntax.includes('{{'), 
+            /* NOT FOR BROWSER END */
+            char = syntax.slice(-1);
+            let subtype = 'td';
+            if (char === '!') {
+                subtype = 'th';
+            }
+            else if (char === '+') {
+                subtype = 'caption';
+            }
+            if (this.isIndependent()) {
+                return {
+                    subtype,
+                    /* NOT FOR BROWSER */
+                    escape: esc,
+                    correction: false,
+                };
+            }
+            const { previousSibling } = this;
+            /* NOT FOR BROWSER */
+            if (!(previousSibling instanceof TdToken)) {
+                return { subtype, escape: esc, correction: true };
+            }
+            /* NOT FOR BROWSER END */
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+            const result = { ...previousSibling.#getSyntax() };
+            /* NOT FOR BROWSER */
+            const str = previousSibling.lastChild.toString();
+            result.escape ||= esc;
+            result.correction = str.includes('\n') && debug_1.Shadow.run(() => {
+                const config = this.getAttribute('config'), include = this.getAttribute('include');
+                return new index_2.Token(str, config).parseOnce(0, include).parseOnce().parseOnce()
+                    .toString()
+                    .includes('\n');
+            });
+            if (subtype === 'th' && result.subtype !== 'th') {
+                result.subtype = 'th';
+                result.correction = true;
+            }
+            /* NOT FOR BROWSER END */
+            return result;
+        }
+        /** @private */
+        afterBuild() {
+            if (this.#innerSyntax.includes('\0')) {
+                this.#innerSyntax = this.buildFromStr(this.#innerSyntax, constants_1.BuildMethod.String);
+            }
+            super.afterBuild();
+        }
+        /** @private */
+        toString(skip) {
+            /* NOT FOR BROWSER */
+            this.#correct();
+            /* NOT FOR BROWSER END */
+            const { childNodes: [syntax, attr, inner] } = this;
+            return syntax.toString(skip) + attr.toString(skip) + this.#innerSyntax + inner.toString(skip);
+        }
+        /** @private */
+        text() {
+            /* NOT FOR BROWSER */
+            this.#correct();
+            /* NOT FOR BROWSER END */
+            const { childNodes: [syntax, attr, inner] } = this;
+            return syntax.text() + attr.text() + this.#innerSyntax + inner.text();
+        }
+        /** @private */
+        getGaps(i) {
+            if (i === 1) {
+                /* NOT FOR BROWSER */
+                this.#correct();
+                /* NOT FOR BROWSER END */
+                return this.#innerSyntax.length;
+            }
+            return 0;
+        }
+        /** @private */
+        lint(start = this.getAbsoluteIndex(), re) {
+            const errors = super.lint(start, re), rect = new rect_1.BoundingRect(this, start + this.getRelativeIndex(this.length - 1));
+            for (const child of this.lastChild.childNodes) {
+                if (child.type === 'text') {
+                    const { data } = child;
+                    if (data.includes('|')) {
+                        const isError = data.includes('||'), e = (0, lint_1.generateForChild)(child, rect, 'pipe-like', 'additional "|" in a table cell', isError ? 'error' : 'warning');
+                        if (isError) {
+                            const syntax = { caption: '|+', td: '|', th: '!' }[this.subtype];
+                            e.fix = {
+                                range: [e.startIndex, e.endIndex],
+                                text: data.replace(/\|\|/gu, `\n${syntax}`),
+                            };
+                        }
+                        else {
+                            e.suggestions = [
+                                {
+                                    desc: 'escape',
+                                    range: [e.startIndex, e.endIndex],
+                                    text: data.replace(/\|/gu, '&#124;'),
+                                },
+                            ];
+                        }
+                        errors.push(e);
+                    }
+                }
+            }
+            return errors;
+        }
+        /** 是否位于行首 */
+        isIndependent() {
+            return this.firstChild.text().startsWith('\n');
+        }
+        getAttr(key) {
+            const value = super.getAttr(key);
+            key = key.toLowerCase().trim();
+            return (key === 'rowspan' || key === 'colspan' ? parseInt(value) || 1 : value);
+        }
+        /** @private */
+        print() {
+            const { childNodes: [syntax, attr, inner] } = this;
+            return `<span class="wpb-td">${syntax.print()}${attr.print()}${this.#innerSyntax}${inner.print()}</span>`;
+        }
+        /** @override */
+        json() {
+            const json = super.json();
+            json['subtype'] = this.subtype;
+            return json;
+        }
+        /* NOT FOR BROWSER */
+        cloneNode() {
+            const token = super.cloneNode();
+            token.setAttribute('innerSyntax', this.#innerSyntax);
+            return token;
+        }
+        /** @private */
+        setAttribute(key, value) {
+            if (key === 'innerSyntax') {
+                this.#innerSyntax = (value ?? '');
+            }
+            else {
+                super.setAttribute(key, value);
+            }
+        }
+        /** @private */
+        setSyntax(syntax, esc) {
+            const aliases = { td: '\n|', th: '\n!', caption: '\n|+' };
+            super.setSyntax(aliases[syntax] ?? syntax, esc);
+        }
+        /** 修复\<td\>语法 */
+        #correct() {
+            if (this.childNodes[1].toString()) {
+                this.#innerSyntax ||= '|';
+            }
+            const { subtype, escape, correction } = this.#getSyntax();
+            if (correction) {
+                this.setSyntax(subtype, escape);
+            }
+        }
+        /** 改为独占一行 */
+        independence() {
+            if (!this.isIndependent()) {
+                const { subtype, escape } = this.#getSyntax();
+                this.setSyntax(subtype, escape);
+            }
+        }
+        getAttrs() {
+            const attr = super.getAttrs();
+            if ('rowspan' in attr) {
+                attr.rowspan = parseInt(attr.rowspan);
+            }
+            if ('colspan' in attr) {
+                attr.colspan = parseInt(attr.colspan);
+            }
+            return attr;
+        }
+        setAttr(keyOrProp, value) {
+            if (typeof keyOrProp !== 'string') {
+                for (const [key, val] of Object.entries(keyOrProp)) {
+                    this.setAttr(key, val);
+                }
+                return;
+            }
+            const key = keyOrProp.toLowerCase().trim();
+            let v;
+            if (typeof value === 'number' && (key === 'rowspan' || key === 'colspan')) {
+                v = value === 1 ? false : String(value);
+            }
+            else {
+                v = String(value);
+            }
+            super.setAttr(key, v);
+            if (!this.childNodes[1].toString()) {
+                this.#innerSyntax = '';
+            }
+        }
+        /** @private */
+        escape() {
+            super.escape();
+            if (this.childNodes[1].toString()) {
+                this.#innerSyntax ||= '{{!}}';
+            }
+            if (this.#innerSyntax === '|') {
+                this.#innerSyntax = '{{!}}';
+            }
+        }
+        /** @private */
+        toHtmlInternal(nowrap) {
+            const { subtype, childNodes: [, attr, inner], nextSibling } = this, notEOL = nextSibling?.toString().startsWith('\n') === false, lf = nowrap ? ' ' : '\n';
+            let html = inner.toHtmlInternal(nowrap).replace(/^[^\S\n]*/u, '');
+            if (notEOL) {
+                html = html.replace(/(?<=[\S\n])[^\S\n]*$/u, '');
+            }
+            return `${lf}<${subtype}${attr.toHtmlInternal()}>${subtype === 'caption' ? (0, string_1.newline)(html) : html + (notEOL ? '' : lf)}</${subtype}>`;
+        }
+    };
+    return TdToken = _classThis;
+})();
+exports.TdToken = TdToken;
+/* NOT FOR BROWSER */
+/**
+ * 创建新的单元格
+ * @param inner 内部wikitext
+ * @param subtype 单元格类型
+ * @param attr 单元格属性
+ * @param include 是否嵌入
+ * @param config
+ */
+const createTd = (inner, subtype = 'td', attr = {}, include, config = index_1.default.getConfig()) => {
+    const innerToken = typeof inner === 'string' ? index_1.default.parse(inner, include, undefined, config) : inner, 
+    // @ts-expect-error abstract class
+    token = debug_1.Shadow.run(() => new TdToken('\n|', undefined, config));
+    token.setSyntax(subtype);
+    token.lastChild.safeReplaceWith(innerToken);
+    token.setAttr(attr);
+    return token;
+};
+exports.createTd = createTd;
+/* NOT FOR BROWSER END */
+constants_1.classes['TdToken'] = __filename;

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

@@ -0,0 +1,30 @@
+import { TrBaseToken } from './trBase';
+import type { Config } from '../../base';
+import type { Token, TdToken, TableToken, SyntaxToken, AttributesToken } from '../../internal';
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
+ */
+export declare abstract class TrToken extends TrBaseToken {
+    #private;
+    readonly childNodes: readonly [SyntaxToken, AttributesToken, ...TdToken[]];
+    abstract get lastChild(): AttributesToken | TdToken;
+    abstract get parentNode(): TableToken | undefined;
+    abstract get nextSibling(): this | SyntaxToken | undefined;
+    abstract get previousSibling(): Token;
+    abstract get children(): [SyntaxToken, AttributesToken, ...TdToken[]];
+    abstract get lastElementChild(): AttributesToken | TdToken;
+    abstract get parentElement(): TableToken | undefined;
+    abstract get nextElementSibling(): this | SyntaxToken | undefined;
+    abstract get previousElementSibling(): Token;
+    get type(): 'tr';
+    /**
+     * @param syntax 表格语法
+     * @param attr 表格属性
+     */
+    constructor(syntax: string, attr?: string, config?: Config, accum?: Token[]);
+    /** 获取下一行 */
+    getNextRow(): TrToken | undefined;
+    /** 获取前一行 */
+    getPreviousRow(): TrToken | undefined;
+}

package/dist/src/table/tr.js

@@ -0,0 +1,61 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrToken = void 0;
+const trBase_1 = require("./trBase");
+/* NOT FOR BROWSER */
+const constants_1 = require("../../util/constants");
+/* NOT FOR BROWSER END */
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
+ */
+class TrToken extends trBase_1.TrBaseToken {
+    /* NOT FOR BROWSER END */
+    get type() {
+        return 'tr';
+    }
+    /**
+     * @param syntax 表格语法
+     * @param attr 表格属性
+     */
+    constructor(syntax, attr, config, accum) {
+        super(/^\n[^\S\n]*(?:\|-+|\{\{\s*!\s*\}\}-+|\{\{\s*!-\s*\}\}-*)$/u, syntax, 'tr', attr, config, accum, {
+            Token: 2, SyntaxToken: 0, AttributesToken: 1, TdToken: '2:',
+        });
+    }
+    /* NOT FOR BROWSER */
+    /** @private */
+    text() {
+        const str = super.text();
+        return str.trim().includes('\n') ? str : '';
+    }
+    /**
+     * 获取相邻行
+     * @param subset 筛选兄弟节点的方法
+     */
+    #getSiblingRow(subset) {
+        const { parentNode } = this;
+        if (!parentNode) {
+            return undefined;
+        }
+        const { childNodes } = parentNode, index = childNodes.indexOf(this);
+        for (const child of subset(childNodes, index)) {
+            if (child instanceof _a && child.getRowCount()) {
+                return child;
+            }
+        }
+        return undefined;
+    }
+    /** 获取下一行 */
+    getNextRow() {
+        return this.#getSiblingRow((childNodes, index) => childNodes.slice(index + 1));
+    }
+    /** 获取前一行 */
+    getPreviousRow() {
+        return this.#getSiblingRow((childNodes, index) => childNodes.slice(0, index).reverse());
+    }
+}
+exports.TrToken = TrToken;
+_a = TrToken;
+constants_1.classes['TrToken'] = __filename;

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

@@ -0,0 +1,49 @@
+import { TableBaseToken } from './base';
+import { TdToken } from './td';
+import type { LintError } from '../../base';
+import type { AstNodes, SyntaxToken, TrToken } from '../../internal';
+import { Token } from '../index';
+import type { TdAttrs, TdSubtypes } from './td';
+export interface TableCoords {
+    readonly row: number;
+    readonly column: number;
+    readonly x?: undefined;
+    readonly y?: undefined;
+    readonly start?: boolean;
+}
+/** 表格行或表格 */
+export declare abstract class TrBaseToken extends TableBaseToken {
+    #private;
+    abstract get type(): 'table' | 'tr';
+    /** 获取行数 */
+    getRowCount(): number;
+    /**
+     * 获取第n列
+     * @param n 列号
+     * @param insert 是否用于判断插入新列的位置
+     * @throws `RangeError` 不存在对应单元格
+     */
+    getNthCol(n: number, insert?: false): TdToken | undefined;
+    getNthCol(n: number, insert: true): TdToken | TrToken | SyntaxToken | undefined;
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i: number): AstNodes;
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt<T extends Token>(token: T, i?: number): T;
+    /** 获取列数 */
+    getColCount(): number;
+    /**
+     * 插入新的单元格
+     * @param inner 单元格内部wikitext
+     * @param {TableCoords} coord 单元格坐标
+     * @param subtype 单元格类型
+     * @param attr 单元格属性
+     */
+    insertTableCell(inner: string | Token, { column }: TableCoords, subtype?: TdSubtypes, attr?: TdAttrs): TdToken;
+}

package/dist/src/table/trBase.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrBaseToken = void 0;
+const lint_1 = require("../../util/lint");
+const base_1 = require("./base");
+const td_1 = require("./td");
+/* NOT FOR BROWSER */
+const debug_1 = require("../../util/debug");
+const constants_1 = require("../../util/constants");
+const html_1 = require("../../util/html");
+const debug_2 = require("../../util/debug");
+const index_1 = require("../index");
+/** 表格行或表格 */
+class TrBaseToken extends base_1.TableBaseToken {
+    /** @private */
+    lint(start = this.getAbsoluteIndex(), re) {
+        const errors = super.lint(start, re), inter = this.childNodes.find(({ type }) => type === 'table-inter');
+        if (!inter) {
+            return errors;
+        }
+        const first = inter.childNodes.find(child => child.text().trim()), tdPattern = /^\s*(?:!|\{\{\s*![!-]?\s*\}\})/u;
+        if (!first
+            || tdPattern.test(first.toString())
+            || first.is('arg') && tdPattern.test(first.default || '')) {
+            return errors;
+        }
+        else if (first.is('magic-word')) {
+            try {
+                if (first.getPossibleValues().every(token => tdPattern.test(token.text()))) {
+                    return errors;
+                }
+            }
+            catch { }
+        }
+        const error = (0, lint_1.generateForChild)(inter, { start }, 'fostered-content', 'content to be moved out from the table');
+        error.severity = first.type === 'template' ? 'warning' : 'error';
+        error.startIndex++;
+        error.startLine++;
+        error.startCol = 0;
+        errors.push(error);
+        return errors;
+    }
+    /** 获取行数 */
+    getRowCount() {
+        return Number(this.childNodes.some(child => child instanceof td_1.TdToken && child.isIndependent() && !child.firstChild.text().endsWith('+')));
+    }
+    getNthCol(n, insert) {
+        /* NOT FOR BROWSER */
+        const nCols = this.getColCount();
+        n += n < 0 ? nCols : 0;
+        if (n < 0 || n > nCols || n === nCols && !insert) {
+            throw new RangeError(`There is no cell at position ${n}!`);
+        }
+        /* NOT FOR BROWSER END */
+        let last = 0;
+        for (const child of this.childNodes.slice(2)) {
+            if (child instanceof td_1.TdToken) {
+                if (child.isIndependent()) {
+                    last = Number(child.subtype !== 'caption');
+                }
+                n -= last;
+                if (n < 0) {
+                    return child;
+                }
+                /* NOT FOR BROWSER */
+            }
+            else if (child.is('tr') || child.is('table-syntax')) {
+                return child;
+                /* NOT FOR BROWSER END */
+            }
+        }
+        return undefined;
+    }
+    /* NOT FOR BROWSER */
+    /** 修复简单的表格语法错误 */
+    #correct() {
+        const { childNodes: [, , child] } = this;
+        if (child?.constructor === index_1.Token) {
+            const { firstChild } = child;
+            if (firstChild?.type !== 'text') {
+                child.prepend('\n');
+            }
+            else if (!firstChild.data.startsWith('\n')) {
+                firstChild.insertData(0, '\n');
+            }
+        }
+    }
+    /** @private */
+    text() {
+        this.#correct();
+        return super.text();
+    }
+    /** @private */
+    toString(skip) {
+        this.#correct();
+        return super.toString(skip);
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        i += i < 0 ? this.length : 0;
+        const child = this.childNodes[i];
+        if (child instanceof td_1.TdToken && child.isIndependent()) {
+            const { nextSibling } = child;
+            if (nextSibling?.type === 'td') {
+                nextSibling.independence();
+            }
+        }
+        return super.removeAt(i);
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt(token, i = this.length) {
+        if (!debug_1.Shadow.running && token.type !== 'td') {
+            if (this.type === 'tr') {
+                this.typeError('insertAt', 'TdToken');
+            }
+            else if (token.type !== 'tr') {
+                this.typeError('insertAt', 'TrToken', 'TdToken');
+            }
+        }
+        i += i < 0 ? this.length : 0;
+        const child = this.childNodes[i];
+        if (token instanceof td_1.TdToken && token.isIndependent() && child instanceof td_1.TdToken) {
+            child.independence();
+        }
+        return super.insertAt(token, i);
+    }
+    /** 获取列数 */
+    getColCount() {
+        let count = 0, last = 0;
+        for (const child of this.childNodes) {
+            if (child instanceof td_1.TdToken) {
+                last = child.isIndependent() ? Number(child.subtype !== 'caption') : last;
+                count += last;
+            }
+        }
+        return count;
+    }
+    /**
+     * 插入新的单元格
+     * @param inner 单元格内部wikitext
+     * @param {TableCoords} coord 单元格坐标
+     * @param subtype 单元格类型
+     * @param attr 单元格属性
+     */
+    insertTableCell(inner, { column }, subtype = 'td', attr = {}) {
+        const token = (0, td_1.createTd)(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
+        return this.insertBefore(token, this.getNthCol(column, true));
+    }
+    /** @private */
+    toHtmlInternal(nowrap) {
+        const { childNodes, type } = this, td = childNodes.filter((0, debug_2.isToken)('td'));
+        return td.some(({ subtype }) => subtype !== 'caption')
+            ? `<tr${type === 'tr' ? childNodes[1].toHtmlInternal() : ''}>${(0, html_1.html)(td, '', nowrap)}</tr>`
+            : (0, html_1.html)(td, '', nowrap);
+    }
+}
+exports.TrBaseToken = TrBaseToken;
+constants_1.classes['TrBaseToken'] = __filename;