docxmlater 10.4.0 → 11.0.4

package/dist/esm/elements/Table.js

@@ -0,0 +1,1456 @@
+import { TableRow } from './TableRow.js';
+import { TableCell } from './TableCell.js';
+import { Revision } from './Revision.js';
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+import { deepClone } from '../utils/deepClone.js';
+import { TableGridChange } from './TableGridChange.js';
+import { buildShadingAttributes, } from './CommonTypes.js';
+function buildTblLookAttributes(hex) {
+    const raw = typeof hex === 'number' ? hex.toString(16) : String(hex ?? '');
+    const normalized = raw.toUpperCase().padStart(4, '0');
+    const value = parseInt(normalized, 16) || 0;
+    return {
+        'w:val': normalized,
+        'w:firstRow': (value & 0x0020) !== 0 ? '1' : '0',
+        'w:lastRow': (value & 0x0040) !== 0 ? '1' : '0',
+        'w:firstColumn': (value & 0x0080) !== 0 ? '1' : '0',
+        'w:lastColumn': (value & 0x0100) !== 0 ? '1' : '0',
+        'w:noHBand': (value & 0x0200) !== 0 ? '1' : '0',
+        'w:noVBand': (value & 0x0400) !== 0 ? '1' : '0',
+    };
+}
+export class Table {
+    rows = [];
+    formatting;
+    _stylesManager;
+    trackingContext;
+    tblPrChange;
+    tblGridChange;
+    constructor(rows, columns, formatting = {}) {
+        if (formatting.width === undefined) {
+            formatting.width = 9360;
+        }
+        this.formatting = formatting;
+        if (rows !== undefined && rows > 0 && columns !== undefined && columns > 0) {
+            for (let i = 0; i < rows; i++) {
+                const row = new TableRow(columns);
+                row._setParentTable(this);
+                this.rows.push(row);
+            }
+        }
+    }
+    _setTrackingContext(context) {
+        this.trackingContext = context;
+    }
+    getTblPrChange() {
+        return this.tblPrChange;
+    }
+    setTblPrChange(change) {
+        this.tblPrChange = change;
+    }
+    clearTblPrChange() {
+        this.tblPrChange = undefined;
+    }
+    getTblGridChange() {
+        return this.tblGridChange;
+    }
+    setTblGridChange(change) {
+        this.tblGridChange = change;
+    }
+    addRow(row) {
+        this.rows.push(row);
+        row._setParentTable(this);
+        return this;
+    }
+    addRowFromArray(cells) {
+        const row = new TableRow();
+        for (const text of cells) {
+            row.createCell(text || undefined);
+        }
+        this.rows.push(row);
+        row._setParentTable(this);
+        return row;
+    }
+    addSummaryRow(options) {
+        const label = options?.label ?? 'Total';
+        const startRow = options?.startRow ?? 1;
+        const colCount = this.getColumnCount();
+        const defaultCompute = (values) => {
+            const nums = values.map((v) => parseFloat(v)).filter((n) => !isNaN(n));
+            if (nums.length === 0)
+                return '';
+            return String(nums.reduce((a, b) => a + b, 0));
+        };
+        const compute = options?.compute ?? defaultCompute;
+        const cells = [];
+        for (let c = 0; c < colCount; c++) {
+            if (c === 0) {
+                cells.push(label);
+                continue;
+            }
+            const colTexts = this.getColumnTexts(c);
+            const dataValues = colTexts.slice(startRow);
+            cells.push(compute(dataValues, c));
+        }
+        return this.addRowFromArray(cells);
+    }
+    createRow(cellCount, formatting) {
+        const row = new TableRow(cellCount, formatting);
+        this.rows.push(row);
+        row._setParentTable(this);
+        return row;
+    }
+    getRow(index) {
+        return this.rows[index];
+    }
+    getRows() {
+        return [...this.rows];
+    }
+    getFirstParagraph() {
+        if (this.rows.length === 0)
+            return null;
+        const firstRow = this.rows[0];
+        if (!firstRow)
+            return null;
+        const cells = firstRow.getCells();
+        if (cells.length === 0)
+            return null;
+        const paras = cells[0]?.getParagraphs();
+        return paras && paras.length > 0 ? (paras[0] ?? null) : null;
+    }
+    getLastParagraph() {
+        for (let r = this.rows.length - 1; r >= 0; r--) {
+            const row = this.rows[r];
+            if (!row)
+                continue;
+            const cells = row.getCells();
+            for (let c = cells.length - 1; c >= 0; c--) {
+                const cell = cells[c];
+                if (!cell)
+                    continue;
+                const paras = cell.getParagraphs();
+                if (paras.length > 0) {
+                    return paras[paras.length - 1] ?? null;
+                }
+            }
+        }
+        return null;
+    }
+    getRowCount() {
+        return this.rows.length;
+    }
+    getCell(rowIndex, columnIndex) {
+        const row = this.getRow(rowIndex);
+        return row ? row.getCell(columnIndex) : undefined;
+    }
+    setCell(rowIndex, colIndex, text) {
+        const cell = this.getCell(rowIndex, colIndex);
+        if (!cell)
+            return this;
+        const paragraphs = cell.getParagraphs();
+        if (paragraphs.length > 0) {
+            paragraphs[0].setText(text);
+            for (let p = paragraphs.length - 1; p >= 1; p--) {
+                cell.removeParagraph(p);
+            }
+        }
+        else {
+            cell.createParagraph(text);
+        }
+        return this;
+    }
+    setWidth(twips) {
+        const prev = this.formatting.width;
+        this.formatting.width = twips;
+        if (this.trackingContext?.isEnabled() && prev !== twips) {
+            this.trackingContext.trackTableChange(this, 'width', prev, twips);
+        }
+        return this;
+    }
+    setAlignment(alignment) {
+        const prev = this.formatting.alignment;
+        this.formatting.alignment = alignment;
+        if (this.trackingContext?.isEnabled() && prev !== alignment) {
+            this.trackingContext.trackTableChange(this, 'alignment', prev, alignment);
+        }
+        return this;
+    }
+    setLayout(layout) {
+        const prev = this.formatting.layout;
+        this.formatting.layout = layout === 'auto' ? 'autofit' : layout;
+        if (this.trackingContext?.isEnabled() && prev !== this.formatting.layout) {
+            this.trackingContext.trackTableChange(this, 'layout', prev, this.formatting.layout);
+        }
+        return this;
+    }
+    setBorders(borders, options) {
+        const prev = this.formatting.borders;
+        this.formatting.borders = borders;
+        if (this.trackingContext?.isEnabled() && prev !== borders) {
+            this.trackingContext.trackTableChange(this, 'borders', prev, borders);
+        }
+        if (options?.applyToCells !== false) {
+            const cellBorders = {
+                top: borders.top,
+                bottom: borders.bottom,
+                left: borders.left,
+                right: borders.right,
+            };
+            for (const row of this.rows) {
+                const exceptions = row.getTablePropertyExceptions();
+                if (exceptions?.borders) {
+                    row.setTablePropertyExceptions({
+                        ...exceptions,
+                        borders: borders,
+                    });
+                }
+                for (const cell of row.getCells()) {
+                    cell.setBorders(cellBorders);
+                }
+            }
+        }
+        return this;
+    }
+    setAllBorders(border, options) {
+        return this.setBorders({
+            top: border,
+            bottom: border,
+            left: border,
+            right: border,
+            insideH: border,
+            insideV: border,
+        }, options);
+    }
+    setFirstRowShading(color) {
+        if (this.rows.length > 0) {
+            const firstRow = this.rows[0];
+            if (firstRow) {
+                for (const cell of firstRow.getCells()) {
+                    cell.setShading({ fill: color });
+                }
+            }
+        }
+        return this;
+    }
+    setFirstRowFormatting(options) {
+        if (this.rows.length === 0) {
+            return this;
+        }
+        const firstRow = this.rows[0];
+        if (!firstRow) {
+            return this;
+        }
+        for (const cell of firstRow.getCells()) {
+            const paragraphs = cell.getParagraphs();
+            if (options.shading) {
+                cell.setShading({ fill: options.shading });
+            }
+            for (const para of paragraphs) {
+                if (options.alignment) {
+                    para.setAlignment(options.alignment);
+                }
+                if (options.spacingBefore !== undefined) {
+                    para.setSpaceBefore(options.spacingBefore);
+                }
+                if (options.spacingAfter !== undefined) {
+                    para.setSpaceAfter(options.spacingAfter);
+                }
+                const runs = para.getRuns();
+                for (const run of runs) {
+                    if (options.bold !== undefined) {
+                        run.setBold(options.bold);
+                    }
+                    if (options.italic !== undefined) {
+                        run.setItalic(options.italic);
+                    }
+                    if (options.underline !== undefined) {
+                        run.setUnderline(options.underline);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    setCellSpacing(twips) {
+        const prev = this.formatting.cellSpacing;
+        this.formatting.cellSpacing = twips;
+        if (this.trackingContext?.isEnabled() && prev !== twips) {
+            this.trackingContext.trackTableChange(this, 'cellSpacing', prev, twips);
+        }
+        return this;
+    }
+    setIndent(twips) {
+        const prev = this.formatting.indent;
+        this.formatting.indent = twips;
+        if (this.trackingContext?.isEnabled() && prev !== twips) {
+            this.trackingContext.trackTableChange(this, 'indent', prev, twips);
+        }
+        return this;
+    }
+    setIndentType(type) {
+        const prev = this.formatting.indentType;
+        this.formatting.indentType = type;
+        if (this.trackingContext?.isEnabled() && prev !== type) {
+            this.trackingContext.trackTableChange(this, 'indentType', prev, type);
+        }
+        return this;
+    }
+    getIndentType() {
+        return this.formatting.indentType;
+    }
+    setStyle(style) {
+        const prev = this.formatting.style;
+        this.formatting.style = style;
+        if (this.trackingContext?.isEnabled() && prev !== style) {
+            this.trackingContext.trackTableChange(this, 'style', prev, style);
+        }
+        return this;
+    }
+    setTblLook(tblLook) {
+        const prev = this.formatting.tblLook;
+        this.formatting.tblLook = tblLook;
+        if (this.trackingContext?.isEnabled() && prev !== tblLook) {
+            this.trackingContext.trackTableChange(this, 'tblLook', prev, tblLook);
+        }
+        return this;
+    }
+    setStyleRowBandSize(size) {
+        const prev = this.formatting.tblStyleRowBandSize;
+        this.formatting.tblStyleRowBandSize = size;
+        if (this.trackingContext?.isEnabled() && prev !== size) {
+            this.trackingContext.trackTableChange(this, 'tblStyleRowBandSize', prev, size);
+        }
+        return this;
+    }
+    setStyleColBandSize(size) {
+        const prev = this.formatting.tblStyleColBandSize;
+        this.formatting.tblStyleColBandSize = size;
+        if (this.trackingContext?.isEnabled() && prev !== size) {
+            this.trackingContext.trackTableChange(this, 'tblStyleColBandSize', prev, size);
+        }
+        return this;
+    }
+    getTblLookFlags() {
+        const hex = this.formatting.tblLook || '0000';
+        const value = parseInt(hex, 16) || 0;
+        return {
+            firstRow: (value & 0x0020) !== 0,
+            lastRow: (value & 0x0040) !== 0,
+            firstColumn: (value & 0x0080) !== 0,
+            lastColumn: (value & 0x0100) !== 0,
+            noHBand: (value & 0x0200) !== 0,
+            noVBand: (value & 0x0400) !== 0,
+        };
+    }
+    applyConditionalFormatting(rules) {
+        const rows = this.getRows();
+        if (rules.headerRow && rows.length > 0) {
+            const headerFormatting = rules.headerRow === true
+                ? { shading: { fill: '4472C4' } }
+                : rules.headerRow;
+            const headerRow = rows[0];
+            if (headerRow) {
+                for (const cell of headerRow.getCells()) {
+                    this.applyCellFormatting(cell, headerFormatting);
+                }
+            }
+        }
+        if (rules.alternatingRows) {
+            rows.forEach((row, index) => {
+                const isEven = index % 2 === 0;
+                const formatting = isEven ? rules.alternatingRows?.even : rules.alternatingRows?.odd;
+                if (formatting) {
+                    for (const cell of row.getCells()) {
+                        this.applyCellFormatting(cell, formatting);
+                    }
+                }
+            });
+        }
+        if (rules.contentRules && rules.contentRules.length > 0) {
+            rows.forEach((row, rowIndex) => {
+                row.getCells().forEach((cell, colIndex) => {
+                    const cellText = cell
+                        .getParagraphs()
+                        .map((p) => p.getText())
+                        .join('');
+                    for (const rule of rules.contentRules) {
+                        if (rule.condition(cellText, rowIndex, colIndex)) {
+                            this.applyCellFormatting(cell, rule.formatting);
+                        }
+                    }
+                });
+            });
+        }
+        return this;
+    }
+    applyCellFormatting(cell, formatting) {
+        if (formatting.shading) {
+            cell.setShading(formatting.shading);
+        }
+        if (formatting.borders) {
+            cell.setBorders(formatting.borders);
+        }
+        if (formatting.textDirection) {
+            cell.setTextDirection(formatting.textDirection);
+        }
+        if (formatting.verticalAlignment) {
+            cell.setVerticalAlignment(formatting.verticalAlignment);
+        }
+        if (formatting.width !== undefined) {
+            cell.setWidth(formatting.width);
+        }
+        if (formatting.margins) {
+            cell.setMargins(formatting.margins);
+        }
+    }
+    setPosition(position) {
+        const prev = this.formatting.position;
+        this.formatting.position = position;
+        if (this.trackingContext?.isEnabled() && prev !== position) {
+            this.trackingContext.trackTableChange(this, 'position', prev, position);
+        }
+        return this;
+    }
+    setOverlap(overlap) {
+        const prev = this.formatting.overlap;
+        this.formatting.overlap = overlap;
+        if (this.trackingContext?.isEnabled() && prev !== overlap) {
+            this.trackingContext.trackTableChange(this, 'overlap', prev, overlap);
+        }
+        return this;
+    }
+    setBidiVisual(bidi) {
+        const prev = this.formatting.bidiVisual;
+        this.formatting.bidiVisual = bidi;
+        if (this.trackingContext?.isEnabled() && prev !== bidi) {
+            this.trackingContext.trackTableChange(this, 'bidiVisual', prev, bidi);
+        }
+        return this;
+    }
+    setTableGrid(widths) {
+        const prev = this.formatting.tableGrid;
+        this.formatting.tableGrid = widths;
+        if (this.trackingContext?.isEnabled() && prev) {
+            if (!this.tblGridChange) {
+                const revisionManager = this.trackingContext.getRevisionManager();
+                this.tblGridChange = TableGridChange.create(revisionManager.consumeNextId(), prev.map((w) => ({ width: w })), this.trackingContext.getAuthor(), new Date());
+            }
+        }
+        return this;
+    }
+    setCaption(caption) {
+        const prev = this.formatting.caption;
+        this.formatting.caption = caption;
+        if (this.trackingContext?.isEnabled() && prev !== caption) {
+            this.trackingContext.trackTableChange(this, 'caption', prev, caption);
+        }
+        return this;
+    }
+    setDescription(description) {
+        const prev = this.formatting.description;
+        this.formatting.description = description;
+        if (this.trackingContext?.isEnabled() && prev !== description) {
+            this.trackingContext.trackTableChange(this, 'description', prev, description);
+        }
+        return this;
+    }
+    setShading(shading) {
+        const prev = this.formatting.shading;
+        this.formatting.shading = shading;
+        if (this.trackingContext?.isEnabled() && prev !== shading) {
+            this.trackingContext.trackTableChange(this, 'shading', prev, shading);
+        }
+        return this;
+    }
+    getShading() {
+        return this.formatting.shading;
+    }
+    setWidthType(type) {
+        const prev = this.formatting.widthType;
+        this.formatting.widthType = type;
+        if (this.trackingContext?.isEnabled() && prev !== type) {
+            this.trackingContext.trackTableChange(this, 'widthType', prev, type);
+        }
+        return this;
+    }
+    setCellSpacingType(type) {
+        const prev = this.formatting.cellSpacingType;
+        this.formatting.cellSpacingType = type;
+        if (this.trackingContext?.isEnabled() && prev !== type) {
+            this.trackingContext.trackTableChange(this, 'cellSpacingType', prev, type);
+        }
+        return this;
+    }
+    getFormatting() {
+        return { ...this.formatting };
+    }
+    getWidth() {
+        return this.formatting.width;
+    }
+    getWidthType() {
+        return this.formatting.widthType;
+    }
+    getAlignment() {
+        return this.formatting.alignment;
+    }
+    getLayout() {
+        return this.formatting.layout;
+    }
+    getIndent() {
+        return this.formatting.indent;
+    }
+    getBorders() {
+        return this.formatting.borders;
+    }
+    getColumnWidths() {
+        return [...(this.formatting.tableGrid || [])];
+    }
+    getCellSpacing() {
+        return this.formatting.cellSpacing;
+    }
+    getCellMargins() {
+        return this.formatting.cellMargins;
+    }
+    setCellMargins(margins) {
+        const prev = this.formatting.cellMargins;
+        this.formatting.cellMargins = margins;
+        if (this.trackingContext?.isEnabled() && prev !== margins) {
+            this.trackingContext.trackTableChange(this, 'cellMargins', prev, margins);
+        }
+        return this;
+    }
+    getStyle() {
+        return this.formatting.style;
+    }
+    getTblLook() {
+        return this.formatting.tblLook;
+    }
+    getPosition() {
+        return this.formatting.position ? { ...this.formatting.position } : undefined;
+    }
+    getOverlap() {
+        return this.formatting.overlap;
+    }
+    getBidiVisual() {
+        return this.formatting.bidiVisual;
+    }
+    getTableGrid() {
+        return this.formatting.tableGrid ? [...this.formatting.tableGrid] : undefined;
+    }
+    getCaption() {
+        return this.formatting.caption;
+    }
+    getDescription() {
+        return this.formatting.description;
+    }
+    getCellSpacingType() {
+        return this.formatting.cellSpacingType;
+    }
+    hasRows() {
+        return this.rows.length > 0;
+    }
+    isFloating() {
+        return this.formatting.position !== undefined;
+    }
+    hasStyle() {
+        return this.formatting.style !== undefined && this.formatting.style !== '';
+    }
+    _setStylesManager(manager) {
+        this._stylesManager = manager;
+        for (const row of this.rows) {
+            for (const cell of row.getCells()) {
+                for (const para of cell.getParagraphs()) {
+                    para._setStylesManager(manager);
+                }
+            }
+        }
+    }
+    _getStylesManager() {
+        return this._stylesManager;
+    }
+    toXML() {
+        const tblPrChildren = [];
+        if (this.formatting.style) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblStyle', { 'w:val': this.formatting.style }));
+        }
+        if (this.formatting.position) {
+            const pos = this.formatting.position;
+            const posAttrs = {};
+            if (pos.x !== undefined)
+                posAttrs['w:tblpX'] = pos.x;
+            if (pos.y !== undefined)
+                posAttrs['w:tblpY'] = pos.y;
+            if (pos.horizontalAnchor)
+                posAttrs['w:horzAnchor'] = pos.horizontalAnchor;
+            if (pos.verticalAnchor)
+                posAttrs['w:vertAnchor'] = pos.verticalAnchor;
+            if (pos.horizontalAlignment)
+                posAttrs['w:tblpXSpec'] = pos.horizontalAlignment;
+            if (pos.verticalAlignment)
+                posAttrs['w:tblpYSpec'] = pos.verticalAlignment;
+            if (pos.leftFromText !== undefined)
+                posAttrs['w:leftFromText'] = pos.leftFromText;
+            if (pos.rightFromText !== undefined)
+                posAttrs['w:rightFromText'] = pos.rightFromText;
+            if (pos.topFromText !== undefined)
+                posAttrs['w:topFromText'] = pos.topFromText;
+            if (pos.bottomFromText !== undefined)
+                posAttrs['w:bottomFromText'] = pos.bottomFromText;
+            if (Object.keys(posAttrs).length > 0) {
+                tblPrChildren.push(XMLBuilder.wSelf('tblpPr', posAttrs));
+            }
+        }
+        if (this.formatting.overlap !== undefined) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblOverlap', {
+                'w:val': this.formatting.overlap ? 'overlap' : 'never',
+            }));
+        }
+        if (this.formatting.bidiVisual !== undefined) {
+            if (this.formatting.bidiVisual) {
+                tblPrChildren.push(XMLBuilder.wSelf('bidiVisual'));
+            }
+            else {
+                tblPrChildren.push(XMLBuilder.wSelf('bidiVisual', { 'w:val': 'off' }));
+            }
+        }
+        if (this.formatting.width !== undefined) {
+            const widthType = this.formatting.widthType || 'dxa';
+            tblPrChildren.push(XMLBuilder.wSelf('tblW', {
+                'w:w': this.formatting.width,
+                'w:type': widthType,
+            }));
+        }
+        if (this.formatting.alignment) {
+            tblPrChildren.push(XMLBuilder.wSelf('jc', { 'w:val': this.formatting.alignment }));
+        }
+        if (this.formatting.cellSpacing !== undefined) {
+            const cellSpacingType = this.formatting.cellSpacingType || 'dxa';
+            tblPrChildren.push(XMLBuilder.wSelf('tblCellSpacing', {
+                'w:w': this.formatting.cellSpacing,
+                'w:type': cellSpacingType,
+            }));
+        }
+        if (this.formatting.indent !== undefined) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblInd', {
+                'w:w': this.formatting.indent,
+                'w:type': this.formatting.indentType || 'dxa',
+            }));
+        }
+        if (this.formatting.borders) {
+            const borderElements = [];
+            const borders = this.formatting.borders;
+            if (borders.top) {
+                borderElements.push(XMLBuilder.createBorder('top', borders.top));
+            }
+            if (borders.left) {
+                borderElements.push(XMLBuilder.createBorder('left', borders.left));
+            }
+            if (borders.bottom) {
+                borderElements.push(XMLBuilder.createBorder('bottom', borders.bottom));
+            }
+            if (borders.right) {
+                borderElements.push(XMLBuilder.createBorder('right', borders.right));
+            }
+            if (borders.insideH) {
+                borderElements.push(XMLBuilder.createBorder('insideH', borders.insideH));
+            }
+            if (borders.insideV) {
+                borderElements.push(XMLBuilder.createBorder('insideV', borders.insideV));
+            }
+            if (borderElements.length > 0) {
+                tblPrChildren.push(XMLBuilder.w('tblBorders', undefined, borderElements));
+            }
+        }
+        if (this.formatting.shading) {
+            const shdAttrs = buildShadingAttributes(this.formatting.shading);
+            if (Object.keys(shdAttrs).length > 0) {
+                tblPrChildren.push(XMLBuilder.wSelf('shd', shdAttrs));
+            }
+        }
+        if (this.formatting.layout) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblLayout', { 'w:type': this.formatting.layout }));
+        }
+        if (this.formatting.cellMargins) {
+            const marginElements = [];
+            if (this.formatting.cellMargins.top !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('top', {
+                    'w:w': this.formatting.cellMargins.top,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (this.formatting.cellMargins.left !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('left', {
+                    'w:w': this.formatting.cellMargins.left,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (this.formatting.cellMargins.bottom !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('bottom', {
+                    'w:w': this.formatting.cellMargins.bottom,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (this.formatting.cellMargins.right !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('right', {
+                    'w:w': this.formatting.cellMargins.right,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (marginElements.length > 0) {
+                tblPrChildren.push(XMLBuilder.w('tblCellMar', undefined, marginElements));
+            }
+        }
+        if (this.formatting.tblLook) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblLook', buildTblLookAttributes(this.formatting.tblLook)));
+        }
+        if (this.formatting.caption) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblCaption', { 'w:val': this.formatting.caption }));
+        }
+        if (this.formatting.description) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblDescription', {
+                'w:val': this.formatting.description,
+            }));
+        }
+        if (this.tblPrChange) {
+            const changeAttrs = {
+                'w:id': this.tblPrChange.id,
+                'w:author': this.tblPrChange.author,
+                'w:date': this.tblPrChange.date,
+            };
+            const prevTblPrChildren = [];
+            const prev = this.tblPrChange.previousProperties;
+            if (prev) {
+                if (prev.style) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblStyle', { 'w:val': prev.style }));
+                }
+                if (prev.position) {
+                    const posAttrs = {};
+                    const pos = prev.position;
+                    if (pos.x !== undefined)
+                        posAttrs['w:tblpX'] = pos.x;
+                    if (pos.y !== undefined)
+                        posAttrs['w:tblpY'] = pos.y;
+                    if (pos.horizontalAnchor)
+                        posAttrs['w:horzAnchor'] = pos.horizontalAnchor;
+                    if (pos.verticalAnchor)
+                        posAttrs['w:vertAnchor'] = pos.verticalAnchor;
+                    if (pos.leftFromText !== undefined)
+                        posAttrs['w:leftFromText'] = pos.leftFromText;
+                    if (pos.rightFromText !== undefined)
+                        posAttrs['w:rightFromText'] = pos.rightFromText;
+                    if (pos.topFromText !== undefined)
+                        posAttrs['w:topFromText'] = pos.topFromText;
+                    if (pos.bottomFromText !== undefined)
+                        posAttrs['w:bottomFromText'] = pos.bottomFromText;
+                    if (Object.keys(posAttrs).length > 0) {
+                        prevTblPrChildren.push(XMLBuilder.wSelf('tblpPr', posAttrs));
+                    }
+                }
+                if (prev.overlap) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblOverlap', { 'w:val': prev.overlap }));
+                }
+                if (prev.bidiVisual !== undefined) {
+                    if (prev.bidiVisual) {
+                        prevTblPrChildren.push(XMLBuilder.wSelf('bidiVisual'));
+                    }
+                    else {
+                        prevTblPrChildren.push(XMLBuilder.wSelf('bidiVisual', { 'w:val': 'off' }));
+                    }
+                }
+                if (prev.tblStyleRowBandSize !== undefined) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblStyleRowBandSize', { 'w:val': prev.tblStyleRowBandSize }));
+                }
+                if (prev.tblStyleColBandSize !== undefined) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblStyleColBandSize', { 'w:val': prev.tblStyleColBandSize }));
+                }
+                if (prev.width !== undefined) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblW', {
+                        'w:w': prev.width,
+                        'w:type': prev.widthType || 'dxa',
+                    }));
+                }
+                if (prev.alignment) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('jc', { 'w:val': prev.alignment }));
+                }
+                if (prev.cellSpacing !== undefined) {
+                    const csAttrs = {
+                        'w:w': prev.cellSpacing,
+                        'w:type': prev.cellSpacingType || 'dxa',
+                    };
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblCellSpacing', csAttrs));
+                }
+                if (prev.indent !== undefined) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblInd', { 'w:w': prev.indent, 'w:type': prev.indentType || 'dxa' }));
+                }
+                if (prev.borders) {
+                    const borderChildren = [];
+                    const bNames = ['top', 'left', 'bottom', 'right', 'insideH', 'insideV'];
+                    for (const name of bNames) {
+                        const b = prev.borders[name];
+                        if (b) {
+                            const bAttrs = { 'w:val': b.style ?? 'nil' };
+                            if (b.size !== undefined)
+                                bAttrs['w:sz'] = b.size;
+                            if (b.color)
+                                bAttrs['w:color'] = b.color;
+                            const bx = b;
+                            if (bx.space !== undefined)
+                                bAttrs['w:space'] = bx.space;
+                            if (bx.themeColor)
+                                bAttrs['w:themeColor'] = bx.themeColor;
+                            if (bx.themeTint)
+                                bAttrs['w:themeTint'] = bx.themeTint;
+                            if (bx.themeShade)
+                                bAttrs['w:themeShade'] = bx.themeShade;
+                            if (bx.shadow !== undefined)
+                                bAttrs['w:shadow'] = bx.shadow ? '1' : '0';
+                            if (bx.frame !== undefined)
+                                bAttrs['w:frame'] = bx.frame ? '1' : '0';
+                            borderChildren.push(XMLBuilder.wSelf(name, bAttrs));
+                        }
+                    }
+                    if (borderChildren.length > 0) {
+                        prevTblPrChildren.push(XMLBuilder.w('tblBorders', undefined, borderChildren));
+                    }
+                }
+                if (prev.shading) {
+                    const shadingAttrs = buildShadingAttributes(prev.shading);
+                    if (Object.keys(shadingAttrs).length > 0) {
+                        prevTblPrChildren.push(XMLBuilder.wSelf('shd', shadingAttrs));
+                    }
+                }
+                if (prev.layout) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblLayout', { 'w:type': prev.layout }));
+                }
+                if (prev.cellMargins) {
+                    const cmChildren = [];
+                    if (prev.cellMargins.top !== undefined) {
+                        cmChildren.push(XMLBuilder.wSelf('top', { 'w:w': prev.cellMargins.top, 'w:type': 'dxa' }));
+                    }
+                    if (prev.cellMargins.left !== undefined) {
+                        cmChildren.push(XMLBuilder.wSelf('left', { 'w:w': prev.cellMargins.left, 'w:type': 'dxa' }));
+                    }
+                    if (prev.cellMargins.bottom !== undefined) {
+                        cmChildren.push(XMLBuilder.wSelf('bottom', { 'w:w': prev.cellMargins.bottom, 'w:type': 'dxa' }));
+                    }
+                    if (prev.cellMargins.right !== undefined) {
+                        cmChildren.push(XMLBuilder.wSelf('right', { 'w:w': prev.cellMargins.right, 'w:type': 'dxa' }));
+                    }
+                    if (cmChildren.length > 0) {
+                        prevTblPrChildren.push(XMLBuilder.w('tblCellMar', undefined, cmChildren));
+                    }
+                }
+                if (prev.tblLook) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblLook', buildTblLookAttributes(prev.tblLook)));
+                }
+                if (prev.caption) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblCaption', { 'w:val': prev.caption }));
+                }
+                if (prev.description) {
+                    prevTblPrChildren.push(XMLBuilder.wSelf('tblDescription', { 'w:val': prev.description }));
+                }
+            }
+            const prevTblPr = XMLBuilder.w('tblPr', undefined, prevTblPrChildren);
+            tblPrChildren.push(XMLBuilder.w('tblPrChange', changeAttrs, [prevTblPr]));
+        }
+        const tableChildren = [];
+        tableChildren.push(XMLBuilder.w('tblPr', undefined, tblPrChildren));
+        const gridWidths = this.formatting.tableGrid;
+        const maxColumns = gridWidths
+            ? gridWidths.length
+            : Math.max(...this.rows.map((row) => row.getTotalGridSpan()), 0);
+        const gridColumnCount = maxColumns > 0 ? maxColumns : 1;
+        const tblGridChildren = [];
+        for (let i = 0; i < gridColumnCount; i++) {
+            if (gridWidths?.[i] !== undefined) {
+                tblGridChildren.push(XMLBuilder.wSelf('gridCol', { 'w:w': gridWidths[i] }));
+            }
+            else {
+                tblGridChildren.push(XMLBuilder.wSelf('gridCol', { 'w:w': 2880 }));
+            }
+        }
+        if (this.tblGridChange) {
+            tblGridChildren.push(this.tblGridChange.toXML());
+        }
+        tableChildren.push(XMLBuilder.w('tblGrid', undefined, tblGridChildren));
+        for (const row of this.rows) {
+            tableChildren.push(row.toXML());
+        }
+        return XMLBuilder.w('tbl', undefined, tableChildren);
+    }
+    removeRow(index) {
+        if (index >= 0 && index < this.rows.length) {
+            if (this.rows.length <= 1 && !this.trackingContext?.isEnabled()) {
+                return false;
+            }
+            if (this.trackingContext?.isEnabled()) {
+                const author = this.trackingContext.getAuthor();
+                const row = this.rows[index];
+                for (const cell of row.getCells()) {
+                    const cellDelRevision = Revision.createTableCellDelete(author, []);
+                    cell.setCellRevision(cellDelRevision);
+                    for (const para of cell.getParagraphs()) {
+                        const runs = para.getRuns();
+                        if (runs.length > 0) {
+                            const deletion = Revision.createDeletion(author, runs);
+                            para.addRevision(deletion);
+                        }
+                    }
+                }
+                return true;
+            }
+            this.rows.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    _removeRowAtIndex(index) {
+        if (index < 0 || index >= this.rows.length)
+            return false;
+        this.rows.splice(index, 1);
+        return true;
+    }
+    insertRow(index, row) {
+        if (index < 0)
+            index = 0;
+        if (index > this.rows.length)
+            index = this.rows.length;
+        if (!row) {
+            const gridColumns = this.formatting.tableGrid
+                ? this.formatting.tableGrid.length
+                : Math.max(...this.rows.map((r) => r.getTotalGridSpan()), 1);
+            row = new TableRow(gridColumns);
+        }
+        this.rows.splice(index, 0, row);
+        if (this.trackingContext?.isEnabled()) {
+            const author = this.trackingContext.getAuthor();
+            for (const cell of row.getCells()) {
+                const revision = Revision.createTableCellInsert(author, []);
+                cell.setCellRevision(revision);
+            }
+        }
+        return row;
+    }
+    addColumn(index) {
+        const isTracking = this.trackingContext?.isEnabled();
+        const author = isTracking ? this.trackingContext.getAuthor() : '';
+        for (const row of this.rows) {
+            const cell = new TableCell();
+            if (isTracking) {
+                const revision = Revision.createTableCellInsert(author, []);
+                cell.setCellRevision(revision);
+            }
+            const cells = row.getCells();
+            if (index === undefined || index >= cells.length) {
+                row.addCell(cell);
+            }
+            else {
+                const idx = Math.max(0, index);
+                row.insertCellAt(idx, cell);
+            }
+        }
+        return this;
+    }
+    removeColumn(index) {
+        if (index < 0 || this.rows.length === 0) {
+            return false;
+        }
+        if (this.trackingContext?.isEnabled()) {
+            const author = this.trackingContext.getAuthor();
+            let marked = false;
+            for (const row of this.rows) {
+                const cells = row.getCells();
+                if (index < cells.length) {
+                    const revision = Revision.createTableCellDelete(author, []);
+                    cells[index].setCellRevision(revision);
+                    marked = true;
+                }
+            }
+            return marked;
+        }
+        let removed = false;
+        for (const row of this.rows) {
+            const cells = row.getCells();
+            if (index < cells.length) {
+                row.removeCellAt(index);
+                removed = true;
+            }
+        }
+        return removed;
+    }
+    getColumnCount() {
+        if (this.rows.length === 0) {
+            return 0;
+        }
+        return Math.max(...this.rows.map((row) => row.getCellCount()));
+    }
+    getColumnCells(colIndex) {
+        const cells = [];
+        for (const row of this.rows) {
+            const cell = row.getCell(colIndex);
+            if (cell)
+                cells.push(cell);
+        }
+        return cells;
+    }
+    getColumnTexts(colIndex) {
+        return this.getColumnCells(colIndex).map((cell) => cell.getText());
+    }
+    mapColumn(colIndex, transform) {
+        for (let r = 0; r < this.rows.length; r++) {
+            const cell = this.rows[r].getCell(colIndex);
+            if (!cell)
+                continue;
+            const currentText = cell.getText();
+            const newText = transform(currentText, r);
+            if (newText !== currentText) {
+                const paragraphs = cell.getParagraphs();
+                if (paragraphs.length > 0) {
+                    const firstPara = paragraphs[0];
+                    firstPara.setText(newText);
+                    for (let p = paragraphs.length - 1; p >= 1; p--) {
+                        cell.removeParagraph(p);
+                    }
+                }
+                else {
+                    cell.createParagraph(newText);
+                }
+            }
+        }
+        return this;
+    }
+    forEachCell(callback) {
+        for (let r = 0; r < this.rows.length; r++) {
+            const cells = this.rows[r].getCells();
+            for (let c = 0; c < cells.length; c++) {
+                const result = callback(r, c, cells[c]);
+                if (result === false)
+                    return;
+            }
+        }
+    }
+    findCell(predicate) {
+        for (let r = 0; r < this.rows.length; r++) {
+            const cells = this.rows[r].getCells();
+            for (let c = 0; c < cells.length; c++) {
+                if (predicate(cells[c], r, c)) {
+                    return { row: r, col: c, cell: cells[c] };
+                }
+            }
+        }
+        return undefined;
+    }
+    filterRows(predicate) {
+        const indices = [];
+        for (let r = 0; r < this.rows.length; r++) {
+            if (predicate(this.rows[r].getCells(), r)) {
+                indices.push(r);
+            }
+        }
+        return indices;
+    }
+    removeEmptyRows() {
+        const emptyIndices = this.filterRows((cells) => cells.every((c) => c.getText().trim() === ''));
+        const toRemove = emptyIndices.length === this.rows.length
+            ? emptyIndices.slice(1)
+            : emptyIndices;
+        for (let i = toRemove.length - 1; i >= 0; i--) {
+            this.removeRow(toRemove[i]);
+        }
+        return toRemove.length;
+    }
+    removeEmptyColumns() {
+        const colCount = this.getColumnCount();
+        let removed = 0;
+        for (let c = colCount - 1; c >= 0; c--) {
+            const columnCells = this.getColumnCells(c);
+            const isEmpty = columnCells.every((cell) => cell.getText().trim() === '');
+            if (isEmpty) {
+                this.removeColumn(c);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    setColumnWidths(widths) {
+        this.formatting.tableGrid = widths.map((w) => (w === null ? undefined : w));
+        return this;
+    }
+    static create(rows, columns, formatting) {
+        return new Table(rows, columns, formatting);
+    }
+    static fromArray(data, formatting) {
+        if (data.length === 0)
+            return new Table(0, 0, formatting);
+        const maxCols = Math.max(...data.map((row) => row.length));
+        const table = new Table(0, 0, formatting);
+        for (const rowData of data) {
+            const row = new TableRow();
+            for (let c = 0; c < maxCols; c++) {
+                const text = c < rowData.length ? rowData[c] : undefined;
+                row.createCell(text || undefined);
+            }
+            table.addRow(row);
+        }
+        return table;
+    }
+    mergeCells(startRow, startCol, endRow, endCol) {
+        if (startRow < 0 || endRow >= this.rows.length || startCol < 0 || endCol < 0) {
+            return this;
+        }
+        if (endRow < startRow || endCol < startCol) {
+            return this;
+        }
+        const cell = this.getCell(startRow, startCol);
+        if (!cell) {
+            return this;
+        }
+        for (let row = startRow; row <= endRow; row++) {
+            for (let col = startCol; col <= endCol; col++) {
+                const checkCell = this.getCell(row, col);
+                if (!checkCell)
+                    continue;
+                const vMerge = checkCell.getVerticalMerge();
+                if (vMerge) {
+                    if (row === startRow && col === startCol && vMerge === 'restart') {
+                        continue;
+                    }
+                    throw new Error(`Cannot merge cells: Cell at row ${row}, column ${col} is already part of a vertical merge region. ` +
+                        `Use splitCell() or clear existing merges before creating new merge regions.`);
+                }
+                const colSpan = checkCell.getColumnSpan();
+                if (colSpan > 1) {
+                    if (row === startRow && col === startCol) {
+                        continue;
+                    }
+                    throw new Error(`Cannot merge cells: Cell at row ${row}, column ${col} already has a column span of ${colSpan}. ` +
+                        `Use splitCell() or clear existing merges before creating new merge regions.`);
+                }
+            }
+        }
+        if (endCol > startCol) {
+            cell.setColumnSpan(endCol - startCol + 1);
+        }
+        if (endRow > startRow) {
+            cell.setVerticalMerge('restart');
+            for (let row = startRow + 1; row <= endRow; row++) {
+                const mergeCell = this.getCell(row, startCol);
+                if (mergeCell) {
+                    mergeCell.setVerticalMerge('continue');
+                    if (endCol > startCol) {
+                        mergeCell.setColumnSpan(endCol - startCol + 1);
+                    }
+                }
+            }
+        }
+        if (this.trackingContext?.isEnabled()) {
+            const author = this.trackingContext.getAuthor();
+            for (let row = startRow; row <= endRow; row++) {
+                for (let col = startCol; col <= endCol; col++) {
+                    if (row === startRow && col === startCol)
+                        continue;
+                    const absorbedCell = this.getCell(row, col);
+                    if (absorbedCell) {
+                        const revision = Revision.createTableCellMerge(author, []);
+                        absorbedCell.setCellRevision(revision);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    splitCell(row, col) {
+        const cell = this.getCell(row, col);
+        if (cell) {
+            cell.setColumnSpan(1);
+            cell.setVerticalMerge(undefined);
+        }
+        return this;
+    }
+    canMergeCells(startRow, startCol, endRow, endCol) {
+        const conflicts = [];
+        if (startRow < 0 ||
+            endRow >= this.rows.length ||
+            startCol < 0 ||
+            endCol < 0 ||
+            endRow < startRow ||
+            endCol < startCol) {
+            conflicts.push('Invalid cell range specified');
+            return { valid: false, conflicts };
+        }
+        for (let row = startRow; row <= endRow; row++) {
+            for (let col = startCol; col <= endCol; col++) {
+                const checkCell = this.getCell(row, col);
+                if (!checkCell) {
+                    conflicts.push(`Cell at row ${row}, column ${col} does not exist`);
+                    continue;
+                }
+                const vMerge = checkCell.getVerticalMerge();
+                if (vMerge) {
+                    if (!(row === startRow && col === startCol && vMerge === 'restart')) {
+                        conflicts.push(`Cell at row ${row}, column ${col} is part of a vertical merge (${vMerge})`);
+                    }
+                }
+                const colSpan = checkCell.getColumnSpan();
+                if (colSpan > 1) {
+                    if (!(row === startRow && col === startCol)) {
+                        conflicts.push(`Cell at row ${row}, column ${col} has column span of ${colSpan}`);
+                    }
+                }
+            }
+        }
+        return { valid: conflicts.length === 0, conflicts };
+    }
+    moveCell(fromRow, fromCol, toRow, toCol) {
+        const fromCell = this.getCell(fromRow, fromCol);
+        const toCell = this.getCell(toRow, toCol);
+        if (!fromCell || !toCell) {
+            return this;
+        }
+        const paragraphs = fromCell.getParagraphs();
+        for (const para of paragraphs) {
+            toCell.addParagraph(para);
+        }
+        const formatting = fromCell.getFormatting();
+        if (formatting.shading)
+            toCell.setShading(formatting.shading);
+        if (formatting.borders)
+            toCell.setBorders(formatting.borders);
+        if (formatting.width)
+            toCell.setWidth(formatting.width);
+        if (formatting.verticalAlignment)
+            toCell.setVerticalAlignment(formatting.verticalAlignment);
+        const row = this.getRow(fromRow);
+        if (row) {
+            const cells = row.getCells();
+            cells[fromCol] = new TableCell();
+        }
+        return this;
+    }
+    swapCells(row1, col1, row2, col2) {
+        const row1Obj = this.getRow(row1);
+        const row2Obj = this.getRow(row2);
+        if (!row1Obj || !row2Obj) {
+            return this;
+        }
+        const cells1 = row1Obj.getCells();
+        const cells2 = row2Obj.getCells();
+        if (col1 >= cells1.length || col2 >= cells2.length) {
+            return this;
+        }
+        const temp = cells1[col1];
+        cells1[col1] = cells2[col2];
+        cells2[col2] = temp;
+        return this;
+    }
+    setColumnWidth(columnIndex, width) {
+        const tableGrid = this.formatting.tableGrid || [];
+        tableGrid[columnIndex] = width;
+        this.formatting.tableGrid = tableGrid;
+        return this;
+    }
+    insertRows(startIndex, count) {
+        const insertedRows = [];
+        const columnCount = this.formatting.tableGrid
+            ? this.formatting.tableGrid.length
+            : Math.max(...this.rows.map((r) => r.getTotalGridSpan()), 1);
+        for (let i = 0; i < count; i++) {
+            const row = new TableRow(columnCount);
+            this.insertRow(startIndex + i, row);
+            insertedRows.push(row);
+        }
+        return insertedRows;
+    }
+    removeRows(startIndex, count) {
+        if (startIndex < 0 || startIndex >= this.rows.length || count <= 0) {
+            return false;
+        }
+        const actualCount = Math.min(count, this.rows.length - startIndex);
+        if (this.trackingContext?.isEnabled()) {
+            const author = this.trackingContext.getAuthor();
+            for (let i = startIndex; i < startIndex + actualCount; i++) {
+                const row = this.rows[i];
+                for (const cell of row.getCells()) {
+                    const cellDelRevision = Revision.createTableCellDelete(author, []);
+                    cell.setCellRevision(cellDelRevision);
+                    for (const para of cell.getParagraphs()) {
+                        const runs = para.getRuns();
+                        if (runs.length > 0) {
+                            const deletion = Revision.createDeletion(author, runs);
+                            para.addRevision(deletion);
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        this.rows.splice(startIndex, actualCount);
+        return actualCount > 0;
+    }
+    sortRows(columnIndex, options) {
+        const ascending = options?.ascending ?? true;
+        const numeric = options?.numeric ?? false;
+        const skipHeaderRow = options?.skipHeaderRow ?? true;
+        if (this.rows.length <= 1) {
+            return this;
+        }
+        const headerRow = skipHeaderRow ? this.rows.shift() : null;
+        const rowsToSort = [...this.rows];
+        rowsToSort.sort((a, b) => {
+            const cellA = a.getCell(columnIndex);
+            const cellB = b.getCell(columnIndex);
+            const textA = cellA?.getText().trim() || '';
+            const textB = cellB?.getText().trim() || '';
+            let comparison;
+            if (numeric) {
+                const numA = parseFloat(textA) || 0;
+                const numB = parseFloat(textB) || 0;
+                comparison = numA - numB;
+            }
+            else {
+                comparison = textA.localeCompare(textB);
+            }
+            return ascending ? comparison : -comparison;
+        });
+        this.rows = headerRow ? [headerRow, ...rowsToSort] : rowsToSort;
+        return this;
+    }
+    toArray() {
+        return this.rows.map((row) => row.getCells().map((cell) => cell.getText()));
+    }
+    toPlainText(columnSeparator = '\t', rowSeparator = '\n') {
+        return this.rows
+            .map((row) => row
+            .getCells()
+            .map((cell) => cell.getText())
+            .join(columnSeparator))
+            .join(rowSeparator);
+    }
+    toCSV(delimiter = ',') {
+        return this.rows
+            .map((row) => row
+            .getCells()
+            .map((cell) => {
+            const text = cell.getText();
+            if (text.includes(delimiter) || text.includes('"') || text.includes('\n')) {
+                return '"' + text.replace(/"/g, '""') + '"';
+            }
+            return text;
+        })
+            .join(delimiter))
+            .join('\n');
+    }
+    static fromCSV(csv, delimiter = ',', formatting) {
+        const rows = [];
+        let currentRow = [];
+        let currentField = '';
+        let inQuotes = false;
+        let i = 0;
+        while (i < csv.length) {
+            const ch = csv[i];
+            if (inQuotes) {
+                if (ch === '"') {
+                    if (i + 1 < csv.length && csv[i + 1] === '"') {
+                        currentField += '"';
+                        i += 2;
+                    }
+                    else {
+                        inQuotes = false;
+                        i++;
+                    }
+                }
+                else {
+                    currentField += ch;
+                    i++;
+                }
+            }
+            else {
+                if (ch === '"') {
+                    inQuotes = true;
+                    i++;
+                }
+                else if (ch === delimiter) {
+                    currentRow.push(currentField);
+                    currentField = '';
+                    i++;
+                }
+                else if (ch === '\n') {
+                    currentRow.push(currentField);
+                    currentField = '';
+                    rows.push(currentRow);
+                    currentRow = [];
+                    i++;
+                }
+                else if (ch === '\r') {
+                    if (i + 1 < csv.length && csv[i + 1] === '\n') {
+                        i++;
+                    }
+                    currentRow.push(currentField);
+                    currentField = '';
+                    rows.push(currentRow);
+                    currentRow = [];
+                    i++;
+                }
+                else {
+                    currentField += ch;
+                    i++;
+                }
+            }
+        }
+        if (currentField || currentRow.length > 0) {
+            currentRow.push(currentField);
+            rows.push(currentRow);
+        }
+        if (rows.length === 0)
+            return new Table(0, 0, formatting);
+        return Table.fromArray(rows, formatting);
+    }
+    transpose() {
+        const srcRows = this.rows.length;
+        if (srcRows === 0)
+            return new Table(0, 0);
+        const srcCols = this.getColumnCount();
+        if (srcCols === 0)
+            return new Table(0, 0);
+        const transposed = new Table(0, 0);
+        for (let c = 0; c < srcCols; c++) {
+            const newRow = new TableRow();
+            for (let r = 0; r < srcRows; r++) {
+                const srcCell = this.getCell(r, c);
+                if (srcCell) {
+                    newRow.addCell(srcCell.clone());
+                }
+                else {
+                    newRow.createCell();
+                }
+            }
+            transposed.addRow(newRow);
+        }
+        return transposed;
+    }
+    clone() {
+        const clonedFormatting = deepClone(this.formatting);
+        const clonedTable = new Table(0, 0, clonedFormatting);
+        for (const row of this.rows) {
+            clonedTable.addRow(row.clone());
+        }
+        return clonedTable;
+    }
+    duplicateRow(rowIndex, count = 1) {
+        if (rowIndex < 0 || rowIndex >= this.rows.length) {
+            throw new RangeError(`Row index ${rowIndex} is out of bounds (0-${this.rows.length - 1})`);
+        }
+        if (count < 1)
+            return [];
+        const sourceRow = this.rows[rowIndex];
+        const inserted = [];
+        for (let i = 0; i < count; i++) {
+            const clonedRow = sourceRow.clone();
+            this.rows.splice(rowIndex + 1 + i, 0, clonedRow);
+            clonedRow._setParentTable(this);
+            inserted.push(clonedRow);
+        }
+        return inserted;
+    }
+}
+//# sourceMappingURL=Table.js.map