wikiparser-node 1.0.0-beta.4 → 1.0.0-beta.6

package/README.md

@@ -1,15 +1,16 @@
 [![npm version](https://badge.fury.io/js/wikiparser-node.svg)](https://www.npmjs.com/package/wikiparser-node)
-[![CodeQL](https://github.com/bhsd-harry/wikiparser-node/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/bhsd-harry/wikiparser-node/actions/workflows/github-code-scanning/codeql)
+[![CodeQL](https://github.com/bhsd-harry/wikiparser-node/actions/workflows/codeql.yml/badge.svg)](https://github.com/bhsd-harry/wikiparser-node/actions/workflows/codeql.yml)
+[![CI](https://github.com/bhsd-harry/wikiparser-node/actions/workflows/node.js.yml/badge.svg)](https://github.com/bhsd-harry/wikiparser-node/actions/workflows/node.js.yml)
 
 # 简介
 
-wikiparser-node 是一款由 Bhsd 开发的基于 [Node.js](https://nodejs.org/en/) 环境的离线[维基文本](https://www.mediawiki.org/wiki/Wikitext)语法解析器，可以解析绝大部分的维基语法并生成[语法树](https://en.wikipedia.org/wiki/Abstract_syntax_tree)，还可以很方便地对语法树进行查询和修改，最后返回修改后的维基文本。
+wikiparser-node 是一款由 Bhsd 开发的基于 [Node.js](https://nodejs.org/) 环境的离线[维基文本](https://www.mediawiki.org/wiki/Wikitext)语法解析器，可以解析几乎全部的维基语法并生成[语法树](https://en.wikipedia.org/wiki/Abstract_syntax_tree)，还可以很方便地对语法树进行查询和修改，最后返回修改后的维基文本。
 
 # 其他版本
 
-## Mini
+## Mini (又名 [wikilint](https://www.npmjs.com/package/wikilint))
 
-仅保留了解析功能和[语法错误分析](https://github.com/bhsd-harry/wikiparser-node/wiki/AstElement#lint)功能的轻量版本，解析生成的语法树不能修改。这个版本被应用于 [eslint-plugin-wikitext](/bhsd-harry/eslint-plugin-wikitext) 插件。
+提供了 [CLI](https://en.wikipedia.org/wiki/Command-line_interface)，但仅保留了解析功能和语法错误分析功能，解析生成的语法树不能修改。这个版本被应用于 [eslint-plugin-wikitext](https://www.npmjs.com/package/eslint-plugin-wikitext) 插件。
 
 ## Browser
 
@@ -19,16 +20,16 @@ wikiparser-node 是一款由 Bhsd 开发的基于 [Node.js](https://nodejs.org/e
 
 ## Node.js
 
-请根据需要需要安装对应的版本（`latest` 或 `mini`），如：
+请根据需要需要安装对应的版本（`wikiparser-node` 或 `wikilint`），如：
 
 ```sh
-npm i wikiparser-node # 默认为latest
+npm i wikiparser-node
 ```
 
 或
 
 ```sh
-npm i wikiparser-node@mini
+npm i wikilint
 ```
 
 ## 浏览器
@@ -45,8 +46,8 @@ npm i wikiparser-node@mini
 <script src="//unpkg.com/wikiparser-node@browser/bundle/bundle.min.js"></script>
 ```
 
-更多浏览器端可用的插件请查阅对应[文档](https://github.com/bhsd-harry/wikiparser-node/wiki/Browser)。
+更多浏览器端可用的插件请查阅对应文档。
 
 # 使用方法
 
-请查阅 [Wiki](https://github.com/bhsd-harry/wikiparser-node/wiki/Parser)。
+请查阅 [Wiki](https://github.com/bhsd-harry/wikiparser-node/wiki)。

package/dist/addon/table.d.ts

@@ -0,0 +1,6 @@
+import type { TableCoords } from '../src/table/trBase';
+/** @extends {Array<TableCoords[]>} */
+export declare class Layout extends Array<TableCoords[]> {
+    /** 打印表格布局 */
+    print(): void;
+}

package/dist/addon/table.js

@@ -0,0 +1,529 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layout = void 0;
+const assert = require("assert/strict");
+const Parser = require("../index");
+const src_1 = require("../src");
+const tr_1 = require("../src/table/tr");
+const table_1 = require("../src/table");
+const td_1 = require("../src/table/td");
+const trBase_1 = require("../src/table/trBase");
+/**
+ * 比较两个表格坐标
+ * @param coords1 坐标1
+ * @param coords2 坐标2
+ */
+const cmpCoords = (coords1, coords2) => {
+    const diff = coords1.row - coords2.row;
+    return diff === 0 ? coords1.column - coords2.column : diff;
+};
+/**
+ * 是否是行尾
+ * @param {Token} cell 表格单元格
+ */
+const isRowEnd = ({ type }) => type === 'tr' || type === 'table-syntax';
+/**
+ * 是否是合并单元格的第一列
+ * @param rowLayout 行布局
+ * @param i 单元格序号
+ * @param oneCol 是否仅有一列
+ */
+const isStartCol = (rowLayout, i, oneCol = false) => {
+    const coords = rowLayout[i];
+    return rowLayout[i - 1] !== coords && (!oneCol || rowLayout[i + 1] !== coords);
+};
+/**
+ * 设置表格格式
+ * @param cells 单元格
+ * @param attr 属性
+ * @param multi 是否对所有单元格设置，或是仅对行首单元格设置
+ */
+const format = (cells, attr = {}, multi = false) => {
+    for (const [token, start] of cells) {
+        if (multi || start) {
+            if (typeof attr === 'string') {
+                token.setSyntax(attr);
+            }
+            else {
+                for (const [k, v] of Object.entries(attr)) {
+                    token.setAttr(k, v);
+                }
+            }
+        }
+    }
+};
+/**
+ * 填补缺失单元格
+ * @param y 行号
+ * @param rowToken 表格行
+ * @param layout 表格布局
+ * @param maxCol 最大列数
+ * @param token 待填充的单元格
+ */
+const fill = (y, rowToken, layout, maxCol, token) => {
+    const rowLayout = layout[y], lastIndex = rowToken.childNodes.findLastIndex(child => child instanceof td_1.TdToken && child.subtype !== 'caption'), pos = lastIndex + 1 || undefined;
+    Parser.run(() => {
+        for (let i = 0; i < maxCol; i++) {
+            if (!rowLayout[i]) {
+                rowToken.insertAt(token.cloneNode(), pos);
+            }
+        }
+    });
+};
+/** @extends {Array<TableCoords[]>} */
+class Layout extends Array {
+    /** 打印表格布局 */
+    print() {
+        const hBorders = new Array(this.length + 1).fill(undefined).map((_, i) => {
+            const prev = this[i - 1] ?? [], next = this[i] ?? [];
+            return new Array(Math.max(prev.length, next.length)).fill(undefined)
+                .map((__, j) => prev[j] !== next[j]);
+        }), vBorders = this.map(cur => new Array(cur.length + 1).fill(undefined).map((_, j) => cur[j - 1] !== cur[j]));
+        let out = '';
+        for (let i = 0; i <= this.length; i++) {
+            const hBorder = hBorders[i].map(Number), vBorderTop = (vBorders[i - 1] ?? []).map(Number), vBorderBottom = (vBorders[i] ?? []).map(Number), 
+            // eslint-disable-next-line no-sparse-arrays
+            border = [' ', , , '┌', , '┐', '─', '┬', , '│', '└', '├', '┘', '┤', '┴', '┼'];
+            for (let j = 0; j <= hBorder.length; j++) {
+                const bit = (vBorderTop[j] << 3) + (vBorderBottom[j] << 0)
+                    + (hBorder[j - 1] << 2) + (hBorder[j] << 1);
+                out += `${border[bit]}${hBorder[j] ? '─' : ' '}`;
+            }
+            out += '\n';
+        }
+        console.log(out.slice(0, -1));
+    }
+}
+exports.Layout = Layout;
+Object.assign(table_1.TableToken.prototype, {
+    /** @implements */
+    getNthCell(coords) {
+        const rawCoords = coords.row === undefined ? this.toRawCoords(coords) : coords;
+        return rawCoords && this.getNthRow(rawCoords.row, false, false)?.getNthCol(rawCoords.column);
+    },
+    /** @implements */
+    getLayout(stop) {
+        const rows = this.getAllRows(), { length } = rows, layout = new Layout(...new Array(length).fill(undefined).map(() => []));
+        for (let i = 0; i < length; i++) {
+            if (i > (stop?.row ?? stop?.y ?? NaN)) {
+                break;
+            }
+            const rowLayout = layout[i];
+            let j = 0, k = 0, last;
+            for (const cell of rows[i].childNodes.slice(2)) {
+                if (cell instanceof td_1.TdToken) {
+                    if (cell.isIndependent()) {
+                        last = cell.subtype !== 'caption';
+                    }
+                    if (last) {
+                        const coords = { row: i, column: j }, { rowspan, colspan } = cell;
+                        j++;
+                        while (rowLayout[k]) {
+                            k++;
+                        }
+                        if (i === stop?.row && j > (stop.column ?? NaN)) {
+                            layout[i][k] = coords;
+                            return layout;
+                        }
+                        for (let y = i; y < Math.min(i + rowspan, length); y++) {
+                            for (let x = k; x < k + colspan; x++) {
+                                layout[y][x] = coords;
+                            }
+                        }
+                        k += colspan;
+                        if (i === stop?.y && k > (stop.x ?? NaN)) {
+                            return layout;
+                        }
+                    }
+                }
+                else if (isRowEnd(cell)) {
+                    break;
+                }
+            }
+        }
+        return layout;
+    },
+    /** @implements */
+    printLayout() {
+        this.getLayout().print();
+    },
+    /** @implements */
+    toRenderedCoords({ row, column }) {
+        const rowLayout = this.getLayout({ row, column })[row], x = rowLayout?.findIndex(coords => cmpCoords(coords, { row, column }) === 0);
+        return rowLayout && (x === -1 ? undefined : { y: row, x: x });
+    },
+    /** @implements */
+    toRawCoords({ x, y }) {
+        const rowLayout = this.getLayout({ x, y })[y], coords = rowLayout?.[x];
+        if (coords) {
+            return { ...coords, start: coords.row === y && rowLayout[x - 1] !== coords };
+        }
+        else if (rowLayout || y > 0) {
+            return x === rowLayout?.length
+                ? { row: y, column: (rowLayout.findLast(({ row }) => row === y)?.column ?? -1) + 1, start: true }
+                : undefined;
+        }
+        return { row: 0, column: 0, start: true };
+    },
+    /** @implements */
+    getFullRow(y) {
+        const rows = this.getAllRows();
+        return new Map(this.getLayout({ y })[y]?.map(({ row, column }) => [rows[row].getNthCol(column), row === y]));
+    },
+    /** @implements */
+    getFullCol(x) {
+        const layout = this.getLayout(), colLayout = layout.map(row => row[x]).filter(Boolean), rows = this.getAllRows();
+        return new Map(colLayout.map(coords => [rows[coords.row].getNthCol(coords.column), layout[coords.row][x - 1] !== coords]));
+    },
+    /** @implements */
+    formatTableRow(y, attr = {}, multiRow = false) {
+        format(this.getFullRow(y), attr, multiRow);
+    },
+    /** @implements */
+    formatTableCol(x, attr = {}, multiCol = false) {
+        format(this.getFullCol(x), attr, multiCol);
+    },
+    /** @implements */
+    fillTableRow(y, inner, subtype = 'td', attr = {}) {
+        const rowToken = this.getNthRow(y), layout = this.getLayout({ y }), maxCol = Math.max(...layout.map(({ length }) => length)), token = (0, td_1.createTd)(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
+        fill(y, rowToken, layout, maxCol, token);
+    },
+    /** @implements */
+    fillTable(inner, subtype = 'td', attr = {}) {
+        const rowTokens = this.getAllRows(), layout = this.getLayout(), maxCol = Math.max(...layout.map(({ length }) => length)), token = (0, td_1.createTd)(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
+        for (let y = 0; y < rowTokens.length; y++) {
+            fill(y, rowTokens[y], layout, maxCol, token);
+        }
+    },
+    /** @implements */
+    insertTableCell(inner, coords, subtype = 'td', attr = {}) {
+        let rawCoords;
+        if (coords.column === undefined) {
+            const { x, y } = coords;
+            rawCoords = this.toRawCoords(coords);
+            if (!rawCoords?.start) {
+                throw new RangeError(`指定的坐标不是单元格起始点：(${x}, ${y})`);
+            }
+        }
+        else {
+            rawCoords = coords;
+        }
+        const rowToken = this.getNthRow(rawCoords.row, true);
+        return rowToken === this
+            ? trBase_1.TrBaseToken.prototype.insertTableCell.call(this, inner, rawCoords, subtype, attr)
+            : rowToken.insertTableCell(inner, rawCoords, subtype, attr);
+    },
+    /** @implements */
+    prependTableRow() {
+        const row = Parser.run(() => new tr_1.TrToken('\n|-', undefined, this.getAttribute('config'))), { childNodes } = this, [, , plain] = childNodes, start = plain?.constructor === src_1.Token ? 3 : 2, tdChildren = childNodes.slice(start), index = tdChildren.findIndex(({ type }) => type !== 'td');
+        this.insertAt(row, index === -1 ? -1 : index + start);
+        Parser.run(() => {
+            for (const cell of tdChildren.slice(0, index === -1 ? undefined : index)) {
+                if (cell.subtype !== 'caption') {
+                    row.insertAt(cell);
+                }
+            }
+        });
+        return row;
+    },
+    /** @implements */
+    insertTableRow(y, attr = {}, inner, subtype = 'td', innerAttr = {}) {
+        let reference = this.getNthRow(y, false, true);
+        const token = Parser.run(() => new tr_1.TrToken('\n|-', undefined, this.getAttribute('config')));
+        for (const [k, v] of Object.entries(attr)) {
+            token.setAttr(k, v);
+        }
+        if (reference?.type === 'table') { // `row === 0`且表格自身是有效行
+            reference = this.prependTableRow();
+        }
+        this.insertBefore(token, reference);
+        if (inner !== undefined) {
+            const td = token.insertTableCell(inner, { row: 0, column: 0 }, subtype, innerAttr), set = new WeakSet(), layout = this.getLayout({ y }), maxCol = Math.max(...layout.map(({ length }) => length)), rowLayout = layout[y];
+            Parser.run(() => {
+                for (let i = 0; i < maxCol; i++) {
+                    const coords = rowLayout[i];
+                    if (!coords) {
+                        token.insertAt(td.cloneNode());
+                    }
+                    else if (!set.has(coords)) {
+                        set.add(coords);
+                        if (coords.row < y) {
+                            this.getNthCell(coords).rowspan++;
+                        }
+                    }
+                }
+            });
+        }
+        return token;
+    },
+    /** @implements */
+    insertTableCol(x, inner, subtype = 'td', attr = {}) {
+        const layout = this.getLayout(), rowLength = layout.map(({ length }) => length), minCol = Math.min(...rowLength);
+        if (x > minCol) {
+            throw new RangeError(`表格第 ${rowLength.indexOf(minCol)} 行仅有 ${minCol} 列！`);
+        }
+        const token = (0, td_1.createTd)(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
+        for (let i = 0; i < layout.length; i++) {
+            const coords = layout[i][x], prevCoords = x === 0 ? true : layout[i][x - 1];
+            if (!prevCoords) {
+                continue;
+            }
+            else if (prevCoords !== coords) {
+                const rowToken = this.getNthRow(i);
+                rowToken.insertBefore(token.cloneNode(), rowToken.getNthCol(coords.column, true));
+            }
+            else if (coords.row === i) {
+                this.getNthCell(coords).colspan++;
+            }
+        }
+    },
+    /** @implements */
+    removeTableRow(y) {
+        const rows = this.getAllRows(), layout = this.getLayout(), rowLayout = layout[y], set = new WeakSet();
+        for (let x = rowLayout.length - 1; x >= 0; x--) {
+            const coords = rowLayout[x];
+            if (set.has(coords)) {
+                continue;
+            }
+            set.add(coords);
+            const token = rows[coords.row].getNthCol(coords.column);
+            let { rowspan } = token;
+            if (rowspan > 1) {
+                token.rowspan = --rowspan;
+                if (coords.row === y) {
+                    const { colspan, subtype } = token, attr = token.getAttrs();
+                    for (let i = y + 1; rowspan && i < rows.length; i++, rowspan--) {
+                        const { column } = layout[i].slice(x + colspan).find(({ row }) => row === i) ?? {};
+                        if (column !== undefined) {
+                            rows[i].insertTableCell('', { row: 0, column }, subtype, { ...attr, rowspan });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        const rowToken = rows[y].type === 'table' ? this.prependTableRow() : rows[y];
+        rowToken.remove();
+        return rowToken;
+    },
+    /** @implements */
+    removeTableCol(x) {
+        for (const [token, start] of this.getFullCol(x)) {
+            const { colspan, lastChild } = token;
+            if (colspan > 1) {
+                token.colspan = colspan - 1;
+                if (start) {
+                    lastChild.replaceChildren();
+                }
+            }
+            else {
+                token.remove();
+            }
+        }
+    },
+    /** @implements */
+    mergeCells(xlim, ylim) {
+        const layout = this.getLayout(), maxCol = Math.max(...layout.map(({ length }) => length)), posXlim = xlim.map(x => x < 0 ? x + maxCol : x), posYlim = ylim.map(y => y < 0 ? y + layout.length : y), [xmin, xmax] = posXlim.sort(), [ymin, ymax] = posYlim.sort(), set = new Set(layout.slice(ymin, ymax).flatMap(rowLayout => rowLayout.slice(xmin, xmax)));
+        if ([...layout[ymin - 1] ?? [], ...layout[ymax] ?? []].some(coords => set.has(coords))
+            || layout.some(rowLayout => set.has(rowLayout[xmin - 1]) || set.has(rowLayout[xmax]))) {
+            throw new RangeError('待合并区域与外侧区域有重叠！');
+        }
+        const corner = layout[ymin][xmin], rows = this.getAllRows(), cornerCell = rows[corner.row].getNthCol(corner.column);
+        cornerCell.rowspan = ymax - ymin;
+        cornerCell.colspan = xmax - xmin;
+        set.delete(corner);
+        for (const token of [...set].map(({ row, column }) => rows[row].getNthCol(column))) {
+            token.remove();
+        }
+        return cornerCell;
+    },
+    /** @implements */
+    split(coords, dirs) {
+        const cell = this.getNthCell(coords), attr = cell.getAttrs(), { subtype } = cell;
+        attr.rowspan ||= 1;
+        attr.colspan ||= 1;
+        for (const dir of dirs) {
+            if (attr[dir] === 1) {
+                dirs.delete(dir);
+            }
+        }
+        if (dirs.size === 0) {
+            return;
+        }
+        let { x, y } = coords;
+        const rawCoords = x === undefined ? coords : this.toRawCoords(coords);
+        if (rawCoords.start === false || x === undefined) {
+            ({ x, y } = this.toRenderedCoords(rawCoords));
+        }
+        const splitting = { rowspan: 1, colspan: 1 };
+        for (const dir of dirs) {
+            cell.setAttr(dir, 1);
+            splitting[dir] = attr[dir];
+            delete attr[dir];
+        }
+        for (let j = y; j < y + splitting.rowspan; j++) {
+            for (let i = x; i < x + splitting.colspan; i++) {
+                if (i > x || j > y) {
+                    try {
+                        this.insertTableCell('', { x: i, y: j }, subtype, attr);
+                    }
+                    catch (e) {
+                        if (e instanceof RangeError && e.message.startsWith('指定的坐标不是单元格起始点：')) {
+                            break;
+                        }
+                        throw e;
+                    }
+                }
+            }
+        }
+    },
+    /** @implements */
+    splitIntoRows(coords) {
+        this.split(coords, new Set(['rowspan']));
+    },
+    /** @implements */
+    splitIntoCols(coords) {
+        this.split(coords, new Set(['colspan']));
+    },
+    /** @implements */
+    splitIntoCells(coords) {
+        this.split(coords, new Set(['rowspan', 'colspan']));
+    },
+    /** @implements */
+    replicateTableRow(row) {
+        let rowToken = this.getNthRow(row);
+        if (rowToken.type === 'table') {
+            rowToken = this.prependTableRow();
+        }
+        const replicated = this.insertBefore(rowToken.cloneNode(), rowToken);
+        for (const [token, start] of this.getFullRow(row)) {
+            if (start) {
+                token.rowspan = 1;
+            }
+            else {
+                token.rowspan++;
+            }
+        }
+        return replicated;
+    },
+    /** @implements */
+    replicateTableCol(x) {
+        const replicated = [];
+        for (const [token, start] of this.getFullCol(x)) {
+            if (start) {
+                const newToken = token.cloneNode();
+                newToken.colspan = 1;
+                token.before(newToken);
+                replicated.push(newToken);
+            }
+            else {
+                token.colspan++;
+            }
+        }
+        return replicated;
+    },
+    /** @implements */
+    moveTableRowBefore(y, before) {
+        const layout = this.getLayout(), 
+        /** @ignore */
+        occupied = (i) => layout[i].map(({ row }, j) => row === i ? j : undefined).filter(j => j !== undefined);
+        try {
+            assert.deepEqual(occupied(y), occupied(before));
+        }
+        catch (e) {
+            if (e instanceof assert.AssertionError) {
+                throw new RangeError(`第 ${y} 行与第 ${before} 行的构造不同，无法移动！`);
+            }
+            throw e;
+        }
+        const rowToken = this.removeTableRow(y);
+        for (const coords of layout[before]) {
+            if (coords.row < before) {
+                this.getNthCell(coords).rowspan++;
+            }
+        }
+        let beforeToken = this.getNthRow(before);
+        if (beforeToken.type === 'table') {
+            beforeToken = this.prependTableRow();
+        }
+        this.insertBefore(rowToken, beforeToken);
+        return rowToken;
+    },
+    /** @implements */
+    moveTableRowAfter(y, after) {
+        const layout = this.getLayout(), afterToken = this.getNthRow(after), cells = afterToken.childNodes.filter(child => child instanceof td_1.TdToken && child.subtype !== 'caption'), 
+        /** @ignore */
+        occupied = (i, oneRow = false) => layout[i].map(({ row, column }, j) => row === i && (!oneRow || cells[column].rowspan === 1) ? j : undefined).filter(j => j !== undefined);
+        try {
+            assert.deepEqual(occupied(y), occupied(after, true));
+        }
+        catch (e) {
+            if (e instanceof assert.AssertionError) {
+                throw new RangeError(`第 ${y} 行与第 ${after} 行的构造不同，无法移动！`);
+            }
+            throw e;
+        }
+        const rowToken = this.removeTableRow(y);
+        for (const coords of layout[after]) {
+            if (coords.row < after) {
+                this.getNthCell(coords).rowspan++;
+            }
+            else {
+                const cell = cells[coords.column], { rowspan } = cell;
+                if (rowspan > 1) {
+                    cell.rowspan = rowspan + 1;
+                }
+            }
+        }
+        if (afterToken === this) {
+            const index = this.childNodes.slice(2).findIndex(isRowEnd);
+            this.insertAt(rowToken, index + 2);
+        }
+        else {
+            this.insertBefore(rowToken, afterToken);
+        }
+        return rowToken;
+    },
+    /** @implements */
+    moveCol(x, reference, after = false) {
+        const layout = this.getLayout();
+        if (layout.some(rowLayout => isStartCol(rowLayout, x) !== isStartCol(rowLayout, reference, after))) {
+            throw new RangeError(`第 ${x} 列与第 ${reference} 列的构造不同，无法移动！`);
+        }
+        const setX = new WeakSet(), setRef = new WeakSet(), rows = this.getAllRows();
+        for (let i = 0; i < layout.length; i++) {
+            const rowLayout = layout[i], coords = rowLayout[x], refCoords = rowLayout[reference], start = isStartCol(rowLayout, x);
+            if (refCoords && !start && !setRef.has(refCoords)) {
+                setRef.add(refCoords);
+                rows[refCoords.row].getNthCol(refCoords.column).colspan++;
+            }
+            if (coords && !setX.has(coords)) {
+                setX.add(coords);
+                const rowToken = rows[i];
+                let token = rowToken.getNthCol(coords.column);
+                const { colspan } = token;
+                if (colspan > 1) {
+                    token.colspan = colspan - 1;
+                    if (start) {
+                        const original = token;
+                        token = token.cloneNode();
+                        original.lastChild.replaceChildren();
+                        token.colspan = 1;
+                    }
+                }
+                if (start) {
+                    const col = rowLayout.slice(reference + Number(after)).find(({ row }) => row === i)?.column;
+                    rowToken.insertBefore(token, col === undefined ? rowToken.childNodes.slice(2).find(isRowEnd) : rowToken.getNthCol(col));
+                }
+            }
+        }
+    },
+    /** @implements */
+    moveTableColBefore(x, before) {
+        this.moveCol(x, before);
+    },
+    /** @implements */
+    moveTableColAfter(x, after) {
+        this.moveCol(x, after, true);
+    },
+});

package/dist/bin/toc.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const { argv: [, , filename] } = process;
+if (!filename) {
+    throw new RangeError('请指定文档文件！');
+}
+const fullpath = path.join(__dirname, '..', '..', 'wiki', `${filename}.md`);
+if (!fs.existsSync(fullpath)) {
+    throw new RangeError(`文档 ${filename}.md 不存在！`);
+}
+const content = fs.readFileSync(fullpath, 'utf8');
+if (/^- \[[^\]]+\]\(#[^)]+\)$/mu.test(content)) {
+    throw new Error(`文档 ${filename}.md 中已包含目录！`);
+}
+const toc = content.split('\n').filter(line => line.startsWith('#')).map(line => line.replace(/^(#+)\s+(\S.*)$/u, (_, { length }, title) => `${'\t'.repeat(length - 1)}- [${title}](#${title.toLowerCase().replaceAll(' ', '-').replaceAll('.', '')})`)).join('\n');
+fs.writeFileSync(fullpath, `<details>\n\t<summary>目录</summary>\n\n${toc}\n</details>\n\n${content}`);

package/dist/index.d.ts

@@ -27,15 +27,12 @@ export interface LintError {
     excerpt: string;
 }
 declare interface Parser {
-    /** @browser */
     config: string | Config;
-    /** @browser */
     i18n?: string | Record<string, string>;
     conversionTable: Map<string, string>;
     redirects: Map<string, string>;
     /**
      * 规范化页面标题
-     * @browser
      * @param title 标题（含或不含命名空间前缀）
      * @param defaultNs 命名空间
      * @param include 是否嵌入
@@ -46,7 +43,6 @@ declare interface Parser {
     normalizeTitle(title: string, defaultNs?: number, include?: boolean, config?: Config, halfParsed?: boolean, decode?: boolean, selfLink?: boolean): Title;
     /**
      * 解析wikitext
-     * @browser
      * @param include 是否嵌入
      * @param maxStage 最大解析层级
      */