docxmlater 10.4.0 → 11.0.4

package/dist/esm/formatting/Style.js

@@ -0,0 +1,1151 @@
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+import { Run } from '../elements/Run.js';
+import { buildShadingAttributes } from '../elements/CommonTypes.js';
+import { deepClone } from '../utils/deepClone.js';
+export class Style {
+    properties;
+    constructor(properties) {
+        this.properties = { ...properties };
+    }
+    getStyleId() {
+        return this.properties.styleId;
+    }
+    getName() {
+        return this.properties.name;
+    }
+    getType() {
+        return this.properties.type;
+    }
+    getProperties() {
+        return { ...this.properties };
+    }
+    getIsDefault() {
+        return this.properties.isDefault ?? false;
+    }
+    setIsDefault(value) {
+        this.properties.isDefault = value;
+        return this;
+    }
+    setBasedOn(styleId) {
+        this.properties.basedOn = styleId;
+        return this;
+    }
+    setNext(styleId) {
+        this.properties.next = styleId;
+        return this;
+    }
+    setParagraphFormatting(formatting) {
+        this.properties.paragraphFormatting = { ...formatting };
+        return this;
+    }
+    setRunFormatting(formatting) {
+        this.properties.runFormatting = { ...formatting };
+        return this;
+    }
+    getRunFormatting() {
+        return this.properties.runFormatting;
+    }
+    getParagraphFormatting() {
+        return this.properties.paragraphFormatting;
+    }
+    setHeading2TableOptions(options) {
+        this.properties.heading2TableOptions = options;
+        return this;
+    }
+    getHeading2TableOptions() {
+        return this.properties.heading2TableOptions;
+    }
+    setQFormat(enabled) {
+        this.properties.qFormat = enabled;
+        return this;
+    }
+    setUiPriority(priority) {
+        if (priority < 0 || priority > 99) {
+            throw new Error('UI priority must be between 0 and 99');
+        }
+        this.properties.uiPriority = priority;
+        return this;
+    }
+    setSemiHidden(hidden) {
+        this.properties.semiHidden = hidden;
+        return this;
+    }
+    setUnhideWhenUsed(enabled) {
+        this.properties.unhideWhenUsed = enabled;
+        return this;
+    }
+    setLocked(locked) {
+        this.properties.locked = locked;
+        return this;
+    }
+    setPersonal(personal) {
+        this.properties.personal = personal;
+        return this;
+    }
+    setPersonalCompose(enabled) {
+        this.properties.personalCompose = enabled;
+        return this;
+    }
+    getPersonalCompose() {
+        return this.properties.personalCompose === true;
+    }
+    setPersonalReply(enabled) {
+        this.properties.personalReply = enabled;
+        return this;
+    }
+    getPersonalReply() {
+        return this.properties.personalReply === true;
+    }
+    setLink(styleId) {
+        this.properties.link = styleId;
+        return this;
+    }
+    setAutoRedefine(enabled) {
+        this.properties.autoRedefine = enabled;
+        return this;
+    }
+    setAliases(aliases) {
+        this.properties.aliases = aliases;
+        return this;
+    }
+    setTableFormatting(formatting) {
+        if (!this.properties.tableStyle) {
+            this.properties.tableStyle = {};
+        }
+        this.properties.tableStyle.table = { ...formatting };
+        return this;
+    }
+    setTableCellFormatting(formatting) {
+        if (!this.properties.tableStyle) {
+            this.properties.tableStyle = {};
+        }
+        this.properties.tableStyle.cell = { ...formatting };
+        return this;
+    }
+    setTableRowFormatting(formatting) {
+        if (!this.properties.tableStyle) {
+            this.properties.tableStyle = {};
+        }
+        this.properties.tableStyle.row = { ...formatting };
+        return this;
+    }
+    setRowBandSize(size) {
+        if (!this.properties.tableStyle) {
+            this.properties.tableStyle = {};
+        }
+        if (size < 0) {
+            throw new Error('Row band size must be non-negative');
+        }
+        this.properties.tableStyle.rowBandSize = size;
+        return this;
+    }
+    setColBandSize(size) {
+        if (!this.properties.tableStyle) {
+            this.properties.tableStyle = {};
+        }
+        if (size < 0) {
+            throw new Error('Column band size must be non-negative');
+        }
+        this.properties.tableStyle.colBandSize = size;
+        return this;
+    }
+    addConditionalFormatting(conditional) {
+        if (!this.properties.tableStyle) {
+            this.properties.tableStyle = {};
+        }
+        if (!this.properties.tableStyle.conditionalFormatting) {
+            this.properties.tableStyle.conditionalFormatting = [];
+        }
+        this.properties.tableStyle.conditionalFormatting.push({ ...conditional });
+        return this;
+    }
+    isValid() {
+        try {
+            if (!this.properties.styleId || !this.properties.name || !this.properties.type) {
+                return false;
+            }
+            const validTypes = ['paragraph', 'character', 'table', 'numbering'];
+            if (!validTypes.includes(this.properties.type)) {
+                return false;
+            }
+            if (this.properties.basedOn === this.properties.styleId) {
+                return false;
+            }
+            if (this.properties.paragraphFormatting) {
+                const pf = this.properties.paragraphFormatting;
+                if (pf.alignment) {
+                    const validAlignments = ['left', 'center', 'right', 'justify', 'both', 'distribute'];
+                    if (!validAlignments.includes(pf.alignment)) {
+                        return false;
+                    }
+                }
+                if (pf.spacing) {
+                    const spacing = pf.spacing;
+                    if (spacing.before !== undefined && spacing.before < 0)
+                        return false;
+                    if (spacing.after !== undefined && spacing.after < 0)
+                        return false;
+                    if (spacing.line !== undefined && spacing.line < 0)
+                        return false;
+                    if (spacing.lineRule && !['auto', 'exact', 'atLeast'].includes(spacing.lineRule)) {
+                        return false;
+                    }
+                }
+                if (pf.indentation) {
+                    const ind = pf.indentation;
+                    if (ind.left !== undefined && ind.left < -100000)
+                        return false;
+                    if (ind.right !== undefined && ind.right < -100000)
+                        return false;
+                }
+            }
+            if (this.properties.runFormatting) {
+                const rf = this.properties.runFormatting;
+                if (rf.size !== undefined && (rf.size <= 0 || rf.size > 1638)) {
+                    return false;
+                }
+                if (rf.color && !/^[0-9A-Fa-f]{6}$/.test(rf.color)) {
+                    return false;
+                }
+                if (rf.highlight) {
+                    const validHighlights = [
+                        'black',
+                        'blue',
+                        'cyan',
+                        'darkBlue',
+                        'darkCyan',
+                        'darkGray',
+                        'darkGreen',
+                        'darkMagenta',
+                        'darkRed',
+                        'darkYellow',
+                        'green',
+                        'lightGray',
+                        'magenta',
+                        'none',
+                        'red',
+                        'white',
+                        'yellow',
+                    ];
+                    if (!validHighlights.includes(rf.highlight)) {
+                        return false;
+                    }
+                }
+            }
+            if (this.properties.uiPriority !== undefined) {
+                if (this.properties.uiPriority < 0 || this.properties.uiPriority > 99) {
+                    return false;
+                }
+            }
+            if (this.properties.link === this.properties.styleId) {
+                return false;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    toXML() {
+        const styleAttrs = {
+            'w:type': this.properties.type,
+            'w:styleId': this.properties.styleId,
+        };
+        if (this.properties.isDefault) {
+            styleAttrs['w:default'] = '1';
+        }
+        if (this.properties.customStyle) {
+            styleAttrs['w:customStyle'] = '1';
+        }
+        const styleChildren = [];
+        styleChildren.push(XMLBuilder.wSelf('name', { 'w:val': this.properties.name }));
+        if (this.properties.aliases) {
+            styleChildren.push(XMLBuilder.wSelf('aliases', { 'w:val': this.properties.aliases }));
+        }
+        if (this.properties.basedOn) {
+            styleChildren.push(XMLBuilder.wSelf('basedOn', { 'w:val': this.properties.basedOn }));
+        }
+        if (this.properties.next) {
+            styleChildren.push(XMLBuilder.wSelf('next', { 'w:val': this.properties.next }));
+        }
+        if (this.properties.link) {
+            styleChildren.push(XMLBuilder.wSelf('link', { 'w:val': this.properties.link }));
+        }
+        if (this.properties.autoRedefine !== undefined) {
+            if (this.properties.autoRedefine) {
+                styleChildren.push(XMLBuilder.wSelf('autoRedefine'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('autoRedefine', { 'w:val': 'off' }));
+            }
+        }
+        if (this.properties.hidden !== undefined) {
+            if (this.properties.hidden) {
+                styleChildren.push(XMLBuilder.wSelf('hidden'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('hidden', { 'w:val': 'off' }));
+            }
+        }
+        if (this.properties.uiPriority !== undefined) {
+            styleChildren.push(XMLBuilder.wSelf('uiPriority', {
+                'w:val': String(this.properties.uiPriority),
+            }));
+        }
+        if (this.properties.semiHidden !== undefined) {
+            if (this.properties.semiHidden) {
+                styleChildren.push(XMLBuilder.wSelf('semiHidden'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('semiHidden', { 'w:val': 'off' }));
+            }
+        }
+        if (this.properties.unhideWhenUsed !== undefined) {
+            if (this.properties.unhideWhenUsed) {
+                styleChildren.push(XMLBuilder.wSelf('unhideWhenUsed'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('unhideWhenUsed', { 'w:val': 'off' }));
+            }
+        }
+        if (this.properties.qFormat !== undefined) {
+            if (this.properties.qFormat) {
+                styleChildren.push(XMLBuilder.wSelf('qFormat'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('qFormat', { 'w:val': 'off' }));
+            }
+        }
+        else if (!this.properties.customStyle) {
+            styleChildren.push(XMLBuilder.wSelf('qFormat'));
+        }
+        if (this.properties.locked !== undefined) {
+            if (this.properties.locked) {
+                styleChildren.push(XMLBuilder.wSelf('locked'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('locked', { 'w:val': 'off' }));
+            }
+        }
+        if (this.properties.personal !== undefined) {
+            if (this.properties.personal) {
+                styleChildren.push(XMLBuilder.wSelf('personal'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('personal', { 'w:val': 'off' }));
+            }
+        }
+        if (this.properties.personalCompose !== undefined) {
+            if (this.properties.personalCompose) {
+                styleChildren.push(XMLBuilder.wSelf('personalCompose'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('personalCompose', { 'w:val': 'off' }));
+            }
+        }
+        if (this.properties.personalReply !== undefined) {
+            if (this.properties.personalReply) {
+                styleChildren.push(XMLBuilder.wSelf('personalReply'));
+            }
+            else {
+                styleChildren.push(XMLBuilder.wSelf('personalReply', { 'w:val': 'off' }));
+            }
+        }
+        if (this.properties.rsid !== undefined && this.properties.rsid !== '') {
+            styleChildren.push(XMLBuilder.wSelf('rsid', { 'w:val': this.properties.rsid }));
+        }
+        if (this.properties.paragraphFormatting || this.properties.numPr) {
+            const pPr = this.generateParagraphProperties(this.properties.paragraphFormatting || {});
+            if (this.properties.numPr) {
+                const numPrChildren = [];
+                if (this.properties.numPr.ilvl !== undefined) {
+                    numPrChildren.push(XMLBuilder.wSelf('ilvl', { 'w:val': String(this.properties.numPr.ilvl) }));
+                }
+                if (this.properties.numPr.numId !== undefined) {
+                    numPrChildren.push(XMLBuilder.wSelf('numId', { 'w:val': String(this.properties.numPr.numId) }));
+                }
+                if (numPrChildren.length > 0) {
+                    const numPrEl = XMLBuilder.w('numPr', undefined, numPrChildren);
+                    if (pPr.children && pPr.children.length > 0) {
+                        const preNumPr = new Set([
+                            'w:keepNext',
+                            'w:keepLines',
+                            'w:pageBreakBefore',
+                            'w:framePr',
+                            'w:widowControl',
+                        ]);
+                        let insertIdx = 0;
+                        for (let i = 0; i < pPr.children.length; i++) {
+                            const child = pPr.children[i];
+                            if (child && typeof child !== 'string' && preNumPr.has(child.name)) {
+                                insertIdx = i + 1;
+                            }
+                        }
+                        pPr.children.splice(insertIdx, 0, numPrEl);
+                    }
+                    else {
+                        pPr.children = [numPrEl];
+                    }
+                }
+            }
+            if (pPr.children && pPr.children.length > 0) {
+                styleChildren.push(pPr);
+            }
+        }
+        if (this.properties.runFormatting) {
+            const rPr = this.generateRunProperties(this.properties.runFormatting);
+            if (rPr.children && rPr.children.length > 0) {
+                styleChildren.push(rPr);
+            }
+        }
+        if (this.properties.tableStyle) {
+            if (this.properties.tableStyle.table) {
+                const tblPr = this.generateTableProperties(this.properties.tableStyle.table, this.properties.tableStyle);
+                if (tblPr.children && tblPr.children.length > 0) {
+                    styleChildren.push(tblPr);
+                }
+            }
+            if (this.properties.tableStyle.row) {
+                const trPr = this.generateTableRowProperties(this.properties.tableStyle.row);
+                if (trPr.children && trPr.children.length > 0) {
+                    styleChildren.push(trPr);
+                }
+            }
+            if (this.properties.tableStyle.cell) {
+                const tcPr = this.generateTableCellProperties(this.properties.tableStyle.cell);
+                if (tcPr.children && tcPr.children.length > 0) {
+                    styleChildren.push(tcPr);
+                }
+            }
+            if (this.properties.tableStyle.conditionalFormatting) {
+                for (const conditional of this.properties.tableStyle.conditionalFormatting) {
+                    const tblStylePr = this.generateConditionalFormatting(conditional);
+                    if (tblStylePr.children && tblStylePr.children.length > 0) {
+                        styleChildren.push(tblStylePr);
+                    }
+                }
+            }
+        }
+        return XMLBuilder.w('style', styleAttrs, styleChildren);
+    }
+    generateParagraphProperties(formatting) {
+        const pPrChildren = [];
+        const emitCtOnOff = (tag, value) => {
+            if (value === undefined)
+                return;
+            pPrChildren.push(value ? XMLBuilder.wSelf(tag) : XMLBuilder.wSelf(tag, { 'w:val': '0' }));
+        };
+        emitCtOnOff('keepNext', formatting.keepNext);
+        emitCtOnOff('keepLines', formatting.keepLines);
+        emitCtOnOff('pageBreakBefore', formatting.pageBreakBefore);
+        if (formatting.framePr) {
+            const f = formatting.framePr;
+            const attrs = {};
+            if (f.w !== undefined)
+                attrs['w:w'] = f.w.toString();
+            if (f.h !== undefined)
+                attrs['w:h'] = f.h.toString();
+            if (f.hRule)
+                attrs['w:hRule'] = f.hRule;
+            if (f.x !== undefined)
+                attrs['w:x'] = f.x.toString();
+            if (f.y !== undefined)
+                attrs['w:y'] = f.y.toString();
+            if (f.xAlign)
+                attrs['w:xAlign'] = f.xAlign;
+            if (f.yAlign)
+                attrs['w:yAlign'] = f.yAlign;
+            if (f.hAnchor)
+                attrs['w:hAnchor'] = f.hAnchor;
+            if (f.vAnchor)
+                attrs['w:vAnchor'] = f.vAnchor;
+            if (f.hSpace !== undefined)
+                attrs['w:hSpace'] = f.hSpace.toString();
+            if (f.vSpace !== undefined)
+                attrs['w:vSpace'] = f.vSpace.toString();
+            if (f.wrap)
+                attrs['w:wrap'] = f.wrap;
+            if (f.dropCap)
+                attrs['w:dropCap'] = f.dropCap;
+            if (f.lines !== undefined)
+                attrs['w:lines'] = f.lines.toString();
+            if (f.anchorLock !== undefined)
+                attrs['w:anchorLock'] = f.anchorLock ? '1' : '0';
+            if (Object.keys(attrs).length > 0) {
+                pPrChildren.push(XMLBuilder.wSelf('framePr', attrs));
+            }
+        }
+        emitCtOnOff('widowControl', formatting.widowControl);
+        emitCtOnOff('suppressLineNumbers', formatting.suppressLineNumbers);
+        if (formatting.borders) {
+            const borderChildren = [];
+            const b = formatting.borders;
+            const createBorder = (tag, def) => {
+                if (!def)
+                    return;
+                const attrs = { 'w:val': def.style ?? 'nil' };
+                if (def.size !== undefined)
+                    attrs['w:sz'] = def.size;
+                if (def.space !== undefined)
+                    attrs['w:space'] = def.space;
+                if (def.color)
+                    attrs['w:color'] = def.color;
+                if (def.themeColor)
+                    attrs['w:themeColor'] = def.themeColor;
+                if (def.themeTint)
+                    attrs['w:themeTint'] = def.themeTint;
+                if (def.themeShade)
+                    attrs['w:themeShade'] = def.themeShade;
+                if (def.shadow !== undefined)
+                    attrs['w:shadow'] = def.shadow ? '1' : '0';
+                if (def.frame !== undefined)
+                    attrs['w:frame'] = def.frame ? '1' : '0';
+                borderChildren.push(XMLBuilder.wSelf(tag, attrs));
+            };
+            createBorder('top', b.top);
+            createBorder('left', b.left);
+            createBorder('bottom', b.bottom);
+            createBorder('right', b.right);
+            createBorder('between', b.between);
+            createBorder('bar', b.bar);
+            if (borderChildren.length > 0) {
+                pPrChildren.push(XMLBuilder.w('pBdr', undefined, borderChildren));
+            }
+        }
+        if (formatting.shading) {
+            const shdAttrs = buildShadingAttributes(formatting.shading);
+            if (Object.keys(shdAttrs).length > 0) {
+                pPrChildren.push(XMLBuilder.wSelf('shd', shdAttrs));
+            }
+        }
+        if (formatting.tabs && formatting.tabs.length > 0) {
+            const tabChildren = [];
+            for (const tab of formatting.tabs) {
+                const attrs = {
+                    'w:val': tab.val ?? 'left',
+                    'w:pos': tab.position,
+                };
+                if (tab.leader)
+                    attrs['w:leader'] = tab.leader;
+                tabChildren.push(XMLBuilder.wSelf('tab', attrs));
+            }
+            if (tabChildren.length > 0) {
+                pPrChildren.push(XMLBuilder.w('tabs', undefined, tabChildren));
+            }
+        }
+        emitCtOnOff('suppressAutoHyphens', formatting.suppressAutoHyphens);
+        emitCtOnOff('kinsoku', formatting.kinsoku);
+        emitCtOnOff('wordWrap', formatting.wordWrap);
+        emitCtOnOff('overflowPunct', formatting.overflowPunct);
+        emitCtOnOff('topLinePunct', formatting.topLinePunct);
+        emitCtOnOff('autoSpaceDE', formatting.autoSpaceDE);
+        emitCtOnOff('autoSpaceDN', formatting.autoSpaceDN);
+        emitCtOnOff('bidi', formatting.bidi);
+        emitCtOnOff('adjustRightInd', formatting.adjustRightInd);
+        if (formatting.spacing) {
+            const spc = formatting.spacing;
+            const attributes = {};
+            if (spc.before !== undefined)
+                attributes['w:before'] = spc.before;
+            if (spc.beforeLines !== undefined)
+                attributes['w:beforeLines'] = spc.beforeLines;
+            if (spc.beforeAutospacing !== undefined) {
+                attributes['w:beforeAutospacing'] = spc.beforeAutospacing ? '1' : '0';
+            }
+            if (spc.after !== undefined)
+                attributes['w:after'] = spc.after;
+            if (spc.afterLines !== undefined)
+                attributes['w:afterLines'] = spc.afterLines;
+            if (spc.afterAutospacing !== undefined) {
+                attributes['w:afterAutospacing'] = spc.afterAutospacing ? '1' : '0';
+            }
+            if (spc.line !== undefined)
+                attributes['w:line'] = spc.line;
+            if (spc.lineRule)
+                attributes['w:lineRule'] = spc.lineRule;
+            if (Object.keys(attributes).length > 0) {
+                pPrChildren.push(XMLBuilder.wSelf('spacing', attributes));
+            }
+        }
+        if (formatting.indentation) {
+            const ind = formatting.indentation;
+            const attributes = {};
+            if (ind.left !== undefined)
+                attributes['w:left'] = ind.left;
+            if (ind.right !== undefined)
+                attributes['w:right'] = ind.right;
+            if (ind.hanging !== undefined) {
+                attributes['w:hanging'] = ind.hanging;
+            }
+            else if (ind.firstLine !== undefined) {
+                attributes['w:firstLine'] = ind.firstLine;
+            }
+            if (ind.leftChars !== undefined)
+                attributes['w:leftChars'] = ind.leftChars;
+            if (ind.rightChars !== undefined)
+                attributes['w:rightChars'] = ind.rightChars;
+            if (ind.hangingChars !== undefined) {
+                attributes['w:hangingChars'] = ind.hangingChars;
+            }
+            else if (ind.firstLineChars !== undefined) {
+                attributes['w:firstLineChars'] = ind.firstLineChars;
+            }
+            if (Object.keys(attributes).length > 0) {
+                pPrChildren.push(XMLBuilder.wSelf('ind', attributes));
+            }
+        }
+        emitCtOnOff('contextualSpacing', formatting.contextualSpacing);
+        emitCtOnOff('mirrorIndents', formatting.mirrorIndents);
+        emitCtOnOff('suppressOverlap', formatting.suppressOverlap);
+        if (formatting.alignment) {
+            const alignmentValue = formatting.alignment === 'justify' ? 'both' : formatting.alignment;
+            pPrChildren.push(XMLBuilder.wSelf('jc', { 'w:val': alignmentValue }));
+        }
+        if (formatting.textDirection) {
+            pPrChildren.push(XMLBuilder.wSelf('textDirection', { 'w:val': formatting.textDirection }));
+        }
+        if (formatting.textAlignment) {
+            pPrChildren.push(XMLBuilder.wSelf('textAlignment', { 'w:val': formatting.textAlignment }));
+        }
+        if (formatting.textboxTightWrap) {
+            pPrChildren.push(XMLBuilder.wSelf('textboxTightWrap', { 'w:val': formatting.textboxTightWrap }));
+        }
+        if (formatting.outlineLevel !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('outlineLvl', { 'w:val': formatting.outlineLevel.toString() }));
+        }
+        if (formatting.divId !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('divId', { 'w:val': formatting.divId.toString() }));
+        }
+        if (formatting.cnfStyle) {
+            pPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': formatting.cnfStyle }));
+        }
+        return XMLBuilder.w('pPr', undefined, pPrChildren);
+    }
+    generateRunProperties(formatting) {
+        const rPr = Run.generateRunPropertiesXML(formatting);
+        return rPr || XMLBuilder.w('rPr', undefined, []);
+    }
+    generateTableProperties(formatting, tableStyle, isConditional = false) {
+        const tblPrChildren = [];
+        if (tableStyle.rowBandSize !== undefined) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblStyleRowBandSize', {
+                'w:val': tableStyle.rowBandSize,
+            }));
+        }
+        if (tableStyle.colBandSize !== undefined) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblStyleColBandSize', {
+                'w:val': tableStyle.colBandSize,
+            }));
+        }
+        if (formatting.alignment) {
+            tblPrChildren.push(XMLBuilder.wSelf('jc', { 'w:val': formatting.alignment }));
+        }
+        if (formatting.cellSpacing !== undefined) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblCellSpacing', {
+                'w:w': formatting.cellSpacing,
+                'w:type': 'dxa',
+            }));
+        }
+        if (formatting.indent !== undefined) {
+            tblPrChildren.push(XMLBuilder.wSelf('tblInd', {
+                'w:w': formatting.indent,
+                'w:type': formatting.indentType || 'dxa',
+            }));
+        }
+        if (formatting.borders) {
+            const borderElements = this.generateBorderElements(formatting.borders, false);
+            if (borderElements.length > 0) {
+                tblPrChildren.push(XMLBuilder.w('tblBorders', undefined, borderElements));
+            }
+        }
+        if (formatting.shading && !isConditional) {
+            tblPrChildren.push(this.generateShadingElement(formatting.shading));
+        }
+        if (formatting.cellMargins) {
+            const marginElements = [];
+            if (formatting.cellMargins.top !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('top', {
+                    'w:w': formatting.cellMargins.top,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (formatting.cellMargins.left !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('left', {
+                    'w:w': formatting.cellMargins.left,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (formatting.cellMargins.bottom !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('bottom', {
+                    'w:w': formatting.cellMargins.bottom,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (formatting.cellMargins.right !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('right', {
+                    'w:w': formatting.cellMargins.right,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (marginElements.length > 0) {
+                tblPrChildren.push(XMLBuilder.w('tblCellMar', undefined, marginElements));
+            }
+        }
+        return XMLBuilder.w('tblPr', undefined, tblPrChildren);
+    }
+    generateTableCellProperties(formatting) {
+        const tcPrChildren = [];
+        if (formatting.borders) {
+            const borderElements = this.generateBorderElements(formatting.borders, true);
+            if (borderElements.length > 0) {
+                tcPrChildren.push(XMLBuilder.w('tcBorders', undefined, borderElements));
+            }
+        }
+        if (formatting.shading) {
+            tcPrChildren.push(this.generateShadingElement(formatting.shading));
+        }
+        if (formatting.margins) {
+            const marginElements = [];
+            if (formatting.margins.top !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('top', {
+                    'w:w': formatting.margins.top,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (formatting.margins.left !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('left', {
+                    'w:w': formatting.margins.left,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (formatting.margins.bottom !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('bottom', {
+                    'w:w': formatting.margins.bottom,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (formatting.margins.right !== undefined) {
+                marginElements.push(XMLBuilder.wSelf('right', {
+                    'w:w': formatting.margins.right,
+                    'w:type': 'dxa',
+                }));
+            }
+            if (marginElements.length > 0) {
+                tcPrChildren.push(XMLBuilder.w('tcMar', undefined, marginElements));
+            }
+        }
+        if (formatting.verticalAlignment) {
+            tcPrChildren.push(XMLBuilder.wSelf('vAlign', { 'w:val': formatting.verticalAlignment }));
+        }
+        return XMLBuilder.w('tcPr', undefined, tcPrChildren);
+    }
+    generateTableRowProperties(formatting) {
+        const trPrChildren = [];
+        if (formatting.cantSplit) {
+            trPrChildren.push(XMLBuilder.wSelf('cantSplit'));
+        }
+        if (formatting.isHeader) {
+            trPrChildren.push(XMLBuilder.wSelf('tblHeader'));
+        }
+        return XMLBuilder.w('trPr', undefined, trPrChildren);
+    }
+    generateConditionalFormatting(conditional) {
+        const tblStylePrChildren = [];
+        if (conditional.paragraphFormatting) {
+            const pPr = this.generateParagraphProperties(conditional.paragraphFormatting);
+            if (pPr.children && pPr.children.length > 0) {
+                tblStylePrChildren.push(pPr);
+            }
+        }
+        if (conditional.runFormatting) {
+            const rPr = this.generateRunProperties(conditional.runFormatting);
+            if (rPr.children && rPr.children.length > 0) {
+                tblStylePrChildren.push(rPr);
+            }
+        }
+        if (conditional.tableFormatting) {
+            const tblPr = this.generateTableProperties(conditional.tableFormatting, {}, true);
+            if (tblPr.children && tblPr.children.length > 0) {
+                tblStylePrChildren.push(tblPr);
+            }
+        }
+        if (conditional.rowFormatting) {
+            const trPr = this.generateTableRowProperties(conditional.rowFormatting);
+            if (trPr.children && trPr.children.length > 0) {
+                tblStylePrChildren.push(trPr);
+            }
+        }
+        if (conditional.cellFormatting) {
+            const tcPr = this.generateTableCellProperties(conditional.cellFormatting);
+            if (tcPr.children && tcPr.children.length > 0) {
+                tblStylePrChildren.push(tcPr);
+            }
+        }
+        return XMLBuilder.w('tblStylePr', { 'w:type': conditional.type }, tblStylePrChildren);
+    }
+    generateBorderElements(borders, includeDiagonals) {
+        const borderElements = [];
+        const borderProps = ['top', 'left', 'bottom', 'right', 'insideH', 'insideV'];
+        for (const prop of borderProps) {
+            const border = borders[prop];
+            if (border) {
+                const attrs = { 'w:val': border.style ?? 'nil' };
+                if (border.size !== undefined)
+                    attrs['w:sz'] = border.size;
+                if (border.space !== undefined)
+                    attrs['w:space'] = border.space;
+                if (border.color)
+                    attrs['w:color'] = border.color;
+                const b = border;
+                if (b.themeColor)
+                    attrs['w:themeColor'] = b.themeColor;
+                if (b.themeTint)
+                    attrs['w:themeTint'] = b.themeTint;
+                if (b.themeShade)
+                    attrs['w:themeShade'] = b.themeShade;
+                if (b.shadow !== undefined)
+                    attrs['w:shadow'] = b.shadow ? '1' : '0';
+                if (b.frame !== undefined)
+                    attrs['w:frame'] = b.frame ? '1' : '0';
+                borderElements.push(XMLBuilder.wSelf(prop, attrs));
+            }
+        }
+        const buildDiagonalAttrs = (b) => {
+            const attrs = { 'w:val': b.style ?? 'nil' };
+            if (b.size !== undefined)
+                attrs['w:sz'] = b.size;
+            if (b.space !== undefined)
+                attrs['w:space'] = b.space;
+            if (b.color)
+                attrs['w:color'] = b.color;
+            if (b.themeColor)
+                attrs['w:themeColor'] = b.themeColor;
+            if (b.themeTint)
+                attrs['w:themeTint'] = b.themeTint;
+            if (b.themeShade)
+                attrs['w:themeShade'] = b.themeShade;
+            if (b.shadow !== undefined)
+                attrs['w:shadow'] = b.shadow ? '1' : '0';
+            if (b.frame !== undefined)
+                attrs['w:frame'] = b.frame ? '1' : '0';
+            return attrs;
+        };
+        if (includeDiagonals) {
+            const cellBorders = borders;
+            if (cellBorders.tl2br) {
+                borderElements.push(XMLBuilder.wSelf('tl2br', buildDiagonalAttrs(cellBorders.tl2br)));
+            }
+            if (cellBorders.tr2bl) {
+                borderElements.push(XMLBuilder.wSelf('tr2bl', buildDiagonalAttrs(cellBorders.tr2bl)));
+            }
+        }
+        return borderElements;
+    }
+    generateShadingElement(shading) {
+        const attrs = buildShadingAttributes(shading);
+        return XMLBuilder.wSelf('shd', attrs);
+    }
+    static create(properties) {
+        return new Style(properties);
+    }
+    static createNormalStyle() {
+        return new Style({
+            styleId: 'Normal',
+            name: 'Normal',
+            type: 'paragraph',
+            isDefault: true,
+            next: 'Normal',
+            qFormat: true,
+            uiPriority: 0,
+            paragraphFormatting: {
+                alignment: 'left',
+                spacing: {
+                    before: 60,
+                    after: 60,
+                    line: 240,
+                    lineRule: 'auto',
+                },
+            },
+            runFormatting: {
+                font: 'Verdana',
+                size: 12,
+                color: '000000',
+            },
+        });
+    }
+    static createHeadingStyle(level) {
+        if (level < 1 || level > 9) {
+            throw new Error('Heading level must be between 1 and 9');
+        }
+        const sizes = [18, 14, 12, 12, 12, 12, 12, 12, 12];
+        const spacingBefore = level === 1 ? 0 : level === 2 ? 120 : level === 3 ? 60 : 120;
+        const spacingAfter = level === 1 ? 240 : level === 2 ? 120 : level === 3 ? 60 : 120;
+        return new Style({
+            styleId: `Heading${level}`,
+            name: `Heading ${level}`,
+            type: 'paragraph',
+            basedOn: 'Normal',
+            next: 'Normal',
+            link: `Heading${level}Char`,
+            qFormat: true,
+            uiPriority: 9,
+            paragraphFormatting: {
+                alignment: 'left',
+                spacing: {
+                    before: spacingBefore,
+                    after: spacingAfter,
+                    line: 240,
+                    lineRule: 'auto',
+                },
+                keepNext: true,
+                keepLines: true,
+                outlineLevel: level - 1,
+            },
+            runFormatting: {
+                font: 'Verdana',
+                size: sizes[level - 1],
+                bold: true,
+                color: '000000',
+            },
+        });
+    }
+    static createHeadingCharStyle(level) {
+        if (level < 1 || level > 9) {
+            throw new Error('Heading level must be between 1 and 9');
+        }
+        const sizes = [18, 14, 12, 12, 12, 12, 12, 12, 12];
+        return new Style({
+            styleId: `Heading${level}Char`,
+            name: `Heading ${level} Char`,
+            type: 'character',
+            link: `Heading${level}`,
+            qFormat: true,
+            uiPriority: 9,
+            runFormatting: {
+                font: 'Verdana',
+                size: sizes[level - 1],
+                bold: true,
+                color: '000000',
+            },
+        });
+    }
+    static createTitleStyle() {
+        return new Style({
+            styleId: 'Title',
+            name: 'Title',
+            type: 'paragraph',
+            basedOn: 'Normal',
+            next: 'Normal',
+            paragraphFormatting: {
+                spacing: {
+                    after: 120,
+                },
+            },
+            runFormatting: {
+                font: 'Verdana',
+                size: 28,
+                color: '000000',
+            },
+        });
+    }
+    static createSubtitleStyle() {
+        return new Style({
+            styleId: 'Subtitle',
+            name: 'Subtitle',
+            type: 'paragraph',
+            basedOn: 'Normal',
+            next: 'Normal',
+            paragraphFormatting: {
+                spacing: {
+                    after: 120,
+                },
+            },
+            runFormatting: {
+                font: 'Verdana',
+                size: 14,
+                color: '000000',
+                italic: true,
+            },
+        });
+    }
+    static createListParagraphStyle() {
+        return new Style({
+            styleId: 'ListParagraph',
+            name: 'List Paragraph',
+            type: 'paragraph',
+            basedOn: 'Normal',
+            next: 'ListParagraph',
+            qFormat: true,
+            uiPriority: 34,
+            paragraphFormatting: {
+                alignment: 'left',
+                indentation: {
+                    left: 720,
+                    hanging: 360,
+                },
+                spacing: {
+                    before: 0,
+                    after: 60,
+                    line: 240,
+                    lineRule: 'auto',
+                },
+                contextualSpacing: true,
+            },
+            runFormatting: {
+                font: 'Verdana',
+                size: 12,
+                color: '000000',
+            },
+        });
+    }
+    static createTOCHeadingStyle() {
+        return new Style({
+            styleId: 'TOCHeading',
+            name: 'TOC Heading',
+            type: 'paragraph',
+            basedOn: 'Heading1',
+            next: 'Normal',
+            runFormatting: {
+                bold: true,
+                font: 'Verdana',
+                size: 14,
+                color: '000000',
+            },
+            paragraphFormatting: {
+                spacing: {
+                    before: 480,
+                    after: 240,
+                },
+            },
+        });
+    }
+    static createTOCStyle(level, formatting) {
+        if (level < 1 || level > 9) {
+            throw new Error('TOC level must be between 1 and 9');
+        }
+        const defaultLeftIndent = (level - 1) * 220;
+        return Style.create({
+            styleId: `TOC${level}`,
+            name: `toc ${level}`,
+            type: 'paragraph',
+            basedOn: 'Normal',
+            uiPriority: 39,
+            semiHidden: true,
+            unhideWhenUsed: true,
+            runFormatting: formatting?.run,
+            paragraphFormatting: {
+                indentation: { left: defaultLeftIndent },
+                ...formatting?.paragraph,
+            },
+        });
+    }
+    static createTableNormalStyle() {
+        return new Style({
+            styleId: 'TableNormal',
+            name: 'Table Normal',
+            type: 'table',
+            basedOn: 'Normal',
+            tableStyle: {
+                table: {
+                    cellMargins: {
+                        top: 0,
+                        left: 108,
+                        bottom: 0,
+                        right: 108,
+                    },
+                },
+                rowBandSize: 1,
+                colBandSize: 1,
+            },
+        });
+    }
+    static createTableGridStyle() {
+        return new Style({
+            styleId: 'TableGrid',
+            name: 'Table Grid',
+            type: 'table',
+            basedOn: 'TableNormal',
+            tableStyle: {
+                table: {
+                    borders: {
+                        top: { style: 'single', size: 4, color: '000000' },
+                        bottom: { style: 'single', size: 4, color: '000000' },
+                        left: { style: 'single', size: 4, color: '000000' },
+                        right: { style: 'single', size: 4, color: '000000' },
+                        insideH: { style: 'single', size: 4, color: '000000' },
+                        insideV: { style: 'single', size: 4, color: '000000' },
+                    },
+                    cellMargins: {
+                        top: 0,
+                        left: 108,
+                        bottom: 0,
+                        right: 108,
+                    },
+                },
+                rowBandSize: 1,
+                colBandSize: 1,
+            },
+        });
+    }
+    clone() {
+        const clonedProps = deepClone(this.properties);
+        return new Style(clonedProps);
+    }
+    reset() {
+        const { styleId, name, type, basedOn } = this.properties;
+        this.properties = {
+            styleId,
+            name,
+            type,
+            basedOn,
+        };
+        return this;
+    }
+    mergeWith(otherStyle) {
+        const otherProps = otherStyle.getProperties();
+        if (otherProps.paragraphFormatting) {
+            if (!this.properties.paragraphFormatting) {
+                this.properties.paragraphFormatting = {};
+            }
+            if (otherProps.paragraphFormatting.alignment) {
+                this.properties.paragraphFormatting.alignment = otherProps.paragraphFormatting.alignment;
+            }
+            if (otherProps.paragraphFormatting.keepNext !== undefined) {
+                this.properties.paragraphFormatting.keepNext = otherProps.paragraphFormatting.keepNext;
+            }
+            if (otherProps.paragraphFormatting.keepLines !== undefined) {
+                this.properties.paragraphFormatting.keepLines = otherProps.paragraphFormatting.keepLines;
+            }
+            if (otherProps.paragraphFormatting.pageBreakBefore !== undefined) {
+                this.properties.paragraphFormatting.pageBreakBefore =
+                    otherProps.paragraphFormatting.pageBreakBefore;
+            }
+            if (otherProps.paragraphFormatting.indentation) {
+                if (!this.properties.paragraphFormatting.indentation) {
+                    this.properties.paragraphFormatting.indentation = {};
+                }
+                Object.assign(this.properties.paragraphFormatting.indentation, otherProps.paragraphFormatting.indentation);
+            }
+            if (otherProps.paragraphFormatting.spacing) {
+                if (!this.properties.paragraphFormatting.spacing) {
+                    this.properties.paragraphFormatting.spacing = {};
+                }
+                Object.assign(this.properties.paragraphFormatting.spacing, otherProps.paragraphFormatting.spacing);
+            }
+        }
+        if (otherProps.runFormatting) {
+            if (!this.properties.runFormatting) {
+                this.properties.runFormatting = {};
+            }
+            Object.assign(this.properties.runFormatting, otherProps.runFormatting);
+        }
+        if (otherProps.name)
+            this.properties.name = otherProps.name;
+        if (otherProps.basedOn)
+            this.properties.basedOn = otherProps.basedOn;
+        if (otherProps.next)
+            this.properties.next = otherProps.next;
+        return this;
+    }
+}
+//# sourceMappingURL=Style.js.map