docxmlater 10.4.0 → 11.0.4

package/dist/esm/elements/Run.js

@@ -0,0 +1,1465 @@
+import { deepClone } from '../utils/deepClone.js';
+import { formatDateForXml } from '../utils/dateFormatting.js';
+import { isEqualFormatting } from '../utils/formatting.js';
+import { logSerialization, logTextDirection } from '../utils/diagnostics.js';
+import { defaultLogger } from '../utils/logger.js';
+import { normalizeColor, validateRunText } from '../utils/validation.js';
+import { pointsToHalfPoints } from '../utils/units.js';
+import { diffText, diffHasUnchangedParts } from '../utils/textDiff.js';
+import { getActiveConditionalsInPriorityOrder } from '../processors/cnfStyleDecoder.js';
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+import { buildShadingAttributes, } from './CommonTypes.js';
+export class Run {
+    content;
+    formatting;
+    trackingContext;
+    propertyChangeRevision;
+    _parentParagraph;
+    constructor(text, formatting = {}) {
+        if (text === undefined || text === null) {
+            defaultLogger.warn(`DocXML Text Validation Warning [Run constructor]:\n` +
+                `  - Received ${text === undefined ? 'undefined' : 'null'} text value\n` +
+                `  - Converting to empty string for Word compatibility`);
+        }
+        const shouldClean = formatting.cleanXmlFromText !== false;
+        const validation = validateRunText(text, {
+            context: 'Run constructor',
+            autoClean: shouldClean,
+            warnToConsole: true,
+        });
+        const cleanedText = validation.cleanedText || text;
+        const normalizedText = cleanedText ?? '';
+        this.content = this.parseTextWithSpecialCharacters(normalizedText);
+        const { cleanXmlFromText, ...displayFormatting } = formatting;
+        this.formatting = displayFormatting;
+    }
+    parseTextWithSpecialCharacters(text) {
+        if (!text) {
+            return [{ type: 'text', value: '' }];
+        }
+        const content = [];
+        let currentText = '';
+        for (let i = 0; i < text.length; i++) {
+            const char = text[i];
+            switch (char) {
+                case '\t':
+                    if (currentText) {
+                        content.push({ type: 'text', value: currentText });
+                        currentText = '';
+                    }
+                    content.push({ type: 'tab' });
+                    break;
+                case '\n':
+                    if (currentText) {
+                        content.push({ type: 'text', value: currentText });
+                        currentText = '';
+                    }
+                    content.push({ type: 'break' });
+                    break;
+                case '\u2011':
+                    if (currentText) {
+                        content.push({ type: 'text', value: currentText });
+                        currentText = '';
+                    }
+                    content.push({ type: 'noBreakHyphen' });
+                    break;
+                case '\r':
+                    if (currentText) {
+                        content.push({ type: 'text', value: currentText });
+                        currentText = '';
+                    }
+                    content.push({ type: 'carriageReturn' });
+                    break;
+                case '\u00AD':
+                    if (currentText) {
+                        content.push({ type: 'text', value: currentText });
+                        currentText = '';
+                    }
+                    content.push({ type: 'softHyphen' });
+                    break;
+                default:
+                    currentText += char;
+                    break;
+            }
+        }
+        if (currentText) {
+            content.push({ type: 'text', value: currentText });
+        }
+        if (content.length === 0) {
+            content.push({ type: 'text', value: '' });
+        }
+        return content;
+    }
+    getText() {
+        return this.content
+            .map((c) => {
+            switch (c.type) {
+                case 'text':
+                    return c.value || '';
+                case 'tab':
+                    return '\t';
+                case 'break':
+                    return '\n';
+                case 'carriageReturn':
+                    return '\r';
+                case 'softHyphen':
+                    return '\u00AD';
+                case 'noBreakHyphen':
+                    return '\u2011';
+                case 'instructionText':
+                    return '';
+                case 'fieldChar':
+                    return '';
+                default:
+                    return '';
+            }
+        })
+            .join('');
+    }
+    getPlainText() {
+        return this.content
+            .filter((c) => c.type === 'text')
+            .map((c) => c.value || '')
+            .join('');
+    }
+    equals(other) {
+        if (this.getText() !== other.getText())
+            return false;
+        return isEqualFormatting(this.getFormatting(), other.getFormatting());
+    }
+    hasSameFormatting(other) {
+        return isEqualFormatting(this.getFormatting(), other.getFormatting());
+    }
+    setText(text) {
+        const oldText = this.getText();
+        const oldContent = [...this.content];
+        if (text === undefined || text === null) {
+            defaultLogger.warn(`DocXML Text Validation Warning [Run.setText]:\n` +
+                `  - Received ${text === undefined ? 'undefined' : 'null'} text value\n` +
+                `  - Converting to empty string for Word compatibility`);
+        }
+        const shouldClean = this.formatting.cleanXmlFromText !== false;
+        const validation = validateRunText(text, {
+            context: 'Run.setText',
+            autoClean: shouldClean,
+            warnToConsole: true,
+        });
+        const cleanedText = validation.cleanedText || text;
+        const normalizedText = cleanedText ?? '';
+        const isAllInstructionText = this.content.length > 0 && this.content.every((c) => c.type === 'instructionText');
+        if (isAllInstructionText) {
+            this.content = [{ type: 'instructionText', value: normalizedText }];
+        }
+        else {
+            this.content = this.parseTextWithSpecialCharacters(normalizedText);
+        }
+        if (this.trackingContext?.isEnabled() &&
+            this._parentParagraph &&
+            oldText !== normalizedText &&
+            oldText) {
+            const hasNonTextContent = oldContent.some((c) => c.type === 'vml' ||
+                c.type === 'fieldChar' ||
+                c.type === 'symbol' ||
+                c.type === 'embeddedObject');
+            const segments = hasNonTextContent ? [] : diffText(oldText, normalizedText);
+            const useGranular = !hasNonTextContent && diffHasUnchangedParts(segments);
+            if (useGranular) {
+                const revManager = this.trackingContext.getRevisionManager();
+                const now = new Date();
+                const newContent = [];
+                for (const seg of segments) {
+                    if (seg.type === 'equal') {
+                        const equalRun = this.clone();
+                        equalRun.content = this.parseTextWithSpecialCharacters(seg.text);
+                        equalRun._setTrackingContext(this.trackingContext);
+                        equalRun._setParentParagraph(this._parentParagraph);
+                        newContent.push(equalRun);
+                    }
+                    else if (seg.type === 'delete') {
+                        const delRun = this.clone();
+                        delRun.content = this.parseTextWithSpecialCharacters(seg.text);
+                        const delRev = this.trackingContext.createDeletion(delRun, now);
+                        revManager.register(delRev);
+                        newContent.push(delRev);
+                    }
+                    else if (seg.type === 'insert') {
+                        const insRun = this.clone();
+                        insRun.content = this.parseTextWithSpecialCharacters(seg.text);
+                        const insRev = this.trackingContext.createInsertion(insRun, now);
+                        revManager.register(insRev);
+                        newContent.push(insRev);
+                    }
+                }
+                this._parentParagraph.replaceContent(this, newContent);
+            }
+            else {
+                const revManager = this.trackingContext.getRevisionManager();
+                const now = new Date();
+                const deleteRun = this.clone();
+                deleteRun.content = this.parseTextWithSpecialCharacters(oldText);
+                const deleteRev = this.trackingContext.createDeletion(deleteRun, now);
+                revManager.register(deleteRev);
+                const insertRev = this.trackingContext.createInsertion(this, now);
+                revManager.register(insertRev);
+                this._parentParagraph.replaceContent(this, [deleteRev, insertRev]);
+            }
+        }
+    }
+    getFormatting() {
+        return { ...this.formatting };
+    }
+    getBold() {
+        return this.formatting.bold ?? false;
+    }
+    getItalic() {
+        return this.formatting.italic ?? false;
+    }
+    getUnderline() {
+        return this.formatting.underline;
+    }
+    getStrike() {
+        return this.formatting.strike ?? false;
+    }
+    getFont() {
+        return this.formatting.font;
+    }
+    getSize() {
+        return this.formatting.size;
+    }
+    getColor() {
+        return this.formatting.color;
+    }
+    getHighlight() {
+        return this.formatting.highlight;
+    }
+    getSubscript() {
+        return this.formatting.subscript ?? false;
+    }
+    getSuperscript() {
+        return this.formatting.superscript ?? false;
+    }
+    isRTL() {
+        return this.formatting.rtl ?? false;
+    }
+    getSmallCaps() {
+        return this.formatting.smallCaps ?? false;
+    }
+    getAllCaps() {
+        return this.formatting.allCaps ?? false;
+    }
+    getEffectiveBold() {
+        if (this.formatting.bold !== undefined) {
+            return this.formatting.bold;
+        }
+        return this.getConditionalFormattingProperty('bold');
+    }
+    getEffectiveItalic() {
+        if (this.formatting.italic !== undefined) {
+            return this.formatting.italic;
+        }
+        return this.getConditionalFormattingProperty('italic');
+    }
+    getEffectiveColor() {
+        if (this.formatting.color !== undefined) {
+            return this.formatting.color;
+        }
+        return this.getConditionalFormattingProperty('color');
+    }
+    getEffectiveFont() {
+        if (this.formatting.font !== undefined) {
+            return this.formatting.font;
+        }
+        return this.getConditionalFormattingProperty('font');
+    }
+    getEffectiveSize() {
+        if (this.formatting.size !== undefined) {
+            return this.formatting.size;
+        }
+        return this.getConditionalFormattingProperty('size');
+    }
+    isHyperlinkStyled() {
+        return this.formatting.characterStyle === 'Hyperlink';
+    }
+    getConditionalFormattingProperty(property) {
+        const para = this._parentParagraph;
+        if (!para)
+            return undefined;
+        const cell = para._getParentCell();
+        if (!cell)
+            return undefined;
+        const cnfStyle = para.getTableConditionalStyle();
+        if (!cnfStyle)
+            return undefined;
+        const activeConditionals = getActiveConditionalsInPriorityOrder(cnfStyle);
+        const tableStyleId = cell.getTableStyleId();
+        const stylesManager = para._getStylesManager();
+        if (tableStyleId && stylesManager) {
+            const style = stylesManager.getStyle(tableStyleId);
+            if (style) {
+                const tableStyleProps = style.getProperties().tableStyle;
+                if (tableStyleProps?.conditionalFormatting) {
+                    for (const conditionalType of activeConditionals) {
+                        const conditional = tableStyleProps.conditionalFormatting.find((cf) => cf.type === conditionalType);
+                        if (conditional?.runFormatting?.[property] !== undefined) {
+                            return conditional.runFormatting[property];
+                        }
+                    }
+                    const wholeTable = tableStyleProps.conditionalFormatting.find((cf) => cf.type === 'wholeTable');
+                    if (wholeTable?.runFormatting?.[property] !== undefined) {
+                        return wholeTable.runFormatting[property];
+                    }
+                }
+            }
+        }
+        if (property === 'bold' && activeConditionals.length > 0) {
+            const table = cell._getParentRow()?._getParentTable();
+            if (table) {
+                const tblLookFlags = table.getTblLookFlags();
+                for (const conditionalType of activeConditionals) {
+                    if (conditionalType === 'firstRow' && tblLookFlags.firstRow)
+                        return true;
+                    if (conditionalType === 'lastRow' && tblLookFlags.lastRow)
+                        return true;
+                    if (conditionalType === 'firstCol' && tblLookFlags.firstColumn)
+                        return true;
+                    if (conditionalType === 'lastCol' && tblLookFlags.lastColumn)
+                        return true;
+                }
+            }
+        }
+        return undefined;
+    }
+    setCharacterStyle(styleId) {
+        const previousValue = this.formatting.characterStyle;
+        this.formatting.characterStyle = styleId;
+        if (this.trackingContext?.isEnabled() && previousValue !== styleId) {
+            this.trackingContext.trackRunPropertyChange(this, 'characterStyle', previousValue, styleId);
+        }
+        return this;
+    }
+    setBorder(border) {
+        const previousValue = this.formatting.border;
+        this.formatting.border = border;
+        if (this.trackingContext?.isEnabled() && previousValue !== border) {
+            this.trackingContext.trackRunPropertyChange(this, 'border', previousValue, border);
+        }
+        return this;
+    }
+    setShading(shading) {
+        const previousValue = this.formatting.shading;
+        this.formatting.shading = shading;
+        if (this.trackingContext?.isEnabled() && previousValue !== shading) {
+            this.trackingContext.trackRunPropertyChange(this, 'shading', previousValue, shading);
+        }
+        return this;
+    }
+    setEmphasis(emphasis) {
+        const previousValue = this.formatting.emphasis;
+        this.formatting.emphasis = emphasis;
+        if (this.trackingContext?.isEnabled() && previousValue !== emphasis) {
+            this.trackingContext.trackRunPropertyChange(this, 'emphasis', previousValue, emphasis);
+        }
+        return this;
+    }
+    _setTrackingContext(context) {
+        this.trackingContext = context;
+    }
+    _setParentParagraph(paragraph) {
+        this._parentParagraph = paragraph;
+    }
+    _getParentParagraph() {
+        return this._parentParagraph;
+    }
+    getPropertyChangeRevision() {
+        return this.propertyChangeRevision;
+    }
+    setPropertyChangeRevision(propChange) {
+        this.propertyChangeRevision = propChange;
+        return this;
+    }
+    clearPropertyChangeRevision() {
+        this.propertyChangeRevision = undefined;
+        return this;
+    }
+    hasPropertyChangeRevision() {
+        return this.propertyChangeRevision !== undefined;
+    }
+    setBold(bold = true) {
+        const previousValue = this.formatting.bold;
+        this.formatting.bold = bold;
+        if (this.trackingContext?.isEnabled() && previousValue !== bold) {
+            this.trackingContext.trackRunPropertyChange(this, 'bold', previousValue, bold);
+        }
+        return this;
+    }
+    setItalic(italic = true) {
+        const previousValue = this.formatting.italic;
+        this.formatting.italic = italic;
+        if (this.trackingContext?.isEnabled() && previousValue !== italic) {
+            this.trackingContext.trackRunPropertyChange(this, 'italic', previousValue, italic);
+        }
+        return this;
+    }
+    setComplexScriptBold(bold = true) {
+        const previousValue = this.formatting.complexScriptBold;
+        this.formatting.complexScriptBold = bold;
+        if (this.trackingContext?.isEnabled() && previousValue !== bold) {
+            this.trackingContext.trackRunPropertyChange(this, 'complexScriptBold', previousValue, bold);
+        }
+        return this;
+    }
+    setComplexScriptItalic(italic = true) {
+        const previousValue = this.formatting.complexScriptItalic;
+        this.formatting.complexScriptItalic = italic;
+        if (this.trackingContext?.isEnabled() && previousValue !== italic) {
+            this.trackingContext.trackRunPropertyChange(this, 'complexScriptItalic', previousValue, italic);
+        }
+        return this;
+    }
+    setCharacterSpacing(spacing) {
+        const previousValue = this.formatting.characterSpacing;
+        this.formatting.characterSpacing = spacing;
+        if (this.trackingContext?.isEnabled() && previousValue !== spacing) {
+            this.trackingContext.trackRunPropertyChange(this, 'characterSpacing', previousValue, spacing);
+        }
+        return this;
+    }
+    setScaling(scaling) {
+        const previousValue = this.formatting.scaling;
+        this.formatting.scaling = scaling;
+        if (this.trackingContext?.isEnabled() && previousValue !== scaling) {
+            this.trackingContext.trackRunPropertyChange(this, 'scaling', previousValue, scaling);
+        }
+        return this;
+    }
+    setPosition(position) {
+        const previousValue = this.formatting.position;
+        this.formatting.position = position;
+        if (this.trackingContext?.isEnabled() && previousValue !== position) {
+            this.trackingContext.trackRunPropertyChange(this, 'position', previousValue, position);
+        }
+        return this;
+    }
+    setKerning(kerning) {
+        const previousValue = this.formatting.kerning;
+        this.formatting.kerning = kerning;
+        if (this.trackingContext?.isEnabled() && previousValue !== kerning) {
+            this.trackingContext.trackRunPropertyChange(this, 'kerning', previousValue, kerning);
+        }
+        return this;
+    }
+    setLanguage(language) {
+        const previousValue = this.formatting.language;
+        this.formatting.language = language;
+        if (this.trackingContext?.isEnabled() && previousValue !== language) {
+            this.trackingContext.trackRunPropertyChange(this, 'language', previousValue, language);
+        }
+        return this;
+    }
+    setUnderline(underline = true) {
+        const previousValue = this.formatting.underline;
+        this.formatting.underline = underline;
+        if (this.trackingContext?.isEnabled() && previousValue !== underline) {
+            this.trackingContext.trackRunPropertyChange(this, 'underline', previousValue, underline);
+        }
+        return this;
+    }
+    setUnderlineColor(color) {
+        this.formatting.underlineColor = normalizeColor(color);
+        return this;
+    }
+    setUnderlineThemeColor(themeColor, themeTint, themeShade) {
+        this.formatting.underlineThemeColor = themeColor;
+        if (themeTint !== undefined)
+            this.formatting.underlineThemeTint = themeTint;
+        if (themeShade !== undefined)
+            this.formatting.underlineThemeShade = themeShade;
+        return this;
+    }
+    setStrike(strike = true) {
+        const previousValue = this.formatting.strike;
+        this.formatting.strike = strike;
+        if (this.trackingContext?.isEnabled() && previousValue !== strike) {
+            this.trackingContext.trackRunPropertyChange(this, 'strike', previousValue, strike);
+        }
+        return this;
+    }
+    setSubscript(subscript = true) {
+        const previousValue = this.formatting.subscript;
+        this.formatting.subscript = subscript;
+        if (subscript) {
+            this.formatting.superscript = false;
+        }
+        if (this.trackingContext?.isEnabled() && previousValue !== subscript) {
+            this.trackingContext.trackRunPropertyChange(this, 'subscript', previousValue, subscript);
+        }
+        return this;
+    }
+    setSuperscript(superscript = true) {
+        const previousValue = this.formatting.superscript;
+        this.formatting.superscript = superscript;
+        if (superscript) {
+            this.formatting.subscript = false;
+        }
+        if (this.trackingContext?.isEnabled() && previousValue !== superscript) {
+            this.trackingContext.trackRunPropertyChange(this, 'superscript', previousValue, superscript);
+        }
+        return this;
+    }
+    setFont(font, size) {
+        const previousFont = this.formatting.font;
+        const previousSize = this.formatting.size;
+        this.formatting.font = font;
+        if (size !== undefined) {
+            this.formatting.size = size;
+        }
+        if (this.trackingContext?.isEnabled()) {
+            if (previousFont !== font) {
+                this.trackingContext.trackRunPropertyChange(this, 'font', previousFont, font);
+            }
+            if (size !== undefined && previousSize !== size) {
+                this.trackingContext.trackRunPropertyChange(this, 'size', previousSize, size);
+            }
+        }
+        return this;
+    }
+    setSize(size) {
+        const previousValue = this.formatting.size;
+        this.formatting.size = size;
+        if (this.trackingContext?.isEnabled() && previousValue !== size) {
+            this.trackingContext.trackRunPropertyChange(this, 'size', previousValue, size);
+        }
+        return this;
+    }
+    setSizeCs(size) {
+        const previousValue = this.formatting.sizeCs;
+        this.formatting.sizeCs = size;
+        if (this.trackingContext?.isEnabled() && previousValue !== size) {
+            this.trackingContext.trackRunPropertyChange(this, 'sizeCs', previousValue, size);
+        }
+        return this;
+    }
+    setColor(color) {
+        const previousValue = this.formatting.color;
+        const normalizedColor = normalizeColor(color);
+        this.formatting.color = normalizedColor;
+        if (this.trackingContext?.isEnabled() && previousValue !== normalizedColor) {
+            this.trackingContext.trackRunPropertyChange(this, 'color', previousValue, normalizedColor);
+        }
+        return this;
+    }
+    setThemeColor(themeColor) {
+        const previousValue = this.formatting.themeColor;
+        this.formatting.themeColor = themeColor;
+        if (this.trackingContext?.isEnabled() && previousValue !== themeColor) {
+            this.trackingContext.trackRunPropertyChange(this, 'themeColor', previousValue, themeColor);
+        }
+        return this;
+    }
+    setThemeTint(themeTint) {
+        const previousValue = this.formatting.themeTint;
+        this.formatting.themeTint = themeTint;
+        if (this.trackingContext?.isEnabled() && previousValue !== themeTint) {
+            this.trackingContext.trackRunPropertyChange(this, 'themeTint', previousValue, themeTint);
+        }
+        return this;
+    }
+    setThemeShade(themeShade) {
+        const previousValue = this.formatting.themeShade;
+        this.formatting.themeShade = themeShade;
+        if (this.trackingContext?.isEnabled() && previousValue !== themeShade) {
+            this.trackingContext.trackRunPropertyChange(this, 'themeShade', previousValue, themeShade);
+        }
+        return this;
+    }
+    setHighlight(highlight) {
+        const previousValue = this.formatting.highlight;
+        this.formatting.highlight = highlight;
+        if (this.trackingContext?.isEnabled() && previousValue !== highlight) {
+            this.trackingContext.trackRunPropertyChange(this, 'highlight', previousValue, highlight);
+        }
+        return this;
+    }
+    setSmallCaps(smallCaps = true) {
+        const previousValue = this.formatting.smallCaps;
+        this.formatting.smallCaps = smallCaps;
+        if (this.trackingContext?.isEnabled() && previousValue !== smallCaps) {
+            this.trackingContext.trackRunPropertyChange(this, 'smallCaps', previousValue, smallCaps);
+        }
+        return this;
+    }
+    setAllCaps(allCaps = true) {
+        const previousValue = this.formatting.allCaps;
+        this.formatting.allCaps = allCaps;
+        if (this.trackingContext?.isEnabled() && previousValue !== allCaps) {
+            this.trackingContext.trackRunPropertyChange(this, 'allCaps', previousValue, allCaps);
+        }
+        return this;
+    }
+    setOutline(outline = true) {
+        const previousValue = this.formatting.outline;
+        this.formatting.outline = outline;
+        if (this.trackingContext?.isEnabled() && previousValue !== outline) {
+            this.trackingContext.trackRunPropertyChange(this, 'outline', previousValue, outline);
+        }
+        return this;
+    }
+    setShadow(shadow = true) {
+        const previousValue = this.formatting.shadow;
+        this.formatting.shadow = shadow;
+        if (this.trackingContext?.isEnabled() && previousValue !== shadow) {
+            this.trackingContext.trackRunPropertyChange(this, 'shadow', previousValue, shadow);
+        }
+        return this;
+    }
+    setEmboss(emboss = true) {
+        const previousValue = this.formatting.emboss;
+        this.formatting.emboss = emboss;
+        if (this.trackingContext?.isEnabled() && previousValue !== emboss) {
+            this.trackingContext.trackRunPropertyChange(this, 'emboss', previousValue, emboss);
+        }
+        return this;
+    }
+    setImprint(imprint = true) {
+        const previousValue = this.formatting.imprint;
+        this.formatting.imprint = imprint;
+        if (this.trackingContext?.isEnabled() && previousValue !== imprint) {
+            this.trackingContext.trackRunPropertyChange(this, 'imprint', previousValue, imprint);
+        }
+        return this;
+    }
+    setRTL(rtl = true) {
+        const previousValue = this.formatting.rtl;
+        this.formatting.rtl = rtl;
+        if (this.trackingContext?.isEnabled() && previousValue !== rtl) {
+            this.trackingContext.trackRunPropertyChange(this, 'rtl', previousValue, rtl);
+        }
+        return this;
+    }
+    setVanish(vanish = true) {
+        const previousValue = this.formatting.vanish;
+        this.formatting.vanish = vanish;
+        if (this.trackingContext?.isEnabled() && previousValue !== vanish) {
+            this.trackingContext.trackRunPropertyChange(this, 'vanish', previousValue, vanish);
+        }
+        return this;
+    }
+    setNoProof(noProof = true) {
+        const previousValue = this.formatting.noProof;
+        this.formatting.noProof = noProof;
+        if (this.trackingContext?.isEnabled() && previousValue !== noProof) {
+            this.trackingContext.trackRunPropertyChange(this, 'noProof', previousValue, noProof);
+        }
+        return this;
+    }
+    setSnapToGrid(snapToGrid = true) {
+        const previousValue = this.formatting.snapToGrid;
+        this.formatting.snapToGrid = snapToGrid;
+        if (this.trackingContext?.isEnabled() && previousValue !== snapToGrid) {
+            this.trackingContext.trackRunPropertyChange(this, 'snapToGrid', previousValue, snapToGrid);
+        }
+        return this;
+    }
+    setSpecVanish(specVanish = true) {
+        const previousValue = this.formatting.specVanish;
+        this.formatting.specVanish = specVanish;
+        if (this.trackingContext?.isEnabled() && previousValue !== specVanish) {
+            this.trackingContext.trackRunPropertyChange(this, 'specVanish', previousValue, specVanish);
+        }
+        return this;
+    }
+    setComplexScript(complexScript = true) {
+        const previousValue = this.formatting.complexScript;
+        this.formatting.complexScript = complexScript;
+        if (this.trackingContext?.isEnabled() && previousValue !== complexScript) {
+            this.trackingContext.trackRunPropertyChange(this, 'complexScript', previousValue, complexScript);
+        }
+        return this;
+    }
+    setWebHidden(webHidden = true) {
+        const previousValue = this.formatting.webHidden;
+        this.formatting.webHidden = webHidden;
+        if (this.trackingContext?.isEnabled() && previousValue !== webHidden) {
+            this.trackingContext.trackRunPropertyChange(this, 'webHidden', previousValue, webHidden);
+        }
+        return this;
+    }
+    setFontHAnsi(font) {
+        const previousValue = this.formatting.fontHAnsi;
+        this.formatting.fontHAnsi = font;
+        if (this.trackingContext?.isEnabled() && previousValue !== font) {
+            this.trackingContext.trackRunPropertyChange(this, 'fontHAnsi', previousValue, font);
+        }
+        return this;
+    }
+    setFontEastAsia(font) {
+        const previousValue = this.formatting.fontEastAsia;
+        this.formatting.fontEastAsia = font;
+        if (this.trackingContext?.isEnabled() && previousValue !== font) {
+            this.trackingContext.trackRunPropertyChange(this, 'fontEastAsia', previousValue, font);
+        }
+        return this;
+    }
+    setFontCs(font) {
+        const previousValue = this.formatting.fontCs;
+        this.formatting.fontCs = font;
+        if (this.trackingContext?.isEnabled() && previousValue !== font) {
+            this.trackingContext.trackRunPropertyChange(this, 'fontCs', previousValue, font);
+        }
+        return this;
+    }
+    setFontHint(hint) {
+        const previousValue = this.formatting.fontHint;
+        this.formatting.fontHint = hint;
+        if (this.trackingContext?.isEnabled() && previousValue !== hint) {
+            this.trackingContext.trackRunPropertyChange(this, 'fontHint', previousValue, hint);
+        }
+        return this;
+    }
+    setFontAsciiTheme(theme) {
+        this.formatting.fontAsciiTheme = theme;
+        return this;
+    }
+    setFontHAnsiTheme(theme) {
+        this.formatting.fontHAnsiTheme = theme;
+        return this;
+    }
+    setFontEastAsiaTheme(theme) {
+        this.formatting.fontEastAsiaTheme = theme;
+        return this;
+    }
+    setFontCsTheme(theme) {
+        this.formatting.fontCsTheme = theme;
+        return this;
+    }
+    addRawW14Property(rawXml) {
+        if (!this.formatting.rawW14Properties) {
+            this.formatting.rawW14Properties = [];
+        }
+        this.formatting.rawW14Properties.push(rawXml);
+        return this;
+    }
+    setEffect(effect) {
+        const previousValue = this.formatting.effect;
+        this.formatting.effect = effect;
+        if (this.trackingContext?.isEnabled() && previousValue !== effect) {
+            this.trackingContext.trackRunPropertyChange(this, 'effect', previousValue, effect);
+        }
+        return this;
+    }
+    setFitText(width) {
+        const previousValue = this.formatting.fitText;
+        this.formatting.fitText = width;
+        if (this.trackingContext?.isEnabled() && previousValue !== width) {
+            this.trackingContext.trackRunPropertyChange(this, 'fitText', previousValue, width);
+        }
+        return this;
+    }
+    setEastAsianLayout(layout) {
+        const previousValue = this.formatting.eastAsianLayout;
+        this.formatting.eastAsianLayout = layout;
+        if (this.trackingContext?.isEnabled() && previousValue !== layout) {
+            this.trackingContext.trackRunPropertyChange(this, 'eastAsianLayout', previousValue, layout);
+        }
+        return this;
+    }
+    toXML() {
+        const text = this.getText();
+        logSerialization(`Serializing run: "${text}"`, {
+            rtl: this.formatting.rtl || false,
+        });
+        if (this.formatting.rtl) {
+            logTextDirection(`Run with RTL being serialized: "${text}"`);
+        }
+        const runChildren = [];
+        const rPr = Run.generateRunPropertiesXML(this.formatting);
+        if (rPr || this.propertyChangeRevision) {
+            const rPrElement = rPr || { name: 'w:rPr', attributes: {}, children: [] };
+            if (this.propertyChangeRevision) {
+                const prevRPr = this.propertyChangeRevision.previousProperties
+                    ? Run.generateRunPropertiesXML(this.propertyChangeRevision.previousProperties)
+                    : null;
+                if (prevRPr) {
+                    const rPrChange = {
+                        name: 'w:rPrChange',
+                        attributes: {
+                            'w:id': this.propertyChangeRevision.id.toString(),
+                            'w:author': this.propertyChangeRevision.author,
+                            'w:date': formatDateForXml(this.propertyChangeRevision.date),
+                        },
+                        children: [prevRPr],
+                    };
+                    if (rPrElement.children) {
+                        rPrElement.children.push(rPrChange);
+                    }
+                    else {
+                        rPrElement.children = [rPrChange];
+                    }
+                }
+            }
+            runChildren.push(rPrElement);
+        }
+        for (const contentElement of this.content) {
+            switch (contentElement.type) {
+                case 'text':
+                    runChildren.push(XMLBuilder.w('t', {
+                        'xml:space': 'preserve',
+                    }, [contentElement.value || '']));
+                    break;
+                case 'tab':
+                    runChildren.push(XMLBuilder.wSelf('tab'));
+                    break;
+                case 'break':
+                    {
+                        const attrs = {};
+                        if (contentElement.breakType) {
+                            attrs['w:type'] = contentElement.breakType;
+                        }
+                        if (contentElement.breakClear) {
+                            attrs['w:clear'] = contentElement.breakClear;
+                        }
+                        runChildren.push(XMLBuilder.wSelf('br', Object.keys(attrs).length > 0 ? attrs : undefined));
+                    }
+                    break;
+                case 'carriageReturn':
+                    runChildren.push(XMLBuilder.wSelf('cr'));
+                    break;
+                case 'softHyphen':
+                    runChildren.push(XMLBuilder.wSelf('softHyphen'));
+                    break;
+                case 'noBreakHyphen':
+                    runChildren.push(XMLBuilder.wSelf('noBreakHyphen'));
+                    break;
+                case 'instructionText':
+                    runChildren.push(XMLBuilder.w('instrText', { 'xml:space': 'preserve' }, [contentElement.value || '']));
+                    break;
+                case 'fieldChar': {
+                    if (!contentElement.fieldCharType) {
+                        break;
+                    }
+                    const fldCharAttrs = {
+                        'w:fldCharType': contentElement.fieldCharType,
+                    };
+                    if (contentElement.fieldCharDirty !== undefined) {
+                        fldCharAttrs['w:dirty'] = contentElement.fieldCharDirty ? '1' : '0';
+                    }
+                    if (contentElement.fieldCharLocked !== undefined) {
+                        fldCharAttrs['w:fldLock'] = contentElement.fieldCharLocked ? '1' : '0';
+                    }
+                    if (contentElement.formFieldData && contentElement.fieldCharType === 'begin') {
+                        const ffDataChildren = [];
+                        const ffd = contentElement.formFieldData;
+                        if (ffd.name !== undefined) {
+                            ffDataChildren.push(XMLBuilder.wSelf('name', { 'w:val': ffd.name }));
+                        }
+                        if (ffd.enabled !== undefined) {
+                            if (ffd.enabled) {
+                                ffDataChildren.push(XMLBuilder.wSelf('enabled'));
+                            }
+                            else {
+                                ffDataChildren.push(XMLBuilder.wSelf('enabled', { 'w:val': '0' }));
+                            }
+                        }
+                        if (ffd.calcOnExit !== undefined) {
+                            ffDataChildren.push(XMLBuilder.wSelf('calcOnExit', { 'w:val': ffd.calcOnExit ? '1' : '0' }));
+                        }
+                        if (ffd.helpText) {
+                            ffDataChildren.push(XMLBuilder.wSelf('helpText', { 'w:type': 'text', 'w:val': ffd.helpText }));
+                        }
+                        if (ffd.statusText) {
+                            ffDataChildren.push(XMLBuilder.wSelf('statusText', { 'w:type': 'text', 'w:val': ffd.statusText }));
+                        }
+                        if (ffd.entryMacro) {
+                            ffDataChildren.push(XMLBuilder.wSelf('entryMacro', { 'w:val': ffd.entryMacro }));
+                        }
+                        if (ffd.exitMacro) {
+                            ffDataChildren.push(XMLBuilder.wSelf('exitMacro', { 'w:val': ffd.exitMacro }));
+                        }
+                        if (ffd.fieldType) {
+                            switch (ffd.fieldType.type) {
+                                case 'textInput': {
+                                    const tiChildren = [];
+                                    if (ffd.fieldType.inputType) {
+                                        tiChildren.push(XMLBuilder.wSelf('type', { 'w:val': ffd.fieldType.inputType }));
+                                    }
+                                    if (ffd.fieldType.defaultValue !== undefined) {
+                                        tiChildren.push(XMLBuilder.wSelf('default', { 'w:val': ffd.fieldType.defaultValue }));
+                                    }
+                                    if (ffd.fieldType.maxLength !== undefined) {
+                                        tiChildren.push(XMLBuilder.wSelf('maxLength', { 'w:val': ffd.fieldType.maxLength.toString() }));
+                                    }
+                                    if (ffd.fieldType.format) {
+                                        tiChildren.push(XMLBuilder.wSelf('format', { 'w:val': ffd.fieldType.format }));
+                                    }
+                                    ffDataChildren.push(XMLBuilder.w('textInput', {}, tiChildren));
+                                    break;
+                                }
+                                case 'checkBox': {
+                                    const cbChildren = [];
+                                    if (ffd.fieldType.size !== undefined && ffd.fieldType.size !== 'auto') {
+                                        cbChildren.push(XMLBuilder.wSelf('size', { 'w:val': ffd.fieldType.size.toString() }));
+                                    }
+                                    else {
+                                        cbChildren.push(XMLBuilder.wSelf('sizeAuto'));
+                                    }
+                                    if (ffd.fieldType.defaultChecked !== undefined) {
+                                        cbChildren.push(XMLBuilder.wSelf('default', {
+                                            'w:val': ffd.fieldType.defaultChecked ? '1' : '0',
+                                        }));
+                                    }
+                                    if (ffd.fieldType.checked !== undefined) {
+                                        cbChildren.push(XMLBuilder.wSelf('checked', { 'w:val': ffd.fieldType.checked ? '1' : '0' }));
+                                    }
+                                    ffDataChildren.push(XMLBuilder.w('checkBox', {}, cbChildren));
+                                    break;
+                                }
+                                case 'dropDownList': {
+                                    const ddChildren = [];
+                                    if (ffd.fieldType.result !== undefined) {
+                                        ddChildren.push(XMLBuilder.wSelf('result', { 'w:val': ffd.fieldType.result.toString() }));
+                                    }
+                                    if (ffd.fieldType.defaultResult !== undefined) {
+                                        ddChildren.push(XMLBuilder.wSelf('default', {
+                                            'w:val': ffd.fieldType.defaultResult.toString(),
+                                        }));
+                                    }
+                                    if (ffd.fieldType.listEntries) {
+                                        for (const entry of ffd.fieldType.listEntries) {
+                                            ddChildren.push(XMLBuilder.wSelf('listEntry', { 'w:val': entry }));
+                                        }
+                                    }
+                                    ffDataChildren.push(XMLBuilder.w('ddList', {}, ddChildren));
+                                    break;
+                                }
+                            }
+                        }
+                        if (ffDataChildren.length > 0) {
+                            runChildren.push(XMLBuilder.w('fldChar', fldCharAttrs, [XMLBuilder.w('ffData', {}, ffDataChildren)]));
+                        }
+                        else {
+                            runChildren.push(XMLBuilder.wSelf('fldChar', Object.keys(fldCharAttrs).length > 0 ? fldCharAttrs : undefined));
+                        }
+                    }
+                    else {
+                        runChildren.push(XMLBuilder.wSelf('fldChar', Object.keys(fldCharAttrs).length > 0 ? fldCharAttrs : undefined));
+                    }
+                    break;
+                }
+                case 'lastRenderedPageBreak':
+                    runChildren.push(XMLBuilder.wSelf('lastRenderedPageBreak'));
+                    break;
+                case 'separator':
+                    runChildren.push(XMLBuilder.wSelf('separator'));
+                    break;
+                case 'continuationSeparator':
+                    runChildren.push(XMLBuilder.wSelf('continuationSeparator'));
+                    break;
+                case 'pageNumber':
+                    runChildren.push(XMLBuilder.wSelf('pgNum'));
+                    break;
+                case 'annotationRef':
+                    runChildren.push(XMLBuilder.wSelf('annotationRef'));
+                    break;
+                case 'dayShort':
+                    runChildren.push(XMLBuilder.wSelf('dayShort'));
+                    break;
+                case 'dayLong':
+                    runChildren.push(XMLBuilder.wSelf('dayLong'));
+                    break;
+                case 'monthShort':
+                    runChildren.push(XMLBuilder.wSelf('monthShort'));
+                    break;
+                case 'monthLong':
+                    runChildren.push(XMLBuilder.wSelf('monthLong'));
+                    break;
+                case 'yearShort':
+                    runChildren.push(XMLBuilder.wSelf('yearShort'));
+                    break;
+                case 'yearLong':
+                    runChildren.push(XMLBuilder.wSelf('yearLong'));
+                    break;
+                case 'symbol': {
+                    if (!contentElement.symbolFont || !contentElement.symbolChar)
+                        break;
+                    runChildren.push(XMLBuilder.wSelf('sym', {
+                        'w:font': contentElement.symbolFont,
+                        'w:char': contentElement.symbolChar,
+                    }));
+                    break;
+                }
+                case 'positionTab': {
+                    const ptabAttrs = {
+                        'w:alignment': contentElement.ptabAlignment ?? 'left',
+                        'w:relativeTo': contentElement.ptabRelativeTo ?? 'margin',
+                        'w:leader': contentElement.ptabLeader ?? 'none',
+                    };
+                    runChildren.push(XMLBuilder.wSelf('ptab', ptabAttrs));
+                    break;
+                }
+                case 'footnoteReference': {
+                    if (contentElement.footnoteId === undefined)
+                        break;
+                    const fnAttrs = {
+                        'w:id': contentElement.footnoteId,
+                    };
+                    if (contentElement.customMarkFollows === true)
+                        fnAttrs['w:customMarkFollows'] = '1';
+                    runChildren.push(XMLBuilder.wSelf('footnoteReference', fnAttrs));
+                    break;
+                }
+                case 'endnoteReference': {
+                    if (contentElement.endnoteId === undefined)
+                        break;
+                    const enAttrs = {
+                        'w:id': contentElement.endnoteId,
+                    };
+                    if (contentElement.customMarkFollows === true)
+                        enAttrs['w:customMarkFollows'] = '1';
+                    runChildren.push(XMLBuilder.wSelf('endnoteReference', enAttrs));
+                    break;
+                }
+                case 'footnoteRef':
+                    runChildren.push(XMLBuilder.wSelf('footnoteRef'));
+                    break;
+                case 'endnoteRef':
+                    runChildren.push(XMLBuilder.wSelf('endnoteRef'));
+                    break;
+                case 'embeddedObject':
+                    if (contentElement.rawXml) {
+                        runChildren.push({
+                            name: '__rawXml',
+                            rawXml: contentElement.rawXml,
+                        });
+                    }
+                    break;
+                case 'vml':
+                    if (contentElement.rawXml) {
+                        runChildren.push({
+                            name: '__rawXml',
+                            rawXml: contentElement.rawXml,
+                        });
+                    }
+                    break;
+            }
+        }
+        return XMLBuilder.w('r', undefined, runChildren);
+    }
+    hasText() {
+        const text = this.getText();
+        return text.length > 0;
+    }
+    hasFormatting() {
+        return Object.keys(this.formatting).length > 0;
+    }
+    isValid() {
+        return this.hasText() || this.hasFormatting();
+    }
+    getContent() {
+        return [...this.content];
+    }
+    addTab() {
+        this.content.push({ type: 'tab' });
+        return this;
+    }
+    addBreak(breakType, breakClear) {
+        this.content.push({ type: 'break', breakType, breakClear });
+        return this;
+    }
+    appendText(text) {
+        if (text) {
+            this.content.push({ type: 'text', value: text });
+        }
+        return this;
+    }
+    addCarriageReturn() {
+        this.content.push({ type: 'carriageReturn' });
+        return this;
+    }
+    static createFromContent(content, formatting = {}) {
+        const run = Object.create(Run.prototype);
+        run.content = content;
+        const { cleanXmlFromText, ...displayFormatting } = formatting;
+        run.formatting = displayFormatting;
+        return run;
+    }
+    static generateRunPropertiesXML(formatting) {
+        const rPrChildren = [];
+        if (formatting.characterStyle) {
+            rPrChildren.push(XMLBuilder.wSelf('rStyle', {
+                'w:val': formatting.characterStyle,
+            }));
+        }
+        if (formatting.font ||
+            formatting.fontHAnsi ||
+            formatting.fontEastAsia ||
+            formatting.fontCs ||
+            formatting.fontHint ||
+            formatting.fontAsciiTheme ||
+            formatting.fontHAnsiTheme ||
+            formatting.fontEastAsiaTheme ||
+            formatting.fontCsTheme) {
+            const rFontsAttrs = {};
+            if (formatting.font)
+                rFontsAttrs['w:ascii'] = formatting.font;
+            rFontsAttrs['w:hAnsi'] = formatting.fontHAnsi || formatting.font || '';
+            if (formatting.fontEastAsia)
+                rFontsAttrs['w:eastAsia'] = formatting.fontEastAsia;
+            rFontsAttrs['w:cs'] = formatting.fontCs || formatting.font || '';
+            if (formatting.fontHint)
+                rFontsAttrs['w:hint'] = formatting.fontHint;
+            if (formatting.fontAsciiTheme)
+                rFontsAttrs['w:asciiTheme'] = formatting.fontAsciiTheme;
+            if (formatting.fontHAnsiTheme)
+                rFontsAttrs['w:hAnsiTheme'] = formatting.fontHAnsiTheme;
+            if (formatting.fontEastAsiaTheme)
+                rFontsAttrs['w:eastAsiaTheme'] = formatting.fontEastAsiaTheme;
+            if (formatting.fontCsTheme)
+                rFontsAttrs['w:cstheme'] = formatting.fontCsTheme;
+            for (const key of Object.keys(rFontsAttrs)) {
+                if (rFontsAttrs[key] === '')
+                    delete rFontsAttrs[key];
+            }
+            if (Object.keys(rFontsAttrs).length > 0) {
+                rPrChildren.push(XMLBuilder.wSelf('rFonts', rFontsAttrs));
+            }
+        }
+        if (formatting.bold !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('b', { 'w:val': formatting.bold ? '1' : '0' }));
+        }
+        if (formatting.complexScriptBold !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('bCs', { 'w:val': formatting.complexScriptBold ? '1' : '0' }));
+        }
+        if (formatting.italic !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('i', { 'w:val': formatting.italic ? '1' : '0' }));
+        }
+        if (formatting.complexScriptItalic !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('iCs', { 'w:val': formatting.complexScriptItalic ? '1' : '0' }));
+        }
+        if (formatting.allCaps !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('caps', { 'w:val': formatting.allCaps ? '1' : '0' }));
+        }
+        if (formatting.smallCaps !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('smallCaps', { 'w:val': formatting.smallCaps ? '1' : '0' }));
+        }
+        if (formatting.strike !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('strike', { 'w:val': formatting.strike ? '1' : '0' }));
+        }
+        if (formatting.dstrike !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('dstrike', { 'w:val': formatting.dstrike ? '1' : '0' }));
+        }
+        if (formatting.outline !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('outline', { 'w:val': formatting.outline ? '1' : '0' }));
+        }
+        if (formatting.shadow !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('shadow', { 'w:val': formatting.shadow ? '1' : '0' }));
+        }
+        if (formatting.emboss !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('emboss', { 'w:val': formatting.emboss ? '1' : '0' }));
+        }
+        if (formatting.imprint !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('imprint', { 'w:val': formatting.imprint ? '1' : '0' }));
+        }
+        if (formatting.noProof !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('noProof', { 'w:val': formatting.noProof ? '1' : '0' }));
+        }
+        if (formatting.snapToGrid !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('snapToGrid', { 'w:val': formatting.snapToGrid ? '1' : '0' }));
+        }
+        if (formatting.vanish !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('vanish', { 'w:val': formatting.vanish ? '1' : '0' }));
+        }
+        if (formatting.webHidden !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('webHidden', { 'w:val': formatting.webHidden ? '1' : '0' }));
+        }
+        if (formatting.color || formatting.themeColor) {
+            const colorAttrs = {};
+            colorAttrs['w:val'] = formatting.color || '000000';
+            if (formatting.themeColor) {
+                colorAttrs['w:themeColor'] = formatting.themeColor;
+            }
+            if (formatting.themeTint !== undefined) {
+                colorAttrs['w:themeTint'] = formatting.themeTint
+                    .toString(16)
+                    .toUpperCase()
+                    .padStart(2, '0');
+            }
+            if (formatting.themeShade !== undefined) {
+                colorAttrs['w:themeShade'] = formatting.themeShade
+                    .toString(16)
+                    .toUpperCase()
+                    .padStart(2, '0');
+            }
+            rPrChildren.push(XMLBuilder.wSelf('color', colorAttrs));
+        }
+        if (formatting.characterSpacing !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('spacing', { 'w:val': formatting.characterSpacing }));
+        }
+        if (formatting.scaling !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('w', { 'w:val': formatting.scaling }));
+        }
+        if (formatting.kerning !== undefined && formatting.kerning !== null) {
+            rPrChildren.push(XMLBuilder.wSelf('kern', { 'w:val': formatting.kerning }));
+        }
+        if (formatting.position !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('position', { 'w:val': formatting.position }));
+        }
+        if (formatting.size !== undefined) {
+            const halfPoints = pointsToHalfPoints(formatting.size);
+            rPrChildren.push(XMLBuilder.wSelf('sz', { 'w:val': halfPoints }));
+            const csHalfPoints = formatting.sizeCs !== undefined ? pointsToHalfPoints(formatting.sizeCs) : halfPoints;
+            rPrChildren.push(XMLBuilder.wSelf('szCs', { 'w:val': csHalfPoints }));
+        }
+        else if (formatting.sizeCs !== undefined) {
+            const csHalfPoints = pointsToHalfPoints(formatting.sizeCs);
+            rPrChildren.push(XMLBuilder.wSelf('szCs', { 'w:val': csHalfPoints }));
+        }
+        if (formatting.highlight) {
+            rPrChildren.push(XMLBuilder.wSelf('highlight', { 'w:val': formatting.highlight }));
+        }
+        if (formatting.underline) {
+            const underlineValue = typeof formatting.underline === 'string' ? formatting.underline : 'single';
+            const uAttrs = { 'w:val': underlineValue };
+            if (formatting.underlineColor)
+                uAttrs['w:color'] = formatting.underlineColor;
+            if (formatting.underlineThemeColor)
+                uAttrs['w:themeColor'] = formatting.underlineThemeColor;
+            if (formatting.underlineThemeTint !== undefined)
+                uAttrs['w:themeTint'] = formatting.underlineThemeTint
+                    .toString(16)
+                    .toUpperCase()
+                    .padStart(2, '0');
+            if (formatting.underlineThemeShade !== undefined)
+                uAttrs['w:themeShade'] = formatting.underlineThemeShade
+                    .toString(16)
+                    .toUpperCase()
+                    .padStart(2, '0');
+            rPrChildren.push(XMLBuilder.wSelf('u', uAttrs));
+        }
+        else if (formatting.underline === false && formatting.characterStyle) {
+            rPrChildren.push(XMLBuilder.wSelf('u', { 'w:val': 'none' }));
+        }
+        if (formatting.effect) {
+            rPrChildren.push(XMLBuilder.wSelf('effect', { 'w:val': formatting.effect }));
+        }
+        if (formatting.border) {
+            const b = formatting.border;
+            const bdrAttrs = { 'w:val': b.style ?? 'nil' };
+            if (b.size !== undefined)
+                bdrAttrs['w:sz'] = b.size;
+            if (b.color)
+                bdrAttrs['w:color'] = b.color;
+            if (b.space !== undefined)
+                bdrAttrs['w:space'] = b.space;
+            const bb = b;
+            if (bb.themeColor)
+                bdrAttrs['w:themeColor'] = bb.themeColor;
+            if (bb.themeTint)
+                bdrAttrs['w:themeTint'] = bb.themeTint;
+            if (bb.themeShade)
+                bdrAttrs['w:themeShade'] = bb.themeShade;
+            if (bb.shadow !== undefined)
+                bdrAttrs['w:shadow'] = bb.shadow ? '1' : '0';
+            if (bb.frame !== undefined)
+                bdrAttrs['w:frame'] = bb.frame ? '1' : '0';
+            rPrChildren.push(XMLBuilder.wSelf('bdr', bdrAttrs));
+        }
+        if (formatting.shading) {
+            const shdAttrs = buildShadingAttributes(formatting.shading);
+            if (Object.keys(shdAttrs).length > 0) {
+                rPrChildren.push(XMLBuilder.wSelf('shd', shdAttrs));
+            }
+        }
+        if (formatting.fitText !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('fitText', { 'w:val': formatting.fitText }));
+        }
+        if (formatting.subscript) {
+            rPrChildren.push(XMLBuilder.wSelf('vertAlign', { 'w:val': 'subscript' }));
+        }
+        else if (formatting.superscript) {
+            rPrChildren.push(XMLBuilder.wSelf('vertAlign', { 'w:val': 'superscript' }));
+        }
+        else if (formatting.vertAlignBaseline) {
+            rPrChildren.push(XMLBuilder.wSelf('vertAlign', { 'w:val': 'baseline' }));
+        }
+        if (formatting.rtl !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('rtl', { 'w:val': formatting.rtl ? '1' : '0' }));
+        }
+        if (formatting.complexScript !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('cs', { 'w:val': formatting.complexScript ? '1' : '0' }));
+        }
+        if (formatting.emphasis) {
+            rPrChildren.push(XMLBuilder.wSelf('em', { 'w:val': formatting.emphasis }));
+        }
+        if (formatting.language) {
+            const langAttrs = {};
+            if (typeof formatting.language === 'string') {
+                langAttrs['w:val'] = formatting.language;
+            }
+            else {
+                if (formatting.language.val)
+                    langAttrs['w:val'] = formatting.language.val;
+                if (formatting.language.eastAsia)
+                    langAttrs['w:eastAsia'] = formatting.language.eastAsia;
+                if (formatting.language.bidi)
+                    langAttrs['w:bidi'] = formatting.language.bidi;
+            }
+            if (Object.keys(langAttrs).length > 0) {
+                rPrChildren.push(XMLBuilder.wSelf('lang', langAttrs));
+            }
+        }
+        if (formatting.eastAsianLayout) {
+            const layout = formatting.eastAsianLayout;
+            const attrs = {};
+            if (layout.id !== undefined)
+                attrs['w:id'] = layout.id;
+            if (layout.vert !== undefined)
+                attrs['w:vert'] = layout.vert ? '1' : '0';
+            if (layout.vertCompress !== undefined) {
+                attrs['w:vertCompress'] = layout.vertCompress ? '1' : '0';
+            }
+            if (layout.combine !== undefined)
+                attrs['w:combine'] = layout.combine ? '1' : '0';
+            if (layout.combineBrackets)
+                attrs['w:combineBrackets'] = layout.combineBrackets;
+            if (Object.keys(attrs).length > 0) {
+                rPrChildren.push(XMLBuilder.wSelf('eastAsianLayout', attrs));
+            }
+        }
+        if (formatting.specVanish !== undefined) {
+            rPrChildren.push(XMLBuilder.wSelf('specVanish', { 'w:val': formatting.specVanish ? '1' : '0' }));
+        }
+        if (formatting.rawW14Properties && formatting.rawW14Properties.length > 0) {
+            for (const rawXml of formatting.rawW14Properties) {
+                rPrChildren.push({ name: '__rawXml', rawXml });
+            }
+        }
+        if (rPrChildren.length === 0) {
+            return null;
+        }
+        return XMLBuilder.w('rPr', undefined, rPrChildren);
+    }
+    static create(text, formatting) {
+        return new Run(text, formatting);
+    }
+    clone() {
+        const clonedContent = deepClone(this.content);
+        const clonedFormatting = deepClone(this.formatting);
+        return Run.createFromContent(clonedContent, clonedFormatting);
+    }
+    insertText(index, text) {
+        const currentText = this.getText();
+        if (index < 0)
+            index = 0;
+        if (index > currentText.length)
+            index = currentText.length;
+        const newText = currentText.slice(0, index) + text + currentText.slice(index);
+        this.setText(newText);
+        return this;
+    }
+    replaceText(start, end, text) {
+        const currentText = this.getText();
+        if (start < 0)
+            start = 0;
+        if (end > currentText.length)
+            end = currentText.length;
+        if (start > end)
+            [start, end] = [end, start];
+        const newText = currentText.slice(0, start) + text + currentText.slice(end);
+        this.setText(newText);
+        return this;
+    }
+    splitAt(offset) {
+        const totalLength = this.getText().length;
+        if (offset >= totalLength) {
+            return Run.createFromContent([], deepClone(this.formatting));
+        }
+        if (offset <= 0) {
+            const allContent = this.content;
+            this.content = [];
+            return Run.createFromContent(allContent, deepClone(this.formatting));
+        }
+        const beforeContent = [];
+        const afterContent = [];
+        let charPos = 0;
+        let splitDone = false;
+        for (const item of this.content) {
+            if (splitDone) {
+                afterContent.push(deepClone(item));
+                continue;
+            }
+            const itemLength = this.getContentItemLength(item);
+            if (charPos + itemLength <= offset) {
+                beforeContent.push(deepClone(item));
+                charPos += itemLength;
+            }
+            else if (charPos >= offset) {
+                afterContent.push(deepClone(item));
+                splitDone = true;
+            }
+            else {
+                if (item.type === 'text' && item.value) {
+                    const splitIndex = offset - charPos;
+                    beforeContent.push({ type: 'text', value: item.value.slice(0, splitIndex) });
+                    afterContent.push({ type: 'text', value: item.value.slice(splitIndex) });
+                }
+                else {
+                    afterContent.push(deepClone(item));
+                }
+                splitDone = true;
+            }
+        }
+        this.content = beforeContent;
+        return Run.createFromContent(afterContent, deepClone(this.formatting));
+    }
+    getContentItemLength(item) {
+        switch (item.type) {
+            case 'text':
+                return (item.value || '').length;
+            case 'tab':
+            case 'break':
+            case 'carriageReturn':
+            case 'softHyphen':
+            case 'noBreakHyphen':
+                return 1;
+            default:
+                return 0;
+        }
+    }
+    clearFormattingConflicts(styleRunFormatting) {
+        const conflictingProperties = [];
+        for (const key in this.formatting) {
+            const propKey = key;
+            if (styleRunFormatting[propKey] === undefined) {
+                continue;
+            }
+            if (this.formatting[propKey] !== styleRunFormatting[propKey]) {
+                conflictingProperties.push(propKey);
+            }
+        }
+        for (const prop of conflictingProperties) {
+            delete this.formatting[prop];
+        }
+        return this;
+    }
+    clearMatchingFormatting(styleRunFormatting) {
+        const matchingProperties = [];
+        for (const key in this.formatting) {
+            const propKey = key;
+            if (styleRunFormatting[propKey] === undefined) {
+                continue;
+            }
+            if (this.formatting[propKey] === styleRunFormatting[propKey]) {
+                matchingProperties.push(propKey);
+            }
+        }
+        for (const prop of matchingProperties) {
+            delete this.formatting[prop];
+        }
+        return this;
+    }
+    clearFormatting() {
+        this.formatting = {};
+        return this;
+    }
+}
+//# sourceMappingURL=Run.js.map