docxmlater 10.4.1 → 11.0.4

package/dist/esm/elements/TableCell.js

@@ -0,0 +1,835 @@
+import { deepClone } from '../utils/deepClone.js';
+import { formatDateForXml } from '../utils/dateFormatting.js';
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+import { Paragraph } from './Paragraph.js';
+import { Revision } from './Revision.js';
+import { buildShadingAttributes, } from './CommonTypes.js';
+export class TableCell {
+    paragraphs = [];
+    formatting;
+    rawNestedContent = [];
+    _parentRow;
+    cellRevision;
+    trackingContext;
+    tcPrChange;
+    constructor(formatting = {}) {
+        this.formatting = formatting;
+    }
+    _setTrackingContext(context) {
+        this.trackingContext = context;
+    }
+    getTcPrChange() {
+        return this.tcPrChange;
+    }
+    setTcPrChange(change) {
+        this.tcPrChange = change;
+    }
+    clearTcPrChange() {
+        this.tcPrChange = undefined;
+    }
+    addParagraph(paragraph) {
+        this.paragraphs.push(paragraph);
+        paragraph._setParentCell(this);
+        const stylesManager = this._parentRow?._getParentTable()?._getStylesManager();
+        if (stylesManager) {
+            paragraph._setStylesManager(stylesManager);
+        }
+        return this;
+    }
+    createParagraph(text) {
+        const para = new Paragraph();
+        if (text) {
+            para.addText(text);
+        }
+        this.paragraphs.push(para);
+        para._setParentCell(this);
+        const stylesManager = this._parentRow?._getParentTable()?._getStylesManager();
+        if (stylesManager) {
+            para._setStylesManager(stylesManager);
+        }
+        return para;
+    }
+    getParagraphs() {
+        return [...this.paragraphs];
+    }
+    removeParagraph(index) {
+        if (index < 0 || index >= this.paragraphs.length) {
+            return false;
+        }
+        if (this.trackingContext?.isEnabled()) {
+            const paragraph = this.paragraphs[index];
+            const runs = paragraph.getRuns();
+            if (runs.length > 0) {
+                const author = this.trackingContext.getAuthor();
+                const deletion = Revision.createDeletion(author, runs);
+                this.trackingContext.getRevisionManager().register(deletion);
+                paragraph.addRevision(deletion);
+            }
+            return true;
+        }
+        const removed = this.paragraphs.splice(index, 1);
+        const removedPara = removed[0];
+        if (removedPara) {
+            removedPara._setParentCell(undefined);
+        }
+        for (const item of this.rawNestedContent) {
+            if (item.position > index) {
+                item.position--;
+            }
+        }
+        return true;
+    }
+    addParagraphAt(index, paragraph) {
+        if (index < 0) {
+            index = 0;
+        }
+        const actualIndex = index >= this.paragraphs.length ? this.paragraphs.length : index;
+        if (index >= this.paragraphs.length) {
+            this.paragraphs.push(paragraph);
+        }
+        else {
+            this.paragraphs.splice(index, 0, paragraph);
+        }
+        for (const item of this.rawNestedContent) {
+            if (item.position >= actualIndex) {
+                item.position++;
+            }
+        }
+        paragraph._setParentCell(this);
+        const stylesManager = this._parentRow?._getParentTable()?._getStylesManager();
+        if (stylesManager) {
+            paragraph._setStylesManager(stylesManager);
+        }
+        if (this.trackingContext?.isEnabled()) {
+            const runs = paragraph.getRuns();
+            if (runs.length > 0) {
+                const author = this.trackingContext.getAuthor();
+                const insertion = Revision.createInsertion(author, runs);
+                this.trackingContext.getRevisionManager().register(insertion);
+                paragraph.addRevision(insertion);
+            }
+        }
+        return this;
+    }
+    getText() {
+        return this.paragraphs.map((p) => p.getText()).join('\n');
+    }
+    getFields() {
+        const fields = [];
+        for (const para of this.paragraphs) {
+            fields.push(...para.getFields());
+        }
+        return fields;
+    }
+    findFields(predicate) {
+        return this.getFields().filter(predicate);
+    }
+    removeAllFields() {
+        let count = 0;
+        for (const para of this.paragraphs) {
+            count += para.removeAllFields();
+        }
+        return count;
+    }
+    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;
+    }
+    setBorders(borders) {
+        const prev = this.formatting.borders;
+        this.formatting.borders = borders;
+        if (this.trackingContext?.isEnabled() && prev !== borders) {
+            this.trackingContext.trackTableChange(this, 'borders', prev, borders);
+        }
+        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;
+    }
+    setBackgroundColor(color) {
+        return this.setShading({ fill: color, pattern: 'clear' });
+    }
+    getBackgroundColor() {
+        return this.formatting.shading?.fill;
+    }
+    setVerticalAlignment(alignment) {
+        const prev = this.formatting.verticalAlignment;
+        this.formatting.verticalAlignment = alignment;
+        if (this.trackingContext?.isEnabled() && prev !== alignment) {
+            this.trackingContext.trackTableChange(this, 'verticalAlignment', prev, alignment);
+        }
+        return this;
+    }
+    setColumnSpan(span) {
+        const prev = this.formatting.columnSpan;
+        this.formatting.columnSpan = span;
+        if (this.trackingContext?.isEnabled() && prev !== span) {
+            this.trackingContext.trackTableChange(this, 'columnSpan', prev, span);
+        }
+        return this;
+    }
+    getColumnSpan() {
+        return this.formatting.columnSpan || 1;
+    }
+    getFitText() {
+        return this.formatting.fitText ?? false;
+    }
+    getNoWrap() {
+        return this.formatting.noWrap ?? false;
+    }
+    getHideMark() {
+        return this.formatting.hideMark ?? false;
+    }
+    getCnfStyle() {
+        return this.formatting.cnfStyle;
+    }
+    validateMargin(value, side) {
+        if (value === undefined)
+            return;
+        if (value < 0) {
+            throw new Error(`Invalid ${side} margin: ${value} twips. Cell margins cannot be negative.`);
+        }
+        const MAX_MARGIN_TWIPS = 14400;
+        if (value > MAX_MARGIN_TWIPS) {
+            throw new Error(`Invalid ${side} margin: ${value} twips exceeds maximum of ${MAX_MARGIN_TWIPS} twips (10 inches).`);
+        }
+    }
+    setMargins(margins) {
+        this.validateMargin(margins.top, 'top');
+        this.validateMargin(margins.bottom, 'bottom');
+        this.validateMargin(margins.left, 'left');
+        this.validateMargin(margins.right, 'right');
+        const prev = this.formatting.margins;
+        this.formatting.margins = margins;
+        if (this.trackingContext?.isEnabled() && prev !== margins) {
+            this.trackingContext.trackTableChange(this, 'margins', prev, margins);
+        }
+        return this;
+    }
+    setAllMargins(margin) {
+        this.validateMargin(margin, 'all');
+        return this.setMargins({ top: margin, bottom: margin, left: margin, right: margin });
+    }
+    setTextDirection(direction) {
+        const prev = this.formatting.textDirection;
+        this.formatting.textDirection = direction;
+        if (this.trackingContext?.isEnabled() && prev !== direction) {
+            this.trackingContext.trackTableChange(this, 'textDirection', prev, direction);
+        }
+        return this;
+    }
+    setFitText(fit = true) {
+        const prev = this.formatting.fitText;
+        this.formatting.fitText = fit;
+        if (this.trackingContext?.isEnabled() && prev !== fit) {
+            this.trackingContext.trackTableChange(this, 'fitText', prev, fit);
+        }
+        return this;
+    }
+    setNoWrap(noWrap = true) {
+        const prev = this.formatting.noWrap;
+        this.formatting.noWrap = noWrap;
+        if (this.trackingContext?.isEnabled() && prev !== noWrap) {
+            this.trackingContext.trackTableChange(this, 'noWrap', prev, noWrap);
+        }
+        return this;
+    }
+    setHideMark(hide = true) {
+        const prev = this.formatting.hideMark;
+        this.formatting.hideMark = hide;
+        if (this.trackingContext?.isEnabled() && prev !== hide) {
+            this.trackingContext.trackTableChange(this, 'hideMark', prev, hide);
+        }
+        return this;
+    }
+    setConditionalStyle(cnfStyle) {
+        const prev = this.formatting.cnfStyle;
+        this.formatting.cnfStyle = cnfStyle;
+        if (this.trackingContext?.isEnabled() && prev !== cnfStyle) {
+            this.trackingContext.trackTableChange(this, 'cnfStyle', prev, cnfStyle);
+        }
+        return this;
+    }
+    setWidthType(width, type = 'dxa') {
+        const prevWidth = this.formatting.width;
+        const prevType = this.formatting.widthType;
+        this.formatting.width = width;
+        this.formatting.widthType = type;
+        if (this.trackingContext?.isEnabled()) {
+            if (prevWidth !== width) {
+                this.trackingContext.trackTableChange(this, 'width', prevWidth, width);
+            }
+            if (prevType !== type) {
+                this.trackingContext.trackTableChange(this, 'widthType', prevType, type);
+            }
+        }
+        return this;
+    }
+    setVerticalMerge(merge) {
+        const prev = this.formatting.vMerge;
+        this.formatting.vMerge = merge;
+        if (this.trackingContext?.isEnabled() && prev !== merge) {
+            this.trackingContext.trackTableChange(this, 'vMerge', prev, merge);
+        }
+        return this;
+    }
+    setHorizontalMerge(merge) {
+        const prev = this.formatting.hMerge;
+        this.formatting.hMerge = merge;
+        if (this.trackingContext?.isEnabled() && prev !== merge) {
+            this.trackingContext.trackTableChange(this, 'hMerge', prev, merge);
+        }
+        return this;
+    }
+    setCellRevision(revision) {
+        this.cellRevision = revision;
+        return this;
+    }
+    getCellRevision() {
+        return this.cellRevision;
+    }
+    hasCellRevision() {
+        return this.cellRevision !== undefined;
+    }
+    clearCellRevision() {
+        this.cellRevision = undefined;
+        return this;
+    }
+    setTextAlignment(alignment) {
+        for (const para of this.paragraphs) {
+            para.setAlignment(alignment);
+        }
+        return this;
+    }
+    setAllParagraphsStyle(styleId) {
+        for (const para of this.paragraphs) {
+            para.setStyle(styleId);
+        }
+        return this;
+    }
+    setAllRunsFont(fontName) {
+        let count = 0;
+        for (const para of this.paragraphs) {
+            for (const run of para.getRuns()) {
+                run.setFont(fontName);
+                count++;
+            }
+        }
+        return count;
+    }
+    setAllRunsSize(size) {
+        let count = 0;
+        for (const para of this.paragraphs) {
+            for (const run of para.getRuns()) {
+                run.setSize(size);
+                count++;
+            }
+        }
+        return count;
+    }
+    setAllRunsColor(color) {
+        let count = 0;
+        for (const para of this.paragraphs) {
+            for (const run of para.getRuns()) {
+                run.setColor(color);
+                count++;
+            }
+        }
+        return count;
+    }
+    getFormatting() {
+        return { ...this.formatting };
+    }
+    getWidth() {
+        return this.formatting.width;
+    }
+    getWidthType() {
+        return this.formatting.widthType;
+    }
+    getVerticalAlignment() {
+        return this.formatting.verticalAlignment;
+    }
+    getVerticalMerge() {
+        return this.formatting.vMerge;
+    }
+    getHorizontalMerge() {
+        return this.formatting.hMerge;
+    }
+    setHeaders(headers) {
+        this.formatting.headers = headers;
+        return this;
+    }
+    getHeaders() {
+        return this.formatting.headers;
+    }
+    getMargins() {
+        return this.formatting.margins;
+    }
+    getBorders() {
+        return this.formatting.borders;
+    }
+    getShading() {
+        return this.formatting.shading;
+    }
+    getTextDirection() {
+        return this.formatting.textDirection;
+    }
+    addRawNestedContent(position, xml, type = 'table') {
+        this.rawNestedContent.push({ position, xml, type });
+        return this;
+    }
+    getRawNestedContent() {
+        return [...this.rawNestedContent];
+    }
+    hasNestedTables() {
+        return this.rawNestedContent.some((c) => c.type === 'table');
+    }
+    hasRawNestedContent() {
+        return this.rawNestedContent.length > 0;
+    }
+    clearRawNestedContent() {
+        this.rawNestedContent = [];
+        return this;
+    }
+    updateRawNestedContent(index, xml) {
+        if (index < 0 || index >= this.rawNestedContent.length) {
+            return false;
+        }
+        const item = this.rawNestedContent[index];
+        if (item) {
+            item.xml = xml;
+            return true;
+        }
+        return false;
+    }
+    removeTrailingBlankParagraphs(options) {
+        let removed = 0;
+        const ignorePreserve = options?.ignorePreserveFlag ?? false;
+        while (this.paragraphs.length > 1) {
+            const lastIndex = this.paragraphs.length - 1;
+            const lastPara = this.paragraphs[lastIndex];
+            if (!lastPara)
+                break;
+            const isBlank = this.isParaBlank(lastPara);
+            if (!isBlank)
+                break;
+            if (!ignorePreserve && lastPara.isPreserved())
+                break;
+            const hasContentAfter = this.rawNestedContent.some((item) => item.position >= lastIndex);
+            if (hasContentAfter)
+                break;
+            this.removeParagraph(lastIndex);
+            removed++;
+        }
+        return removed;
+    }
+    isParaBlank(para) {
+        const text = para.getText().trim();
+        if (text !== '')
+            return false;
+        const cnfStyle = para.getTableConditionalStyle();
+        if (cnfStyle && cnfStyle !== '') {
+            return false;
+        }
+        const content = para.getContent();
+        for (const item of content) {
+            const itemAny = item;
+            if (item && typeof itemAny.getImageElement === 'function') {
+                return false;
+            }
+            if (item && typeof itemAny.getShapeType === 'function') {
+                return false;
+            }
+            if (item && typeof itemAny.getTextContent === 'function') {
+                return false;
+            }
+            if (item && typeof itemAny.getUrl === 'function') {
+                return false;
+            }
+            if (item && typeof itemAny.getInstruction === 'function') {
+                return false;
+            }
+            if (item && typeof itemAny.getText === 'function') {
+                const itemText = itemAny.getText().trim();
+                if (itemText !== '')
+                    return false;
+                if (typeof itemAny.getContent === 'function') {
+                    const revContent = itemAny.getContent();
+                    for (const revItem of revContent) {
+                        const revItemAny = revItem;
+                        if (revItem && typeof revItemAny.getUrl === 'function') {
+                            return false;
+                        }
+                        if (revItem && typeof revItemAny.getImageElement === 'function') {
+                            return false;
+                        }
+                        if (revItem && typeof revItemAny.getShapeType === 'function') {
+                            return false;
+                        }
+                        if (revItem && typeof revItemAny.getTextContent === 'function') {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        if (para.getBookmarksStart().length > 0 || para.getBookmarksEnd().length > 0) {
+            return false;
+        }
+        if (typeof para.getCommentsStart === 'function') {
+            const commentsStart = para.getCommentsStart();
+            if (commentsStart && commentsStart.length > 0) {
+                return false;
+            }
+        }
+        if (typeof para.getCommentsEnd === 'function') {
+            const commentsEnd = para.getCommentsEnd();
+            if (commentsEnd && commentsEnd.length > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _setParentRow(row) {
+        this._parentRow = row;
+    }
+    _getParentRow() {
+        return this._parentRow;
+    }
+    getTableStyleId() {
+        const row = this._parentRow;
+        if (!row)
+            return undefined;
+        const table = row._getParentTable();
+        if (!table)
+            return undefined;
+        return table.getFormatting().style;
+    }
+    clone() {
+        const clonedCell = new TableCell(deepClone(this.formatting));
+        for (const para of this.paragraphs) {
+            clonedCell.addParagraph(para.clone());
+        }
+        for (const item of this.rawNestedContent) {
+            clonedCell.addRawNestedContent(item.position, item.xml, item.type);
+        }
+        if (this.tcPrChange) {
+            clonedCell.setTcPrChange(deepClone(this.tcPrChange));
+        }
+        if (this.cellRevision) {
+            clonedCell.setCellRevision(this.cellRevision);
+        }
+        return clonedCell;
+    }
+    toXML() {
+        const tcPrChildren = [];
+        if (this.formatting.cnfStyle) {
+            tcPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': this.formatting.cnfStyle }));
+        }
+        if (this.formatting.width !== undefined) {
+            const widthAttrs = {
+                'w:w': this.formatting.width,
+                'w:type': this.formatting.widthType || 'dxa',
+            };
+            tcPrChildren.push(XMLBuilder.wSelf('tcW', widthAttrs));
+        }
+        if (this.formatting.columnSpan && this.formatting.columnSpan > 1) {
+            tcPrChildren.push(XMLBuilder.wSelf('gridSpan', { 'w:val': this.formatting.columnSpan }));
+        }
+        if (this.formatting.hMerge) {
+            tcPrChildren.push(XMLBuilder.wSelf('hMerge', { 'w:val': this.formatting.hMerge }));
+        }
+        if (this.formatting.vMerge) {
+            if (this.formatting.vMerge === 'restart') {
+                tcPrChildren.push(XMLBuilder.wSelf('vMerge', { 'w:val': 'restart' }));
+            }
+            else {
+                tcPrChildren.push(XMLBuilder.wSelf('vMerge'));
+            }
+        }
+        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.tl2br) {
+                borderElements.push(XMLBuilder.createBorder('tl2br', borders.tl2br));
+            }
+            if (borders.tr2bl) {
+                borderElements.push(XMLBuilder.createBorder('tr2bl', borders.tr2bl));
+            }
+            if (borderElements.length > 0) {
+                tcPrChildren.push(XMLBuilder.w('tcBorders', undefined, borderElements));
+            }
+        }
+        if (this.formatting.shading) {
+            const shadingAttrs = buildShadingAttributes(this.formatting.shading);
+            if (Object.keys(shadingAttrs).length > 0) {
+                tcPrChildren.push(XMLBuilder.wSelf('shd', shadingAttrs));
+            }
+        }
+        if (this.formatting.noWrap !== undefined) {
+            if (this.formatting.noWrap) {
+                tcPrChildren.push(XMLBuilder.wSelf('noWrap'));
+            }
+            else {
+                tcPrChildren.push(XMLBuilder.wSelf('noWrap', { 'w:val': 'off' }));
+            }
+        }
+        if (this.formatting.margins) {
+            const margins = this.formatting.margins;
+            const marginChildren = [];
+            if (margins.top !== undefined) {
+                marginChildren.push(XMLBuilder.wSelf('top', {
+                    'w:w': margins.top.toString(),
+                    'w:type': 'dxa',
+                }));
+            }
+            if (margins.left !== undefined) {
+                marginChildren.push(XMLBuilder.wSelf('left', {
+                    'w:w': margins.left.toString(),
+                    'w:type': 'dxa',
+                }));
+            }
+            if (margins.bottom !== undefined) {
+                marginChildren.push(XMLBuilder.wSelf('bottom', {
+                    'w:w': margins.bottom.toString(),
+                    'w:type': 'dxa',
+                }));
+            }
+            if (margins.right !== undefined) {
+                marginChildren.push(XMLBuilder.wSelf('right', {
+                    'w:w': margins.right.toString(),
+                    'w:type': 'dxa',
+                }));
+            }
+            if (marginChildren.length > 0) {
+                tcPrChildren.push(XMLBuilder.w('tcMar', undefined, marginChildren));
+            }
+        }
+        if (this.formatting.textDirection) {
+            tcPrChildren.push(XMLBuilder.wSelf('textDirection', {
+                'w:val': this.formatting.textDirection,
+            }));
+        }
+        if (this.formatting.fitText !== undefined) {
+            if (this.formatting.fitText) {
+                tcPrChildren.push(XMLBuilder.wSelf('tcFitText'));
+            }
+            else {
+                tcPrChildren.push(XMLBuilder.wSelf('tcFitText', { 'w:val': 'off' }));
+            }
+        }
+        if (this.formatting.verticalAlignment) {
+            tcPrChildren.push(XMLBuilder.wSelf('vAlign', {
+                'w:val': this.formatting.verticalAlignment,
+            }));
+        }
+        if (this.formatting.hideMark !== undefined) {
+            if (this.formatting.hideMark) {
+                tcPrChildren.push(XMLBuilder.wSelf('hideMark'));
+            }
+            else {
+                tcPrChildren.push(XMLBuilder.wSelf('hideMark', { 'w:val': 'off' }));
+            }
+        }
+        if (this.cellRevision) {
+            const revType = this.cellRevision.getType();
+            const attrs = {
+                'w:id': this.cellRevision.getId(),
+                'w:author': this.cellRevision.getAuthor(),
+                'w:date': formatDateForXml(this.cellRevision.getDate()),
+            };
+            if (revType === 'tableCellInsert') {
+                tcPrChildren.push(XMLBuilder.wSelf('cellIns', attrs));
+            }
+            else if (revType === 'tableCellDelete') {
+                tcPrChildren.push(XMLBuilder.wSelf('cellDel', attrs));
+            }
+            else if (revType === 'tableCellMerge') {
+                const mergeMap = { continue: 'cont', restart: 'rest' };
+                const prevProps = this.cellRevision.getPreviousProperties();
+                if (prevProps?.vMerge) {
+                    attrs['w:vMerge'] = mergeMap[prevProps.vMerge] || prevProps.vMerge;
+                }
+                if (prevProps?.vMergeOrig) {
+                    attrs['w:vMergeOrig'] = mergeMap[prevProps.vMergeOrig] || prevProps.vMergeOrig;
+                }
+                tcPrChildren.push(XMLBuilder.wSelf('cellMerge', attrs));
+            }
+        }
+        if (this.tcPrChange) {
+            const changeAttrs = {
+                'w:id': this.tcPrChange.id,
+                'w:author': this.tcPrChange.author,
+                'w:date': this.tcPrChange.date,
+            };
+            const prevTcPrChildren = [];
+            const prev = this.tcPrChange.previousProperties;
+            if (prev) {
+                if (prev.cnfStyle) {
+                    prevTcPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': prev.cnfStyle }));
+                }
+                if (prev.width !== undefined) {
+                    prevTcPrChildren.push(XMLBuilder.wSelf('tcW', {
+                        'w:w': prev.width,
+                        'w:type': prev.widthType || 'dxa',
+                    }));
+                }
+                if (prev.columnSpan && prev.columnSpan > 1) {
+                    prevTcPrChildren.push(XMLBuilder.wSelf('gridSpan', { 'w:val': prev.columnSpan }));
+                }
+                if (prev.hMerge) {
+                    prevTcPrChildren.push(XMLBuilder.wSelf('hMerge', { 'w:val': prev.hMerge }));
+                }
+                if (prev.vMerge) {
+                    if (prev.vMerge === 'restart') {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('vMerge', { 'w:val': 'restart' }));
+                    }
+                    else {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('vMerge'));
+                    }
+                }
+                if (prev.borders) {
+                    const borderElements = [];
+                    if (prev.borders.top)
+                        borderElements.push(XMLBuilder.createBorder('top', prev.borders.top));
+                    if (prev.borders.left)
+                        borderElements.push(XMLBuilder.createBorder('left', prev.borders.left));
+                    if (prev.borders.bottom)
+                        borderElements.push(XMLBuilder.createBorder('bottom', prev.borders.bottom));
+                    if (prev.borders.right)
+                        borderElements.push(XMLBuilder.createBorder('right', prev.borders.right));
+                    if (prev.borders.tl2br)
+                        borderElements.push(XMLBuilder.createBorder('tl2br', prev.borders.tl2br));
+                    if (prev.borders.tr2bl)
+                        borderElements.push(XMLBuilder.createBorder('tr2bl', prev.borders.tr2bl));
+                    if (borderElements.length > 0) {
+                        prevTcPrChildren.push(XMLBuilder.w('tcBorders', undefined, borderElements));
+                    }
+                }
+                if (prev.shading) {
+                    const shadingAttrs = buildShadingAttributes(prev.shading);
+                    if (Object.keys(shadingAttrs).length > 0) {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('shd', shadingAttrs));
+                    }
+                }
+                if (prev.noWrap !== undefined) {
+                    if (prev.noWrap) {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('noWrap'));
+                    }
+                    else {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('noWrap', { 'w:val': 'off' }));
+                    }
+                }
+                if (prev.margins) {
+                    const marginChildren = [];
+                    if (prev.margins.top !== undefined) {
+                        marginChildren.push(XMLBuilder.wSelf('top', { 'w:w': prev.margins.top.toString(), 'w:type': 'dxa' }));
+                    }
+                    if (prev.margins.left !== undefined) {
+                        marginChildren.push(XMLBuilder.wSelf('left', { 'w:w': prev.margins.left.toString(), 'w:type': 'dxa' }));
+                    }
+                    if (prev.margins.bottom !== undefined) {
+                        marginChildren.push(XMLBuilder.wSelf('bottom', { 'w:w': prev.margins.bottom.toString(), 'w:type': 'dxa' }));
+                    }
+                    if (prev.margins.right !== undefined) {
+                        marginChildren.push(XMLBuilder.wSelf('right', { 'w:w': prev.margins.right.toString(), 'w:type': 'dxa' }));
+                    }
+                    if (marginChildren.length > 0) {
+                        prevTcPrChildren.push(XMLBuilder.w('tcMar', undefined, marginChildren));
+                    }
+                }
+                if (prev.textDirection) {
+                    prevTcPrChildren.push(XMLBuilder.wSelf('textDirection', { 'w:val': prev.textDirection }));
+                }
+                if (prev.fitText !== undefined) {
+                    if (prev.fitText) {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('tcFitText'));
+                    }
+                    else {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('tcFitText', { 'w:val': 'off' }));
+                    }
+                }
+                if (prev.verticalAlignment) {
+                    prevTcPrChildren.push(XMLBuilder.wSelf('vAlign', { 'w:val': prev.verticalAlignment }));
+                }
+                if (prev.hideMark !== undefined) {
+                    if (prev.hideMark) {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('hideMark'));
+                    }
+                    else {
+                        prevTcPrChildren.push(XMLBuilder.wSelf('hideMark', { 'w:val': 'off' }));
+                    }
+                }
+            }
+            const prevTcPr = prevTcPrChildren.length > 0
+                ? XMLBuilder.w('tcPr', undefined, prevTcPrChildren)
+                : XMLBuilder.w('tcPr', undefined, []);
+            tcPrChildren.push(XMLBuilder.w('tcPrChange', changeAttrs, [prevTcPr]));
+        }
+        const cellChildren = [];
+        if (tcPrChildren.length > 0) {
+            cellChildren.push(XMLBuilder.w('tcPr', undefined, tcPrChildren));
+        }
+        if (this.paragraphs.length > 0 || this.rawNestedContent.length > 0) {
+            const sortedRaw = [...this.rawNestedContent].sort((a, b) => a.position - b.position);
+            let rawIndex = 0;
+            for (let i = 0; i < this.paragraphs.length; i++) {
+                let rawItem = sortedRaw[rawIndex];
+                while (rawIndex < sortedRaw.length && rawItem && rawItem.position <= i) {
+                    cellChildren.push({
+                        name: '__rawXml',
+                        rawXml: rawItem.xml,
+                    });
+                    rawIndex++;
+                    rawItem = sortedRaw[rawIndex];
+                }
+                const para = this.paragraphs[i];
+                if (para) {
+                    cellChildren.push(para.toXML());
+                }
+            }
+            while (rawIndex < sortedRaw.length) {
+                const rawItem = sortedRaw[rawIndex];
+                if (rawItem) {
+                    cellChildren.push({
+                        name: '__rawXml',
+                        rawXml: rawItem.xml,
+                    });
+                }
+                rawIndex++;
+            }
+            if (this.paragraphs.length === 0) {
+                cellChildren.push(new Paragraph().toXML());
+            }
+        }
+        else {
+            cellChildren.push(new Paragraph().toXML());
+        }
+        return XMLBuilder.w('tc', undefined, cellChildren);
+    }
+    static create(formatting) {
+        return new TableCell(formatting);
+    }
+}
+//# sourceMappingURL=TableCell.js.map