docxmlater 10.4.1 → 11.0.4

package/dist/esm/elements/Paragraph.js

@@ -0,0 +1,2308 @@
+import { deepClone } from '../utils/deepClone.js';
+import { deepEqual } from '../utils/deepEqual.js';
+import { formatDateForXml } from '../utils/dateFormatting.js';
+import { logParagraphContent, logTextDirection } from '../utils/diagnostics.js';
+import { isEqualFormatting } from '../utils/formatting.js';
+import { defaultLogger } from '../utils/logger.js';
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+import { buildShadingAttributes, } from './CommonTypes.js';
+import { ComplexField, Field } from './Field.js';
+import { Hyperlink } from './Hyperlink.js';
+import { RangeMarker } from './RangeMarker.js';
+import { Revision } from './Revision.js';
+import { Run } from './Run.js';
+import { Shape } from './Shape.js';
+import { TextBox } from './TextBox.js';
+export function isRun(content) {
+    return content instanceof Run;
+}
+export function isField(content) {
+    return content instanceof Field || content instanceof ComplexField;
+}
+export function isSimpleField(content) {
+    return content instanceof Field && !(content instanceof ComplexField);
+}
+export function isComplexField(content) {
+    return content instanceof ComplexField;
+}
+export function isHyperlink(content) {
+    return content instanceof Hyperlink;
+}
+export function isRevision(content) {
+    return content instanceof Revision;
+}
+export function isRangeMarker(content) {
+    return content instanceof RangeMarker;
+}
+export function isShape(content) {
+    return content instanceof Shape;
+}
+export function isTextBox(content) {
+    return content instanceof TextBox;
+}
+export class Paragraph {
+    content = [];
+    formatting;
+    bookmarksStart = [];
+    bookmarksEnd = [];
+    commentsStart = [];
+    commentsEnd = [];
+    _isPreserved = false;
+    trackingContext;
+    _parentCell;
+    _stylesManager;
+    _isPartOfMultiParagraphField;
+    constructor(formatting = {}) {
+        this.formatting = formatting;
+    }
+    _setTrackingContext(context) {
+        this.trackingContext = context;
+    }
+    _setParentCell(cell) {
+        this._parentCell = cell;
+    }
+    _getParentCell() {
+        return this._parentCell;
+    }
+    isInTableCell() {
+        return this._parentCell !== undefined;
+    }
+    getTableConditionalStyle() {
+        if (this._parentCell) {
+            const cellFormatting = this._parentCell.getFormatting();
+            if (cellFormatting.cnfStyle) {
+                return cellFormatting.cnfStyle;
+            }
+        }
+        return this.formatting.cnfStyle;
+    }
+    _setStylesManager(manager) {
+        this._stylesManager = manager;
+    }
+    _getStylesManager() {
+        return this._stylesManager;
+    }
+    static create(textOrFormatting, formatting) {
+        if (typeof textOrFormatting === 'string') {
+            const paragraph = new Paragraph(formatting);
+            paragraph.addText(textOrFormatting);
+            return paragraph;
+        }
+        else {
+            return new Paragraph(textOrFormatting);
+        }
+    }
+    static createWithStyle(text, styleId) {
+        const paragraph = new Paragraph({ style: styleId });
+        paragraph.addText(text);
+        return paragraph;
+    }
+    static createEmpty() {
+        return new Paragraph();
+    }
+    static createFormatted(text, runFormatting, paragraphFormatting) {
+        const paragraph = new Paragraph(paragraphFormatting);
+        paragraph.addText(text, runFormatting);
+        return paragraph;
+    }
+    addRun(run) {
+        run._setParentParagraph(this);
+        if (this.trackingContext?.isEnabled()) {
+            const revision = Revision.createInsertion(this.trackingContext.getAuthor(), run, new Date());
+            this.trackingContext.getRevisionManager().register(revision);
+            this.content.push(revision);
+        }
+        else {
+            this.content.push(run);
+        }
+        return this;
+    }
+    addField(field) {
+        if (this.trackingContext?.isEnabled()) {
+            this.content.push(field);
+        }
+        else {
+            this.content.push(field);
+        }
+        return this;
+    }
+    addComplexField(field) {
+        this.content.push(field);
+        return this;
+    }
+    addHyperlink(urlOrHyperlink) {
+        if (typeof urlOrHyperlink === 'string') {
+            const hyperlink = new Hyperlink({ url: urlOrHyperlink, text: urlOrHyperlink });
+            hyperlink._setParentParagraph(this);
+            if (this.trackingContext?.isEnabled()) {
+                const revision = Revision.createInsertion(this.trackingContext.getAuthor(), hyperlink, new Date());
+                this.trackingContext.getRevisionManager().register(revision);
+                this.content.push(revision);
+            }
+            else {
+                this.content.push(hyperlink);
+            }
+            return hyperlink;
+        }
+        else if (urlOrHyperlink instanceof Hyperlink) {
+            urlOrHyperlink._setParentParagraph(this);
+            if (this.trackingContext?.isEnabled()) {
+                const revision = Revision.createInsertion(this.trackingContext.getAuthor(), urlOrHyperlink, new Date());
+                this.trackingContext.getRevisionManager().register(revision);
+                this.content.push(revision);
+            }
+            else {
+                this.content.push(urlOrHyperlink);
+            }
+            return this;
+        }
+        else {
+            const hyperlink = new Hyperlink({ text: 'Link' });
+            hyperlink._setParentParagraph(this);
+            if (this.trackingContext?.isEnabled()) {
+                const revision = Revision.createInsertion(this.trackingContext.getAuthor(), hyperlink, new Date());
+                this.trackingContext.getRevisionManager().register(revision);
+                this.content.push(revision);
+            }
+            else {
+                this.content.push(hyperlink);
+            }
+            return hyperlink;
+        }
+    }
+    addRevision(revision) {
+        this.content.push(revision);
+        return this;
+    }
+    addRangeMarker(rangeMarker) {
+        this.content.push(rangeMarker);
+        return this;
+    }
+    addShape(shape) {
+        this.content.push(shape);
+        return this;
+    }
+    addTextBox(textbox) {
+        this.content.push(textbox);
+        return this;
+    }
+    addContent(item) {
+        this.content.push(item);
+        return this;
+    }
+    addBookmarkStart(bookmark) {
+        this.bookmarksStart.push(bookmark);
+        return this;
+    }
+    addBookmarkEnd(bookmark) {
+        this.bookmarksEnd.push(bookmark);
+        return this;
+    }
+    addBookmark(bookmark) {
+        this.addBookmarkStart(bookmark);
+        this.addBookmarkEnd(bookmark);
+        return this;
+    }
+    getBookmarksStart() {
+        return [...this.bookmarksStart];
+    }
+    getBookmarksEnd() {
+        return [...this.bookmarksEnd];
+    }
+    removeBookmarkEnd(id) {
+        const index = this.bookmarksEnd.findIndex((bm) => bm.getId() === id);
+        if (index !== -1) {
+            this.bookmarksEnd.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    addCommentStart(comment) {
+        this.commentsStart.push(comment);
+        return this;
+    }
+    addCommentEnd(comment) {
+        this.commentsEnd.push(comment);
+        return this;
+    }
+    addComment(comment) {
+        this.addCommentStart(comment);
+        this.addCommentEnd(comment);
+        return this;
+    }
+    getCommentsStart() {
+        return [...this.commentsStart];
+    }
+    getCommentsEnd() {
+        return [...this.commentsEnd];
+    }
+    addPageNumber(formatting) {
+        return this.addField(Field.createPageNumber(formatting));
+    }
+    addTotalPages(formatting) {
+        return this.addField(Field.createTotalPages(formatting));
+    }
+    addDate(format, formatting) {
+        return this.addField(Field.createDate(format, formatting));
+    }
+    addTime(format, formatting) {
+        return this.addField(Field.createTime(format, formatting));
+    }
+    addFilename(includePath = false, formatting) {
+        return this.addField(Field.createFilename(includePath, formatting));
+    }
+    addAuthor(formatting) {
+        return this.addField(Field.createAuthor(formatting));
+    }
+    addTitle(formatting) {
+        return this.addField(Field.createTitle(formatting));
+    }
+    addText(text, formatting) {
+        const run = new Run(text, formatting);
+        run._setParentParagraph(this);
+        if (this.trackingContext?.isEnabled()) {
+            const revision = Revision.createInsertion(this.trackingContext.getAuthor(), run, new Date());
+            this.trackingContext.getRevisionManager().register(revision);
+            this.content.push(revision);
+        }
+        else {
+            this.content.push(run);
+        }
+        return this;
+    }
+    addLineBreak() {
+        const run = new Run('');
+        run.addBreak();
+        this.content.push(run);
+        return this;
+    }
+    addColumnBreak() {
+        const run = new Run('');
+        run.addBreak('column');
+        this.content.push(run);
+        return this;
+    }
+    setText(text, formatting) {
+        this.content = [new Run(text, formatting)];
+        return this;
+    }
+    getRuns() {
+        const runs = [];
+        for (const item of this.content) {
+            if (item instanceof Run) {
+                runs.push(item);
+            }
+            else if (item instanceof Revision) {
+                runs.push(...item.getRuns());
+            }
+            else if (item instanceof Hyperlink) {
+                runs.push(item.getRun());
+            }
+        }
+        return runs;
+    }
+    getRevisions() {
+        return this.content.filter((item) => item instanceof Revision);
+    }
+    getContent() {
+        return [...this.content];
+    }
+    clearContent() {
+        if (this.trackingContext?.isEnabled() && this.content.length > 0) {
+            const deletedContent = [];
+            for (const item of this.content) {
+                if (item instanceof Revision) {
+                    deletedContent.push(item);
+                }
+                else if (item instanceof Run || item instanceof Hyperlink) {
+                    const revision = Revision.createDeletion(this.trackingContext.getAuthor(), item, new Date());
+                    this.trackingContext.getRevisionManager().register(revision);
+                    deletedContent.push(revision);
+                }
+                else {
+                    deletedContent.push(item);
+                }
+            }
+            this.content = deletedContent;
+        }
+        else {
+            this.content = [];
+        }
+        return this;
+    }
+    replaceContent(oldItem, newItems) {
+        const index = this.content.indexOf(oldItem);
+        if (index === -1) {
+            return false;
+        }
+        this.content.splice(index, 1, ...newItems);
+        return true;
+    }
+    setContent(content) {
+        if (this.trackingContext?.isEnabled() && this.content.length > 0) {
+            const deletedContent = [];
+            for (const item of this.content) {
+                if (item instanceof Revision) {
+                    deletedContent.push(item);
+                }
+                else if (item instanceof Run || item instanceof Hyperlink) {
+                    const revision = Revision.createDeletion(this.trackingContext.getAuthor(), item, new Date());
+                    this.trackingContext.getRevisionManager().register(revision);
+                    deletedContent.push(revision);
+                }
+            }
+            this.content = [...deletedContent, ...content];
+        }
+        else {
+            this.content = [...content];
+        }
+        for (const item of this.content) {
+            if (item instanceof Hyperlink) {
+                item._setParentParagraph(this);
+            }
+            else if (item instanceof Run) {
+                item._setParentParagraph(this);
+            }
+        }
+    }
+    removeContentAt(index) {
+        if (index < 0 || index >= this.content.length) {
+            return undefined;
+        }
+        const item = this.content[index];
+        if (this.trackingContext?.isEnabled()) {
+            if (item instanceof Run || item instanceof Hyperlink) {
+                const revision = Revision.createDeletion(this.trackingContext.getAuthor(), item, new Date());
+                this.trackingContext.getRevisionManager().register(revision);
+                this.content[index] = revision;
+            }
+        }
+        else {
+            this.content.splice(index, 1);
+        }
+        return item;
+    }
+    getText() {
+        return this.content
+            .filter((item) => item instanceof Run || item instanceof Hyperlink)
+            .map((item) => item.getText())
+            .join('');
+    }
+    getFields() {
+        return this.content.filter((item) => item instanceof Field || item instanceof ComplexField);
+    }
+    findFieldsByInstruction(pattern) {
+        const regex = typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern;
+        return this.getFields().filter((field) => {
+            const instruction = field.getInstruction();
+            return regex.test(instruction);
+        });
+    }
+    removeAllFields() {
+        const originalLength = this.content.length;
+        this.content = this.content.filter((item) => !(item instanceof Field || item instanceof ComplexField));
+        return originalLength - this.content.length;
+    }
+    replaceField(oldField, replacement) {
+        const index = this.content.indexOf(oldField);
+        if (index === -1)
+            return false;
+        if (typeof replacement === 'string') {
+            this.content[index] = new Run(replacement);
+        }
+        else {
+            this.content[index] = replacement;
+        }
+        return true;
+    }
+    getFormatting() {
+        return { ...this.formatting };
+    }
+    getLeftIndent() {
+        return this.formatting.indentation?.left;
+    }
+    getRightIndent() {
+        return this.formatting.indentation?.right;
+    }
+    getFirstLineIndent() {
+        return this.formatting.indentation?.firstLine;
+    }
+    getHangingIndent() {
+        return this.formatting.indentation?.hanging;
+    }
+    getSpaceBefore() {
+        return this.formatting.spacing?.before;
+    }
+    getSpaceAfter() {
+        return this.formatting.spacing?.after;
+    }
+    getLineSpacing() {
+        return this.formatting.spacing?.line;
+    }
+    getAlignment() {
+        return this.formatting.alignment;
+    }
+    getKeepNext() {
+        return this.formatting.keepNext ?? false;
+    }
+    getKeepLines() {
+        return this.formatting.keepLines ?? false;
+    }
+    getPageBreakBefore() {
+        return this.formatting.pageBreakBefore ?? false;
+    }
+    getOutlineLevel() {
+        return this.formatting.outlineLevel;
+    }
+    getTextDirection() {
+        return this.formatting.textDirection;
+    }
+    getWidowControl() {
+        return this.formatting.widowControl ?? true;
+    }
+    getContextualSpacing() {
+        return this.formatting.contextualSpacing ?? false;
+    }
+    hasNumbering() {
+        return this.formatting.numbering?.numId !== undefined && this.formatting.numbering.numId !== 0;
+    }
+    isNumberingSuppressed() {
+        return this.formatting.numberingSuppressed === true;
+    }
+    hasFields() {
+        return this.getFields().length > 0;
+    }
+    hasBookmarks() {
+        return this.getBookmarksStart().length > 0;
+    }
+    hasComments() {
+        return this.getCommentsStart().length > 0;
+    }
+    hasRevisions() {
+        return this.getRevisions().length > 0;
+    }
+    consolidateRevisions(timeWindowMs = 1000) {
+        if (!this.hasRevisions()) {
+            return 0;
+        }
+        const consolidatedContent = [];
+        let mergeCount = 0;
+        let currentMergeGroup = null;
+        for (const item of this.content) {
+            if (item instanceof Revision) {
+                if (currentMergeGroup && this.canMergeRevisions(currentMergeGroup, item, timeWindowMs)) {
+                    for (const content of item.getContent()) {
+                        currentMergeGroup.addContent(content);
+                    }
+                    mergeCount++;
+                }
+                else {
+                    if (currentMergeGroup) {
+                        consolidatedContent.push(currentMergeGroup);
+                    }
+                    currentMergeGroup = this.cloneRevision(item);
+                }
+            }
+            else {
+                if (currentMergeGroup) {
+                    consolidatedContent.push(currentMergeGroup);
+                    currentMergeGroup = null;
+                }
+                consolidatedContent.push(item);
+            }
+        }
+        if (currentMergeGroup) {
+            consolidatedContent.push(currentMergeGroup);
+        }
+        if (mergeCount > 0) {
+            this.content = consolidatedContent;
+        }
+        return mergeCount;
+    }
+    canMergeRevisions(rev1, rev2, timeWindowMs) {
+        if (rev1.getType() !== rev2.getType()) {
+            return false;
+        }
+        const mergeableTypes = ['insert', 'delete', 'moveFrom', 'moveTo'];
+        if (!mergeableTypes.includes(rev1.getType())) {
+            return false;
+        }
+        if (rev1.getAuthor() !== rev2.getAuthor()) {
+            return false;
+        }
+        const timeDiff = Math.abs(rev1.getDate().getTime() - rev2.getDate().getTime());
+        if (timeDiff > timeWindowMs) {
+            return false;
+        }
+        return true;
+    }
+    cloneRevision(revision) {
+        const cloned = new Revision({
+            id: revision.getId(),
+            author: revision.getAuthor(),
+            date: revision.getDate(),
+            type: revision.getType(),
+            content: [...revision.getContent()],
+            previousProperties: revision.getPreviousProperties(),
+            newProperties: revision.getNewProperties(),
+            moveId: revision.getMoveId(),
+            moveLocation: revision.getMoveLocation(),
+            location: revision.getLocation(),
+            fieldContext: revision.getFieldContext(),
+        });
+        return cloned;
+    }
+    isEmpty() {
+        return this.getText().trim().length === 0;
+    }
+    contains(text, caseSensitive = false) {
+        const paraText = caseSensitive ? this.getText() : this.getText().toLowerCase();
+        const search = caseSensitive ? text : text.toLowerCase();
+        return paraText.includes(search);
+    }
+    getStyle() {
+        return this.formatting.style;
+    }
+    detectHeadingLevel() {
+        const style = this.formatting.style;
+        if (style) {
+            const match = /^Heading(\d)$/i.exec(style);
+            if (match?.[1]) {
+                const level = parseInt(match[1], 10);
+                return level >= 1 && level <= 9 ? level : null;
+            }
+        }
+        if (this.formatting.outlineLevel !== undefined) {
+            const level = this.formatting.outlineLevel + 1;
+            return level >= 1 && level <= 9 ? level : null;
+        }
+        const text = this.getText().trim();
+        if (!text)
+            return null;
+        const runs = this.getRuns();
+        if (runs.length === 0)
+            return null;
+        const firstRun = runs[0];
+        if (!firstRun)
+            return null;
+        const fmt = firstRun.getFormatting();
+        if (!fmt)
+            return null;
+        if (fmt.bold && fmt.size) {
+            if (fmt.size >= 24)
+                return 1;
+            if (fmt.size >= 20)
+                return 2;
+            if (fmt.size >= 16)
+                return 3;
+            if (fmt.size >= 14)
+                return 4;
+        }
+        if (fmt.bold && fmt.allCaps && text.length < 100) {
+            return 2;
+        }
+        return null;
+    }
+    setAlignment(alignment) {
+        const previousValue = this.formatting.alignment;
+        this.formatting.alignment = alignment;
+        if (this.trackingContext?.isEnabled() && previousValue !== alignment) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'alignment', previousValue, alignment);
+        }
+        return this;
+    }
+    setLeftIndent(twips) {
+        if (this.formatting.numbering) {
+            defaultLogger.warn('Setting left indentation on a numbered paragraph has no effect. ' +
+                'Numbering controls indentation. Use different numbering levels to change indent.');
+        }
+        const previousValue = this.formatting.indentation?.left;
+        if (!this.formatting.indentation) {
+            this.formatting.indentation = {};
+        }
+        this.formatting.indentation.left = twips;
+        if (this.trackingContext?.isEnabled() && previousValue !== twips) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'indentation.left', previousValue, twips);
+        }
+        return this;
+    }
+    setRightIndent(twips) {
+        const previousValue = this.formatting.indentation?.right;
+        if (!this.formatting.indentation) {
+            this.formatting.indentation = {};
+        }
+        this.formatting.indentation.right = twips;
+        if (this.trackingContext?.isEnabled() && previousValue !== twips) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'indentation.right', previousValue, twips);
+        }
+        return this;
+    }
+    setFirstLineIndent(twips) {
+        if (this.formatting.numbering) {
+            defaultLogger.warn('Setting first line indentation on a numbered paragraph has no effect. ' +
+                'Numbering controls indentation using hanging indent.');
+        }
+        const previousValue = this.formatting.indentation?.firstLine;
+        if (!this.formatting.indentation) {
+            this.formatting.indentation = {};
+        }
+        this.formatting.indentation.firstLine = twips;
+        if (this.trackingContext?.isEnabled() && previousValue !== twips) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'indentation.firstLine', previousValue, twips);
+        }
+        return this;
+    }
+    setHangingIndent(twips) {
+        if (twips < 0) {
+            throw new Error('Hanging indent must be non-negative');
+        }
+        if (this.formatting.numbering) {
+            defaultLogger.warn('Setting hanging indentation on a numbered paragraph has no effect. ' +
+                'Numbering controls indentation.');
+        }
+        const previousValue = this.formatting.indentation?.hanging;
+        if (!this.formatting.indentation) {
+            this.formatting.indentation = {};
+        }
+        this.formatting.indentation.hanging = twips;
+        if (this.trackingContext?.isEnabled() && previousValue !== twips) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'indentation.hanging', previousValue, twips);
+        }
+        return this;
+    }
+    setSpaceBefore(twips) {
+        const previousValue = this.formatting.spacing?.before;
+        if (!this.formatting.spacing) {
+            this.formatting.spacing = {};
+        }
+        this.formatting.spacing.before = twips;
+        if (this.trackingContext?.isEnabled() && previousValue !== twips) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'spacing.before', previousValue, twips);
+        }
+        return this;
+    }
+    setSpaceAfter(twips) {
+        const previousValue = this.formatting.spacing?.after;
+        if (!this.formatting.spacing) {
+            this.formatting.spacing = {};
+        }
+        this.formatting.spacing.after = twips;
+        if (this.trackingContext?.isEnabled() && previousValue !== twips) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'spacing.after', previousValue, twips);
+        }
+        return this;
+    }
+    setLineSpacing(twips, rule = 'auto') {
+        const previousLine = this.formatting.spacing?.line;
+        const previousRule = this.formatting.spacing?.lineRule;
+        if (!this.formatting.spacing) {
+            this.formatting.spacing = {};
+        }
+        this.formatting.spacing.line = twips;
+        this.formatting.spacing.lineRule = rule;
+        if (this.trackingContext?.isEnabled()) {
+            if (previousLine !== twips) {
+                this.trackingContext.trackParagraphPropertyChange(this, 'spacing.line', previousLine, twips);
+            }
+            if (previousRule !== rule) {
+                this.trackingContext.trackParagraphPropertyChange(this, 'spacing.lineRule', previousRule, rule);
+            }
+        }
+        return this;
+    }
+    clearSpacing() {
+        delete this.formatting.spacing;
+        return this;
+    }
+    setStyle(styleId) {
+        const previousValue = this.formatting.style;
+        this.formatting.style = styleId;
+        if (this.trackingContext?.isEnabled() && previousValue !== styleId) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'style', previousValue, styleId);
+        }
+        return this;
+    }
+    setKeepNext(keepNext = true) {
+        const previousValue = this.formatting.keepNext;
+        this.formatting.keepNext = keepNext;
+        if (keepNext) {
+            this.formatting.pageBreakBefore = undefined;
+        }
+        if (this.trackingContext?.isEnabled() && previousValue !== keepNext) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'keepNext', previousValue, keepNext);
+        }
+        return this;
+    }
+    setKeepLines(keepLines = true) {
+        const previousValue = this.formatting.keepLines;
+        this.formatting.keepLines = keepLines;
+        if (keepLines) {
+            this.formatting.pageBreakBefore = undefined;
+        }
+        if (this.trackingContext?.isEnabled() && previousValue !== keepLines) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'keepLines', previousValue, keepLines);
+        }
+        return this;
+    }
+    setPageBreakBefore(pageBreakBefore = true) {
+        const previousValue = this.formatting.pageBreakBefore;
+        this.formatting.pageBreakBefore = pageBreakBefore;
+        if (this.trackingContext?.isEnabled() && previousValue !== pageBreakBefore) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'pageBreakBefore', previousValue, pageBreakBefore);
+        }
+        return this;
+    }
+    setPreserved(preserved = true) {
+        this._isPreserved = preserved;
+        return this;
+    }
+    isPreserved() {
+        return this._isPreserved;
+    }
+    setNumbering(numId, level = 0) {
+        if (numId < 0) {
+            throw new Error('Numbering ID must be non-negative');
+        }
+        if (level < 0 || level > 8) {
+            throw new Error('Level must be between 0 and 8');
+        }
+        const previousValue = this.formatting.numbering;
+        this.formatting.numbering = { numId, level };
+        delete this.formatting.numberingSuppressed;
+        if (this.formatting.indentation) {
+            const { right } = this.formatting.indentation;
+            this.formatting.indentation = right !== undefined ? { right } : undefined;
+        }
+        if (this.trackingContext?.isEnabled()) {
+            const newValue = { numId, level };
+            if (previousValue?.numId !== newValue.numId || previousValue?.level !== newValue.level) {
+                this.trackingContext.trackParagraphPropertyChange(this, 'numbering', previousValue, newValue);
+            }
+        }
+        return this;
+    }
+    setContextualSpacing(enable = true) {
+        const previousValue = this.formatting.contextualSpacing;
+        this.formatting.contextualSpacing = enable;
+        if (this.trackingContext?.isEnabled() && previousValue !== enable) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'contextualSpacing', previousValue, enable);
+        }
+        return this;
+    }
+    removeNumbering() {
+        delete this.formatting.numbering;
+        delete this.formatting.numberingSuppressed;
+        return this;
+    }
+    getNumbering() {
+        return this.formatting.numbering ? { ...this.formatting.numbering } : undefined;
+    }
+    setWidowControl(enable = true) {
+        const previousValue = this.formatting.widowControl;
+        this.formatting.widowControl = enable;
+        if (this.trackingContext?.isEnabled() && previousValue !== enable) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'widowControl', previousValue, enable);
+        }
+        return this;
+    }
+    setOutlineLevel(level) {
+        if (level < 0 || level > 9) {
+            throw new Error('Outline level must be between 0 and 9');
+        }
+        const previousValue = this.formatting.outlineLevel;
+        this.formatting.outlineLevel = level;
+        if (this.trackingContext?.isEnabled() && previousValue !== level) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'outlineLevel', previousValue, level);
+        }
+        return this;
+    }
+    setSuppressLineNumbers(suppress = true) {
+        const previousValue = this.formatting.suppressLineNumbers;
+        this.formatting.suppressLineNumbers = suppress;
+        if (this.trackingContext?.isEnabled() && previousValue !== suppress) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'suppressLineNumbers', previousValue, suppress);
+        }
+        return this;
+    }
+    setBidi(enable = true) {
+        const previousValue = this.formatting.bidi;
+        this.formatting.bidi = enable;
+        if (this.trackingContext?.isEnabled() && previousValue !== enable) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'bidi', previousValue, enable);
+        }
+        return this;
+    }
+    setTextDirection(direction) {
+        const previousValue = this.formatting.textDirection;
+        this.formatting.textDirection = direction;
+        if (this.trackingContext?.isEnabled() && previousValue !== direction) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'textDirection', previousValue, direction);
+        }
+        return this;
+    }
+    setTextAlignment(alignment) {
+        const previousValue = this.formatting.textAlignment;
+        this.formatting.textAlignment = alignment;
+        if (this.trackingContext?.isEnabled() && previousValue !== alignment) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'textAlignment', previousValue, alignment);
+        }
+        return this;
+    }
+    setMirrorIndents(enable = true) {
+        const previousValue = this.formatting.mirrorIndents;
+        this.formatting.mirrorIndents = enable;
+        if (this.trackingContext?.isEnabled() && previousValue !== enable) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'mirrorIndents', previousValue, enable);
+        }
+        return this;
+    }
+    setAdjustRightInd(enable = true) {
+        const previousValue = this.formatting.adjustRightInd;
+        this.formatting.adjustRightInd = enable;
+        if (this.trackingContext?.isEnabled() && previousValue !== enable) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'adjustRightInd', previousValue, enable);
+        }
+        return this;
+    }
+    setFrameProperties(props) {
+        const previousValue = this.formatting.framePr;
+        this.formatting.framePr = props;
+        if (this.trackingContext?.isEnabled() && previousValue !== props) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'framePr', previousValue, props);
+        }
+        return this;
+    }
+    setSuppressAutoHyphens(suppress = true) {
+        const previousValue = this.formatting.suppressAutoHyphens;
+        this.formatting.suppressAutoHyphens = suppress;
+        if (this.trackingContext?.isEnabled() && previousValue !== suppress) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'suppressAutoHyphens', previousValue, suppress);
+        }
+        return this;
+    }
+    setKinsoku(enable = true) {
+        this.formatting.kinsoku = enable;
+        return this;
+    }
+    setWordWrap(enable = true) {
+        this.formatting.wordWrap = enable;
+        return this;
+    }
+    setOverflowPunct(enable = true) {
+        this.formatting.overflowPunct = enable;
+        return this;
+    }
+    setTopLinePunct(enable = true) {
+        this.formatting.topLinePunct = enable;
+        return this;
+    }
+    setAutoSpaceDE(enable = true) {
+        this.formatting.autoSpaceDE = enable;
+        return this;
+    }
+    setAutoSpaceDN(enable = true) {
+        this.formatting.autoSpaceDN = enable;
+        return this;
+    }
+    setSuppressOverlap(suppress = true) {
+        const previousValue = this.formatting.suppressOverlap;
+        this.formatting.suppressOverlap = suppress;
+        if (this.trackingContext?.isEnabled() && previousValue !== suppress) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'suppressOverlap', previousValue, suppress);
+        }
+        return this;
+    }
+    setTextboxTightWrap(wrap) {
+        const previousValue = this.formatting.textboxTightWrap;
+        this.formatting.textboxTightWrap = wrap;
+        if (this.trackingContext?.isEnabled() && previousValue !== wrap) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'textboxTightWrap', previousValue, wrap);
+        }
+        return this;
+    }
+    setDivId(id) {
+        const previousValue = this.formatting.divId;
+        this.formatting.divId = id;
+        if (this.trackingContext?.isEnabled() && previousValue !== id) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'divId', previousValue, id);
+        }
+        return this;
+    }
+    setConditionalFormatting(bitmask) {
+        const previousValue = this.formatting.cnfStyle;
+        this.formatting.cnfStyle = bitmask;
+        if (this.trackingContext?.isEnabled() && previousValue !== bitmask) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'cnfStyle', previousValue, bitmask);
+        }
+        return this;
+    }
+    setSectionProperties(properties) {
+        const previousValue = this.formatting.sectPr;
+        this.formatting.sectPr = properties;
+        if (this.trackingContext?.isEnabled() && previousValue !== properties) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'sectPr', previousValue, properties);
+        }
+        return this;
+    }
+    setParagraphPropertiesChange(change) {
+        const previousValue = this.formatting.pPrChange;
+        this.formatting.pPrChange = change;
+        if (this.trackingContext?.isEnabled() && previousValue !== change) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'pPrChange', previousValue, change);
+        }
+        return this;
+    }
+    clearParagraphPropertiesChange() {
+        delete this.formatting.pPrChange;
+        return this;
+    }
+    setParagraphMarkFormatting(properties) {
+        const previousValue = this.formatting.paragraphMarkRunProperties;
+        this.formatting.paragraphMarkRunProperties = properties;
+        if (this.trackingContext?.isEnabled() && previousValue !== properties) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'paragraphMarkRunProperties', previousValue, properties);
+        }
+        return this;
+    }
+    markParagraphMarkAsDeleted(id, author, date) {
+        this.formatting.paragraphMarkDeletion = {
+            id,
+            author,
+            date: date || new Date(),
+        };
+        return this;
+    }
+    clearParagraphMarkDeletion() {
+        delete this.formatting.paragraphMarkDeletion;
+        return this;
+    }
+    isParagraphMarkDeleted() {
+        return !!this.formatting.paragraphMarkDeletion;
+    }
+    markParagraphMarkAsInserted(id, author, date) {
+        this.formatting.paragraphMarkInsertion = {
+            id,
+            author,
+            date: date || new Date(),
+        };
+        return this;
+    }
+    clearParagraphMarkInsertion() {
+        delete this.formatting.paragraphMarkInsertion;
+        return this;
+    }
+    isParagraphMarkInserted() {
+        return !!this.formatting.paragraphMarkInsertion;
+    }
+    toXML() {
+        const runData = this.getRuns().map((run) => ({
+            text: run.getText(),
+            rtl: run.isRTL(),
+        }));
+        logParagraphContent('serialization', -1, runData, this.formatting.bidi);
+        if (this.formatting.bidi) {
+            logTextDirection(`Serializing paragraph with BiDi enabled`);
+        }
+        const pPrChildren = [];
+        if (this.formatting.style) {
+            pPrChildren.push(XMLBuilder.wSelf('pStyle', { 'w:val': this.formatting.style }));
+        }
+        if (this.formatting.keepNext !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('keepNext', { 'w:val': this.formatting.keepNext ? '1' : '0' }));
+        }
+        if (this.formatting.keepLines !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('keepLines', { 'w:val': this.formatting.keepLines ? '1' : '0' }));
+        }
+        if (this.formatting.pageBreakBefore !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('pageBreakBefore', {
+                'w:val': this.formatting.pageBreakBefore ? '1' : '0',
+            }));
+        }
+        if (this.formatting.framePr) {
+            const attrs = {};
+            const f = this.formatting.framePr;
+            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));
+            }
+        }
+        if (this.formatting.widowControl !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('widowControl', {
+                'w:val': this.formatting.widowControl ? '1' : '0',
+            }));
+        }
+        if (this.formatting.numbering) {
+            const numPr = XMLBuilder.w('numPr', undefined, [
+                XMLBuilder.wSelf('ilvl', {
+                    'w:val': this.formatting.numbering.level.toString(),
+                }),
+                XMLBuilder.wSelf('numId', {
+                    'w:val': this.formatting.numbering.numId.toString(),
+                }),
+            ]);
+            pPrChildren.push(numPr);
+        }
+        else if (this.formatting.numberingSuppressed) {
+            const numPr = XMLBuilder.w('numPr', undefined, [
+                XMLBuilder.wSelf('ilvl', { 'w:val': '0' }),
+                XMLBuilder.wSelf('numId', { 'w:val': '0' }),
+            ]);
+            pPrChildren.push(numPr);
+        }
+        if (this.formatting.suppressLineNumbers !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('suppressLineNumbers', {
+                'w:val': this.formatting.suppressLineNumbers ? '1' : '0',
+            }));
+        }
+        if (this.formatting.borders) {
+            const borderChildren = [];
+            const borders = this.formatting.borders;
+            const createBorder = (borderType, border) => {
+                if (!border)
+                    return null;
+                const attributes = {
+                    'w:val': border.style ?? 'nil',
+                };
+                if (border.size !== undefined)
+                    attributes['w:sz'] = border.size;
+                if (border.color)
+                    attributes['w:color'] = border.color;
+                if (border.space !== undefined)
+                    attributes['w:space'] = border.space;
+                if (border.themeColor)
+                    attributes['w:themeColor'] = border.themeColor;
+                if (border.themeTint)
+                    attributes['w:themeTint'] = border.themeTint;
+                if (border.themeShade)
+                    attributes['w:themeShade'] = border.themeShade;
+                if (border.shadow !== undefined)
+                    attributes['w:shadow'] = border.shadow ? '1' : '0';
+                if (border.frame !== undefined)
+                    attributes['w:frame'] = border.frame ? '1' : '0';
+                return XMLBuilder.wSelf(borderType, attributes);
+            };
+            const topBorder = createBorder('top', borders.top);
+            if (topBorder)
+                borderChildren.push(topBorder);
+            const leftBorder = createBorder('left', borders.left);
+            if (leftBorder)
+                borderChildren.push(leftBorder);
+            const bottomBorder = createBorder('bottom', borders.bottom);
+            if (bottomBorder)
+                borderChildren.push(bottomBorder);
+            const rightBorder = createBorder('right', borders.right);
+            if (rightBorder)
+                borderChildren.push(rightBorder);
+            const betweenBorder = createBorder('between', borders.between);
+            if (betweenBorder)
+                borderChildren.push(betweenBorder);
+            const barBorder = createBorder('bar', borders.bar);
+            if (barBorder)
+                borderChildren.push(barBorder);
+            if (borderChildren.length > 0) {
+                pPrChildren.push(XMLBuilder.w('pBdr', undefined, borderChildren));
+            }
+        }
+        if (this.formatting.shading) {
+            const shdAttrs = buildShadingAttributes(this.formatting.shading);
+            if (Object.keys(shdAttrs).length > 0) {
+                pPrChildren.push(XMLBuilder.wSelf('shd', shdAttrs));
+            }
+        }
+        if (this.formatting.tabs && this.formatting.tabs.length > 0) {
+            const tabChildren = [];
+            for (const tab of this.formatting.tabs) {
+                const attributes = {
+                    'w:val': tab.val ?? 'left',
+                    'w:pos': tab.position,
+                };
+                if (tab.leader)
+                    attributes['w:leader'] = tab.leader;
+                tabChildren.push(XMLBuilder.wSelf('tab', attributes));
+            }
+            if (tabChildren.length > 0) {
+                pPrChildren.push(XMLBuilder.w('tabs', undefined, tabChildren));
+            }
+        }
+        if (this.formatting.suppressAutoHyphens !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('suppressAutoHyphens', {
+                'w:val': this.formatting.suppressAutoHyphens ? '1' : '0',
+            }));
+        }
+        if (this.formatting.kinsoku !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('kinsoku', { 'w:val': this.formatting.kinsoku ? '1' : '0' }));
+        }
+        if (this.formatting.wordWrap !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('wordWrap', { 'w:val': this.formatting.wordWrap ? '1' : '0' }));
+        }
+        if (this.formatting.overflowPunct !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('overflowPunct', { 'w:val': this.formatting.overflowPunct ? '1' : '0' }));
+        }
+        if (this.formatting.topLinePunct !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('topLinePunct', { 'w:val': this.formatting.topLinePunct ? '1' : '0' }));
+        }
+        if (this.formatting.autoSpaceDE !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('autoSpaceDE', { 'w:val': this.formatting.autoSpaceDE ? '1' : '0' }));
+        }
+        if (this.formatting.autoSpaceDN !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('autoSpaceDN', { 'w:val': this.formatting.autoSpaceDN ? '1' : '0' }));
+        }
+        if (this.formatting.bidi !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('bidi', { 'w:val': this.formatting.bidi ? '1' : '0' }));
+        }
+        if (this.formatting.adjustRightInd !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('adjustRightInd', {
+                'w:val': this.formatting.adjustRightInd ? '1' : '0',
+            }));
+        }
+        if (this.formatting.spacing) {
+            const spc = this.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 (this.formatting.indentation) {
+            const ind = this.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));
+            }
+        }
+        if (this.formatting.contextualSpacing !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('contextualSpacing', {
+                'w:val': this.formatting.contextualSpacing ? '1' : '0',
+            }));
+        }
+        if (this.formatting.mirrorIndents !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('mirrorIndents', { 'w:val': this.formatting.mirrorIndents ? '1' : '0' }));
+        }
+        if (this.formatting.suppressOverlap !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('suppressOverlap', {
+                'w:val': this.formatting.suppressOverlap ? '1' : '0',
+            }));
+        }
+        if (this.formatting.alignment) {
+            const alignmentValue = this.formatting.alignment === 'justify' ? 'both' : this.formatting.alignment;
+            pPrChildren.push(XMLBuilder.wSelf('jc', { 'w:val': alignmentValue }));
+        }
+        if (this.formatting.textDirection) {
+            pPrChildren.push(XMLBuilder.wSelf('textDirection', {
+                'w:val': this.formatting.textDirection,
+            }));
+        }
+        if (this.formatting.textAlignment) {
+            pPrChildren.push(XMLBuilder.wSelf('textAlignment', {
+                'w:val': this.formatting.textAlignment,
+            }));
+        }
+        if (this.formatting.textboxTightWrap) {
+            pPrChildren.push(XMLBuilder.wSelf('textboxTightWrap', {
+                'w:val': this.formatting.textboxTightWrap,
+            }));
+        }
+        if (this.formatting.outlineLevel !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('outlineLvl', {
+                'w:val': this.formatting.outlineLevel.toString(),
+            }));
+        }
+        if (this.formatting.divId !== undefined) {
+            pPrChildren.push(XMLBuilder.wSelf('divId', { 'w:val': this.formatting.divId.toString() }));
+        }
+        if (this.formatting.cnfStyle) {
+            pPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': this.formatting.cnfStyle }));
+        }
+        if (this.formatting.paragraphMarkRunProperties ||
+            this.formatting.paragraphMarkDeletion ||
+            this.formatting.paragraphMarkInsertion ||
+            this.formatting.paragraphMarkRunPropertiesChange) {
+            const rPrChildren = [];
+            if (this.formatting.paragraphMarkInsertion) {
+                const ins = this.formatting.paragraphMarkInsertion;
+                rPrChildren.push(XMLBuilder.wSelf('ins', {
+                    'w:id': ins.id.toString(),
+                    'w:author': ins.author,
+                    'w:date': formatDateForXml(ins.date),
+                }));
+            }
+            if (this.formatting.paragraphMarkDeletion) {
+                const del = this.formatting.paragraphMarkDeletion;
+                rPrChildren.push(XMLBuilder.wSelf('del', {
+                    'w:id': del.id.toString(),
+                    'w:author': del.author,
+                    'w:date': formatDateForXml(del.date),
+                }));
+            }
+            if (this.formatting.paragraphMarkRunProperties) {
+                const rPr = Run.generateRunPropertiesXML(this.formatting.paragraphMarkRunProperties);
+                if (rPr?.children) {
+                    for (const child of rPr.children) {
+                        if (typeof child !== 'string') {
+                            rPrChildren.push(child);
+                        }
+                    }
+                }
+            }
+            const paraRPrChange = this.formatting.paragraphMarkRunPropertiesChange;
+            if (paraRPrChange) {
+                const prevRPr = Run.generateRunPropertiesXML(paraRPrChange.previousProperties);
+                const prevRPrElement = prevRPr ?? {
+                    name: 'w:rPr',
+                    attributes: {},
+                    children: [],
+                };
+                rPrChildren.push({
+                    name: 'w:rPrChange',
+                    attributes: {
+                        'w:id': paraRPrChange.id.toString(),
+                        'w:author': paraRPrChange.author,
+                        'w:date': formatDateForXml(paraRPrChange.date),
+                    },
+                    children: [prevRPrElement],
+                });
+            }
+            if (rPrChildren.length > 0) {
+                pPrChildren.push(XMLBuilder.w('rPr', undefined, rPrChildren));
+            }
+        }
+        if (this.formatting.sectPr) {
+            if (typeof this.formatting.sectPr === 'string') {
+                pPrChildren.push({
+                    name: '__rawXml',
+                    rawXml: this.formatting.sectPr,
+                });
+            }
+        }
+        if (this.formatting.pPrChange) {
+            const change = this.formatting.pPrChange;
+            const attrs = {};
+            if (change.id)
+                attrs['w:id'] = change.id;
+            if (change.author)
+                attrs['w:author'] = change.author;
+            if (change.date)
+                attrs['w:date'] = change.date;
+            const prevPPrChildren = [];
+            if (change.previousProperties) {
+                const prev = change.previousProperties;
+                if (prev.style) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('pStyle', { 'w:val': prev.style }));
+                }
+                if (prev.keepNext !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('keepNext', prev.keepNext ? { 'w:val': '1' } : { 'w:val': '0' }));
+                }
+                if (prev.keepLines !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('keepLines', prev.keepLines ? { 'w:val': '1' } : { 'w:val': '0' }));
+                }
+                if (prev.pageBreakBefore !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('pageBreakBefore', prev.pageBreakBefore ? { 'w:val': '1' } : { 'w:val': '0' }));
+                }
+                if (prev.framePr) {
+                    const fAttrs = {};
+                    const f = prev.framePr;
+                    if (f.w !== undefined)
+                        fAttrs['w:w'] = f.w.toString();
+                    if (f.h !== undefined)
+                        fAttrs['w:h'] = f.h.toString();
+                    if (f.hRule)
+                        fAttrs['w:hRule'] = f.hRule;
+                    if (f.x !== undefined)
+                        fAttrs['w:x'] = f.x.toString();
+                    if (f.y !== undefined)
+                        fAttrs['w:y'] = f.y.toString();
+                    if (f.xAlign)
+                        fAttrs['w:xAlign'] = f.xAlign;
+                    if (f.yAlign)
+                        fAttrs['w:yAlign'] = f.yAlign;
+                    if (f.hAnchor)
+                        fAttrs['w:hAnchor'] = f.hAnchor;
+                    if (f.vAnchor)
+                        fAttrs['w:vAnchor'] = f.vAnchor;
+                    if (f.hSpace !== undefined)
+                        fAttrs['w:hSpace'] = f.hSpace.toString();
+                    if (f.vSpace !== undefined)
+                        fAttrs['w:vSpace'] = f.vSpace.toString();
+                    if (f.wrap)
+                        fAttrs['w:wrap'] = f.wrap;
+                    if (f.dropCap)
+                        fAttrs['w:dropCap'] = f.dropCap;
+                    if (f.lines !== undefined)
+                        fAttrs['w:lines'] = f.lines.toString();
+                    if (f.anchorLock !== undefined)
+                        fAttrs['w:anchorLock'] = f.anchorLock ? '1' : '0';
+                    if (Object.keys(fAttrs).length > 0) {
+                        prevPPrChildren.push(XMLBuilder.wSelf('framePr', fAttrs));
+                    }
+                }
+                if (prev.widowControl !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('widowControl', {
+                        'w:val': prev.widowControl ? '1' : '0',
+                    }));
+                }
+                if (prev.numbering) {
+                    const numPrChildren = [];
+                    if (prev.numbering.level !== undefined) {
+                        numPrChildren.push(XMLBuilder.wSelf('ilvl', { 'w:val': prev.numbering.level.toString() }));
+                    }
+                    if (prev.numbering.numId !== undefined) {
+                        numPrChildren.push(XMLBuilder.wSelf('numId', { 'w:val': prev.numbering.numId.toString() }));
+                    }
+                    if (numPrChildren.length > 0) {
+                        prevPPrChildren.push(XMLBuilder.w('numPr', undefined, numPrChildren));
+                    }
+                }
+                else if (prev.numberingSuppressed) {
+                    prevPPrChildren.push(XMLBuilder.w('numPr', undefined, [
+                        XMLBuilder.wSelf('ilvl', { 'w:val': '0' }),
+                        XMLBuilder.wSelf('numId', { 'w:val': '0' }),
+                    ]));
+                }
+                if (prev.suppressLineNumbers !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('suppressLineNumbers', {
+                        'w:val': prev.suppressLineNumbers ? '1' : '0',
+                    }));
+                }
+                if (prev.borders) {
+                    const borderChildren = [];
+                    const borderSides = ['top', 'left', 'bottom', 'right', 'between', 'bar'];
+                    for (const side of borderSides) {
+                        const border = prev.borders[side];
+                        if (border) {
+                            const attrs = { 'w:val': border.style ?? 'nil' };
+                            if (border.size !== undefined)
+                                attrs['w:sz'] = border.size.toString();
+                            if (border.color)
+                                attrs['w:color'] = border.color;
+                            if (border.space !== undefined)
+                                attrs['w:space'] = border.space.toString();
+                            if (border.themeColor)
+                                attrs['w:themeColor'] = border.themeColor;
+                            if (border.themeTint)
+                                attrs['w:themeTint'] = border.themeTint;
+                            if (border.themeShade)
+                                attrs['w:themeShade'] = border.themeShade;
+                            if (border.shadow !== undefined)
+                                attrs['w:shadow'] = border.shadow ? '1' : '0';
+                            if (border.frame !== undefined)
+                                attrs['w:frame'] = border.frame ? '1' : '0';
+                            borderChildren.push(XMLBuilder.wSelf(side, attrs));
+                        }
+                    }
+                    if (borderChildren.length > 0) {
+                        prevPPrChildren.push(XMLBuilder.w('pBdr', undefined, borderChildren));
+                    }
+                }
+                if (prev.shading) {
+                    const shdAttrs = buildShadingAttributes(prev.shading);
+                    if (Object.keys(shdAttrs).length > 0) {
+                        prevPPrChildren.push(XMLBuilder.wSelf('shd', shdAttrs));
+                    }
+                }
+                if (prev.tabs && prev.tabs.length > 0) {
+                    const tabChildren = prev.tabs.map((tab) => {
+                        const tabAttrs = {
+                            'w:val': tab.val ?? 'left',
+                            'w:pos': tab.position.toString(),
+                        };
+                        if (tab.leader)
+                            tabAttrs['w:leader'] = tab.leader;
+                        return XMLBuilder.wSelf('tab', tabAttrs);
+                    });
+                    prevPPrChildren.push(XMLBuilder.w('tabs', undefined, tabChildren));
+                }
+                if (prev.suppressAutoHyphens !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('suppressAutoHyphens', {
+                        'w:val': prev.suppressAutoHyphens ? '1' : '0',
+                    }));
+                }
+                if (prev.kinsoku !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('kinsoku', { 'w:val': prev.kinsoku ? '1' : '0' }));
+                }
+                if (prev.wordWrap !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('wordWrap', { 'w:val': prev.wordWrap ? '1' : '0' }));
+                }
+                if (prev.overflowPunct !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('overflowPunct', { 'w:val': prev.overflowPunct ? '1' : '0' }));
+                }
+                if (prev.topLinePunct !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('topLinePunct', { 'w:val': prev.topLinePunct ? '1' : '0' }));
+                }
+                if (prev.autoSpaceDE !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('autoSpaceDE', { 'w:val': prev.autoSpaceDE ? '1' : '0' }));
+                }
+                if (prev.autoSpaceDN !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('autoSpaceDN', { 'w:val': prev.autoSpaceDN ? '1' : '0' }));
+                }
+                if (prev.bidi !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('bidi', { 'w:val': prev.bidi ? '1' : '0' }));
+                }
+                if (prev.adjustRightInd !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('adjustRightInd', {
+                        'w:val': prev.adjustRightInd ? '1' : '0',
+                    }));
+                }
+                if (prev.spacing) {
+                    const spacingAttrs = {};
+                    if (prev.spacing.before !== undefined)
+                        spacingAttrs['w:before'] = prev.spacing.before.toString();
+                    if (prev.spacing.beforeLines !== undefined)
+                        spacingAttrs['w:beforeLines'] = prev.spacing.beforeLines.toString();
+                    if (prev.spacing.beforeAutospacing !== undefined)
+                        spacingAttrs['w:beforeAutospacing'] = prev.spacing.beforeAutospacing ? '1' : '0';
+                    if (prev.spacing.after !== undefined)
+                        spacingAttrs['w:after'] = prev.spacing.after.toString();
+                    if (prev.spacing.afterLines !== undefined)
+                        spacingAttrs['w:afterLines'] = prev.spacing.afterLines.toString();
+                    if (prev.spacing.afterAutospacing !== undefined)
+                        spacingAttrs['w:afterAutospacing'] = prev.spacing.afterAutospacing ? '1' : '0';
+                    if (prev.spacing.line !== undefined)
+                        spacingAttrs['w:line'] = prev.spacing.line.toString();
+                    if (prev.spacing.lineRule)
+                        spacingAttrs['w:lineRule'] = prev.spacing.lineRule;
+                    if (Object.keys(spacingAttrs).length > 0) {
+                        prevPPrChildren.push(XMLBuilder.wSelf('spacing', spacingAttrs));
+                    }
+                }
+                if (prev.indentation) {
+                    const indAttrs = {};
+                    const indentation = prev.indentation;
+                    if (indentation.left !== undefined)
+                        indAttrs['w:left'] = indentation.left.toString();
+                    if (indentation.right !== undefined)
+                        indAttrs['w:right'] = indentation.right.toString();
+                    if (indentation.hanging !== undefined) {
+                        indAttrs['w:hanging'] = indentation.hanging.toString();
+                    }
+                    else if (indentation.firstLine !== undefined) {
+                        indAttrs['w:firstLine'] = indentation.firstLine.toString();
+                    }
+                    if (indentation.leftChars !== undefined)
+                        indAttrs['w:leftChars'] = indentation.leftChars.toString();
+                    if (indentation.rightChars !== undefined)
+                        indAttrs['w:rightChars'] = indentation.rightChars.toString();
+                    if (indentation.hangingChars !== undefined) {
+                        indAttrs['w:hangingChars'] = indentation.hangingChars.toString();
+                    }
+                    else if (indentation.firstLineChars !== undefined) {
+                        indAttrs['w:firstLineChars'] = indentation.firstLineChars.toString();
+                    }
+                    prevPPrChildren.push(XMLBuilder.wSelf('ind', indAttrs));
+                }
+                if (prev.contextualSpacing !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('contextualSpacing', {
+                        'w:val': prev.contextualSpacing ? '1' : '0',
+                    }));
+                }
+                if (prev.mirrorIndents !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('mirrorIndents', {
+                        'w:val': prev.mirrorIndents ? '1' : '0',
+                    }));
+                }
+                if (prev.suppressOverlap !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('suppressOverlap', {
+                        'w:val': prev.suppressOverlap ? '1' : '0',
+                    }));
+                }
+                if (prev.alignment) {
+                    const alignmentValue = prev.alignment === 'justify' ? 'both' : prev.alignment;
+                    prevPPrChildren.push(XMLBuilder.wSelf('jc', { 'w:val': alignmentValue }));
+                }
+                if (prev.textDirection) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('textDirection', { 'w:val': prev.textDirection }));
+                }
+                if (prev.textAlignment) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('textAlignment', { 'w:val': prev.textAlignment }));
+                }
+                if (prev.textboxTightWrap) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('textboxTightWrap', { 'w:val': prev.textboxTightWrap }));
+                }
+                if (prev.outlineLevel !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('outlineLvl', { 'w:val': prev.outlineLevel.toString() }));
+                }
+                if (prev.divId !== undefined) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('divId', { 'w:val': prev.divId.toString() }));
+                }
+                if (prev.cnfStyle) {
+                    prevPPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': prev.cnfStyle }));
+                }
+            }
+            if (prevPPrChildren.length > 0) {
+                const pPrChangeChildren = [
+                    {
+                        name: 'w:pPr',
+                        attributes: {},
+                        children: prevPPrChildren,
+                    },
+                ];
+                pPrChildren.push({
+                    name: 'w:pPrChange',
+                    attributes: attrs,
+                    children: pPrChangeChildren,
+                });
+            }
+        }
+        const paragraphChildren = [];
+        if (pPrChildren.length > 0) {
+            paragraphChildren.push(XMLBuilder.w('pPr', undefined, pPrChildren));
+        }
+        for (const bookmark of this.bookmarksStart) {
+            paragraphChildren.push(bookmark.toStartXML());
+        }
+        for (const comment of this.commentsStart) {
+            paragraphChildren.push(comment.toRangeStartXML());
+        }
+        for (let i = 0; i < this.content.length; i++) {
+            const item = this.content[i];
+            if (item instanceof Field) {
+                paragraphChildren.push(item.toXML());
+            }
+            else if (item instanceof ComplexField) {
+                const fieldXml = item.toXML();
+                if (Array.isArray(fieldXml)) {
+                    paragraphChildren.push(...fieldXml);
+                }
+                else {
+                    paragraphChildren.push(XMLBuilder.w('r', undefined, [fieldXml]));
+                }
+            }
+            else if (item instanceof Hyperlink) {
+                paragraphChildren.push(item.toXML());
+            }
+            else if (item instanceof Revision) {
+                const revType = item.getType();
+                if (revType === 'runPropertiesChange' ||
+                    revType === 'paragraphPropertiesChange' ||
+                    revType === 'tablePropertiesChange' ||
+                    revType === 'tableExceptionPropertiesChange' ||
+                    revType === 'tableRowPropertiesChange' ||
+                    revType === 'tableCellPropertiesChange' ||
+                    revType === 'sectionPropertiesChange' ||
+                    revType === 'numberingChange') {
+                    continue;
+                }
+                const revisionXml = item.toXML();
+                if (revisionXml) {
+                    paragraphChildren.push(revisionXml);
+                }
+            }
+            else if (item instanceof RangeMarker) {
+                paragraphChildren.push(item.toXML());
+            }
+            else if (item instanceof Shape) {
+                paragraphChildren.push(XMLBuilder.w('r', undefined, [item.toXML()]));
+            }
+            else if (item instanceof TextBox) {
+                paragraphChildren.push(XMLBuilder.w('r', undefined, [item.toXML()]));
+            }
+            else if (item) {
+                paragraphChildren.push(item.toXML());
+            }
+        }
+        if (this.content.length === 0) {
+            paragraphChildren.push(new Run('').toXML());
+        }
+        for (const comment of this.commentsEnd) {
+            paragraphChildren.push(comment.toRangeEndXML());
+        }
+        for (const comment of this.commentsEnd) {
+            paragraphChildren.push(comment.toReferenceXML());
+        }
+        for (const bookmark of this.bookmarksEnd) {
+            paragraphChildren.push(bookmark.toEndXML());
+        }
+        const paragraphAttributes = {};
+        if (this.formatting.paraId) {
+            paragraphAttributes['w14:paraId'] = this.formatting.paraId;
+        }
+        if (this.formatting.textId) {
+            paragraphAttributes['w14:textId'] = this.formatting.textId;
+        }
+        return XMLBuilder.w('p', Object.keys(paragraphAttributes).length > 0 ? paragraphAttributes : undefined, paragraphChildren);
+    }
+    getWordCount() {
+        const text = this.getText().trim();
+        if (!text)
+            return 0;
+        const words = text.split(/\s+/).filter((word) => word.length > 0);
+        return words.length;
+    }
+    getLength(includeSpaces = true) {
+        const text = this.getText();
+        if (includeSpaces) {
+            return text.length;
+        }
+        else {
+            return text.replace(/\s/g, '').length;
+        }
+    }
+    clone() {
+        const clonedFormatting = deepClone(this.formatting);
+        const clonedParagraph = new Paragraph(clonedFormatting);
+        for (const item of this.content) {
+            if (item instanceof Run) {
+                const runFormatting = item.getFormatting();
+                const clonedRun = new Run(item.getText(), deepClone(runFormatting));
+                clonedParagraph.addRun(clonedRun);
+            }
+            else {
+                clonedParagraph.content.push(item);
+            }
+        }
+        clonedParagraph.bookmarksStart = [...this.bookmarksStart];
+        clonedParagraph.bookmarksEnd = [...this.bookmarksEnd];
+        clonedParagraph.commentsStart = [...this.commentsStart];
+        clonedParagraph.commentsEnd = [...this.commentsEnd];
+        return clonedParagraph;
+    }
+    toJSON() {
+        const runs = this.getRuns().map((run) => ({
+            text: run.getText(),
+            formatting: run.getFormatting(),
+        }));
+        const result = {
+            text: this.getText(),
+            runs,
+        };
+        if (this.formatting.style)
+            result.style = this.formatting.style;
+        if (this.formatting.alignment)
+            result.alignment = this.formatting.alignment;
+        if (this.formatting.numbering)
+            result.numbering = { ...this.formatting.numbering };
+        if (this.formatting.indentation)
+            result.indentation = { ...this.formatting.indentation };
+        if (this.formatting.spacing) {
+            result.spacing = {
+                before: this.formatting.spacing.before,
+                after: this.formatting.spacing.after,
+                line: this.formatting.spacing.line,
+                lineRule: this.formatting.spacing.lineRule,
+            };
+        }
+        return result;
+    }
+    static fromJSON(data) {
+        const para = new Paragraph();
+        if (data.runs && data.runs.length > 0) {
+            for (const runData of data.runs) {
+                para.addText(runData.text, runData.formatting);
+            }
+        }
+        else if (data.text) {
+            para.addText(data.text);
+        }
+        if (data.style)
+            para.setStyle(data.style);
+        if (data.alignment)
+            para.setAlignment(data.alignment);
+        if (data.numbering)
+            para.setNumbering(data.numbering.numId, data.numbering.level);
+        if (data.indentation) {
+            if (data.indentation.left !== undefined)
+                para.setLeftIndent(data.indentation.left);
+            if (data.indentation.right !== undefined)
+                para.setRightIndent(data.indentation.right);
+            if (data.indentation.firstLine !== undefined)
+                para.setFirstLineIndent(data.indentation.firstLine);
+            if (data.indentation.hanging !== undefined)
+                para.setHangingIndent(data.indentation.hanging);
+        }
+        if (data.spacing) {
+            if (data.spacing.before !== undefined)
+                para.setSpaceBefore(data.spacing.before);
+            if (data.spacing.after !== undefined)
+                para.setSpaceAfter(data.spacing.after);
+            if (data.spacing.line !== undefined) {
+                para.setLineSpacing(data.spacing.line, data.spacing.lineRule ?? 'auto');
+            }
+        }
+        return para;
+    }
+    splitAt(offset) {
+        const tailPara = new Paragraph(deepClone(this.formatting));
+        const totalLength = this.getText().length;
+        if (offset >= totalLength) {
+            return tailPara;
+        }
+        if (offset <= 0) {
+            tailPara.content = this.content;
+            this.content = [];
+            return tailPara;
+        }
+        let charPos = 0;
+        let splitContentIndex = -1;
+        for (let i = 0; i < this.content.length; i++) {
+            const item = this.content[i];
+            if (item instanceof Run) {
+                const runLen = item.getText().length;
+                const runEnd = charPos + runLen;
+                if (runEnd <= offset) {
+                    charPos = runEnd;
+                    continue;
+                }
+                if (charPos >= offset) {
+                    splitContentIndex = i;
+                    break;
+                }
+                const localOffset = offset - charPos;
+                const tailRun = item.splitAt(localOffset);
+                this.content.splice(i + 1, 0, tailRun);
+                splitContentIndex = i + 1;
+                break;
+            }
+            else {
+                if (charPos >= offset) {
+                    splitContentIndex = i;
+                    break;
+                }
+            }
+        }
+        if (splitContentIndex === -1) {
+            return tailPara;
+        }
+        tailPara.content = this.content.splice(splitContentIndex);
+        return tailPara;
+    }
+    setBorder(borders) {
+        if (!this.formatting) {
+            this.formatting = {};
+        }
+        this.formatting.borders = borders;
+        return this;
+    }
+    setShading(shading) {
+        if (!this.formatting) {
+            this.formatting = {};
+        }
+        const previousValue = this.formatting.shading;
+        this.formatting.shading = shading;
+        if (this.trackingContext?.isEnabled() && previousValue !== shading) {
+            this.trackingContext.trackParagraphPropertyChange(this, 'shading', previousValue, shading);
+        }
+        return this;
+    }
+    setTabs(tabs) {
+        if (!this.formatting) {
+            this.formatting = {};
+        }
+        this.formatting.tabs = tabs;
+        return this;
+    }
+    insertRunAt(index, run) {
+        if (index < 0)
+            index = 0;
+        if (index > this.content.length)
+            index = this.content.length;
+        this.content.splice(index, 0, run);
+        return this;
+    }
+    removeRunAt(index) {
+        if (index >= 0 && index < this.content.length) {
+            const item = this.content[index];
+            if (item instanceof Run) {
+                this.content.splice(index, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    replaceRunAt(index, run) {
+        if (index >= 0 && index < this.content.length) {
+            const item = this.content[index];
+            if (item instanceof Run) {
+                this.content[index] = run;
+                return true;
+            }
+        }
+        return false;
+    }
+    findText(text, options) {
+        const indices = [];
+        const caseSensitive = options?.caseSensitive || false;
+        const wholeWord = options?.wholeWord || false;
+        const searchText = caseSensitive ? text : text.toLowerCase();
+        for (let i = 0; i < this.content.length; i++) {
+            const item = this.content[i];
+            if (item instanceof Run) {
+                const runText = caseSensitive ? item.getText() : item.getText().toLowerCase();
+                if (wholeWord) {
+                    const wordPattern = new RegExp(`\\b${searchText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`);
+                    if (wordPattern.test(runText)) {
+                        indices.push(i);
+                    }
+                }
+                else {
+                    if (runText.includes(searchText)) {
+                        indices.push(i);
+                    }
+                }
+            }
+        }
+        return indices;
+    }
+    replaceText(find, replace, options) {
+        let replacementCount = 0;
+        const caseSensitive = options?.caseSensitive || false;
+        const wholeWord = options?.wholeWord || false;
+        for (const item of this.content) {
+            if (item instanceof Run) {
+                const originalText = item.getText();
+                let newText = originalText;
+                if (wholeWord) {
+                    const wordPattern = new RegExp(`\\b${find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, caseSensitive ? 'g' : 'gi');
+                    const matches = originalText.match(wordPattern);
+                    if (matches) {
+                        replacementCount += matches.length;
+                        newText = originalText.replace(wordPattern, replace);
+                    }
+                }
+                else {
+                    const searchPattern = new RegExp(find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), caseSensitive ? 'g' : 'gi');
+                    const matches = originalText.match(searchPattern);
+                    if (matches) {
+                        replacementCount += matches.length;
+                        newText = originalText.replace(searchPattern, replace);
+                    }
+                }
+                if (newText !== originalText) {
+                    item.setText(newText);
+                }
+            }
+        }
+        return replacementCount;
+    }
+    replaceAll(find, replace) {
+        return this.replaceTextCrossRun(find, replace);
+    }
+    findTextCrossRun(find, options) {
+        const caseSensitive = options?.caseSensitive ?? false;
+        let fullText = '';
+        for (const item of this.content) {
+            if (item instanceof Run) {
+                fullText += item.getText();
+            }
+        }
+        if (fullText.length === 0)
+            return [];
+        const escaped = find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(escaped, caseSensitive ? 'g' : 'gi');
+        const results = [];
+        let m;
+        while ((m = regex.exec(fullText)) !== null) {
+            results.push({ offset: m.index, text: m[0] });
+        }
+        return results;
+    }
+    replaceTextCrossRun(find, replace, options) {
+        const caseSensitive = options?.caseSensitive ?? false;
+        const runMap = [];
+        let charPos = 0;
+        for (let i = 0; i < this.content.length; i++) {
+            const item = this.content[i];
+            if (item instanceof Run) {
+                const len = item.getText().length;
+                if (len > 0) {
+                    runMap.push({ run: item, contentIndex: i, start: charPos, end: charPos + len });
+                }
+                charPos += len;
+            }
+        }
+        if (runMap.length === 0)
+            return 0;
+        const fullText = runMap.map((r) => r.run.getText()).join('');
+        const escaped = find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(escaped, caseSensitive ? 'g' : 'gi');
+        const matches = [];
+        let m;
+        while ((m = regex.exec(fullText)) !== null) {
+            matches.push({ start: m.index, end: m.index + m[0].length });
+        }
+        if (matches.length === 0)
+            return 0;
+        for (let mi = matches.length - 1; mi >= 0; mi--) {
+            const match = matches[mi];
+            const affectedRuns = runMap.filter((r) => r.end > match.start && r.start < match.end);
+            if (affectedRuns.length === 0)
+                continue;
+            const firstAffected = affectedRuns[0];
+            const lastAffected = affectedRuns[affectedRuns.length - 1];
+            const keepBefore = match.start > firstAffected.start
+                ? firstAffected.run.getText().slice(0, match.start - firstAffected.start)
+                : '';
+            const keepAfter = match.end < lastAffected.end
+                ? lastAffected.run.getText().slice(match.end - lastAffected.start)
+                : '';
+            firstAffected.run.setText(keepBefore + replace + keepAfter);
+            for (let r = affectedRuns.length - 1; r >= 1; r--) {
+                const runEntry = affectedRuns[r];
+                const idx = this.content.indexOf(runEntry.run);
+                if (idx !== -1) {
+                    this.content.splice(idx, 1);
+                }
+            }
+        }
+        return matches.length;
+    }
+    deleteRange(start, end) {
+        if (start >= end)
+            return this;
+        const runMap = [];
+        let charPos = 0;
+        for (let i = 0; i < this.content.length; i++) {
+            const item = this.content[i];
+            if (item instanceof Run) {
+                const len = item.getText().length;
+                if (len > 0) {
+                    runMap.push({ index: i, start: charPos, end: charPos + len });
+                }
+                charPos += len;
+            }
+        }
+        for (let m = runMap.length - 1; m >= 0; m--) {
+            const entry = runMap[m];
+            const run = this.content[entry.index];
+            if (entry.end <= start || entry.start >= end)
+                continue;
+            const runStart = entry.start;
+            const runEnd = entry.end;
+            const delStart = Math.max(0, start - runStart);
+            const delEnd = Math.min(runEnd - runStart, end - runStart);
+            const runLen = runEnd - runStart;
+            if (delStart === 0 && delEnd === runLen) {
+                this.content.splice(entry.index, 1);
+            }
+            else {
+                const textBefore = run.getText().slice(0, delStart);
+                const textAfter = run.getText().slice(delEnd);
+                run.setText(textBefore + textAfter);
+            }
+        }
+        return this;
+    }
+    truncate(maxLength, suffix = '...') {
+        const text = this.getText();
+        if (text.length <= maxLength)
+            return this;
+        const cutoff = Math.max(0, maxLength - suffix.length);
+        this.deleteRange(cutoff, text.length);
+        if (suffix) {
+            this.addText(suffix);
+        }
+        return this;
+    }
+    wrap(prefix, suffix, formatting) {
+        if (prefix) {
+            const prefixRun = new Run(prefix, formatting);
+            this.content.unshift(prefixRun);
+        }
+        if (suffix) {
+            const suffixRun = new Run(suffix, formatting);
+            this.content.push(suffixRun);
+        }
+        return this;
+    }
+    getRunAtOffset(offset) {
+        if (offset < 0)
+            return undefined;
+        let charPos = 0;
+        for (const item of this.content) {
+            if (!(item instanceof Run))
+                continue;
+            const len = item.getText().length;
+            if (charPos + len > offset) {
+                return { run: item, localOffset: offset - charPos };
+            }
+            charPos += len;
+        }
+        return undefined;
+    }
+    getFormattingAtOffset(offset) {
+        const result = this.getRunAtOffset(offset);
+        return result ? result.run.getFormatting() : undefined;
+    }
+    applyFormattingToRange(start, end, formatting) {
+        if (start >= end)
+            return this;
+        const contentMap = [];
+        let charPos = 0;
+        for (let i = 0; i < this.content.length; i++) {
+            const item = this.content[i];
+            let len = 0;
+            if (item instanceof Run) {
+                len = item.getText().length;
+            }
+            if (len > 0) {
+                contentMap.push({ index: i, start: charPos, end: charPos + len });
+            }
+            charPos += len;
+        }
+        for (let m = contentMap.length - 1; m >= 0; m--) {
+            const entry = contentMap[m];
+            const run = this.content[entry.index];
+            if (entry.end <= start || entry.start >= end)
+                continue;
+            const runStart = entry.start;
+            const runEnd = entry.end;
+            const splitStart = Math.max(0, start - runStart);
+            const splitEnd = Math.min(runEnd - runStart, end - runStart);
+            const runLen = runEnd - runStart;
+            if (splitStart === 0 && splitEnd === runLen) {
+                this.applyFormattingToRun(run, formatting);
+            }
+            else if (splitStart === 0) {
+                const tail = run.splitAt(splitEnd);
+                this.applyFormattingToRun(run, formatting);
+                this.content.splice(entry.index + 1, 0, tail);
+            }
+            else if (splitEnd === runLen) {
+                const tail = run.splitAt(splitStart);
+                this.applyFormattingToRun(tail, formatting);
+                this.content.splice(entry.index + 1, 0, tail);
+            }
+            else {
+                const mid = run.splitAt(splitStart);
+                const tail = mid.splitAt(splitEnd - splitStart);
+                this.applyFormattingToRun(mid, formatting);
+                this.content.splice(entry.index + 1, 0, mid, tail);
+            }
+        }
+        return this;
+    }
+    applyFormattingToRun(run, formatting) {
+        if (formatting.bold !== undefined)
+            run.setBold(formatting.bold);
+        if (formatting.italic !== undefined)
+            run.setItalic(formatting.italic);
+        if (formatting.underline !== undefined)
+            run.setUnderline(formatting.underline);
+        if (formatting.strike !== undefined)
+            run.setStrike(formatting.strike);
+        if (formatting.subscript !== undefined)
+            run.setSubscript(formatting.subscript);
+        if (formatting.superscript !== undefined)
+            run.setSuperscript(formatting.superscript);
+        if (formatting.smallCaps !== undefined)
+            run.setSmallCaps(formatting.smallCaps);
+        if (formatting.allCaps !== undefined)
+            run.setAllCaps(formatting.allCaps);
+        if (formatting.font !== undefined)
+            run.setFont(formatting.font);
+        if (formatting.size !== undefined)
+            run.setSize(formatting.size);
+        if (formatting.color !== undefined)
+            run.setColor(formatting.color);
+        if (formatting.highlight !== undefined)
+            run.setHighlight(formatting.highlight);
+        if (formatting.characterSpacing !== undefined)
+            run.setCharacterSpacing(formatting.characterSpacing);
+        if (formatting.vanish !== undefined)
+            run.setVanish(formatting.vanish);
+    }
+    consolidateRuns() {
+        if (this.content.length < 2)
+            return 0;
+        const consolidated = [];
+        let eliminated = 0;
+        for (const item of this.content) {
+            if (!(item instanceof Run)) {
+                consolidated.push(item);
+                continue;
+            }
+            const prev = consolidated.length > 0 ? consolidated[consolidated.length - 1] : undefined;
+            if (prev instanceof Run &&
+                isEqualFormatting(prev.getFormatting(), item.getFormatting())) {
+                const mergedContent = [...prev.getContent(), ...item.getContent()];
+                const mergedRun = Run.createFromContent(mergedContent, deepClone(prev.getFormatting()));
+                consolidated[consolidated.length - 1] = mergedRun;
+                eliminated++;
+            }
+            else {
+                consolidated.push(item);
+            }
+        }
+        if (eliminated > 0) {
+            this.content = consolidated;
+        }
+        return eliminated;
+    }
+    mergeWith(otherPara) {
+        for (const item of otherPara.content) {
+            if (item instanceof Run) {
+                this.content.push(item.clone());
+            }
+            else {
+                this.content.push(item);
+            }
+        }
+        this.bookmarksStart.push(...otherPara.bookmarksStart);
+        this.bookmarksEnd.push(...otherPara.bookmarksEnd);
+        this.commentsStart.push(...otherPara.commentsStart);
+        this.commentsEnd.push(...otherPara.commentsEnd);
+        return this;
+    }
+    clearDirectRunFormatting(properties) {
+        const runs = this.getRuns();
+        for (const run of runs) {
+            const formatting = run.getFormatting();
+            if (properties && properties.length > 0) {
+                const newFormatting = { ...formatting };
+                for (const prop of properties) {
+                    if (prop in newFormatting) {
+                        delete newFormatting[prop];
+                    }
+                }
+                const text = run.getText();
+                const newRun = new Run(text, newFormatting);
+                const index = this.content.indexOf(run);
+                if (index !== -1) {
+                    this.content[index] = newRun;
+                }
+            }
+            else {
+                const text = run.getText();
+                const newRun = new Run(text, {});
+                const index = this.content.indexOf(run);
+                if (index !== -1) {
+                    this.content[index] = newRun;
+                }
+            }
+        }
+        return this;
+    }
+    applyStyleAndClearFormatting(styleId, clearProperties) {
+        this.setStyle(styleId);
+        if (clearProperties !== undefined) {
+            this.clearDirectRunFormatting(clearProperties.length === 0 ? undefined : clearProperties);
+        }
+        return this;
+    }
+    clearDirectFormattingConflicts(styleDefinition) {
+        const styleProperties = styleDefinition.getProperties();
+        const styleParagraphFormatting = styleProperties.paragraphFormatting || {};
+        const styleRunFormatting = styleProperties.runFormatting || {};
+        const conflictingParaProps = [];
+        for (const key in this.formatting) {
+            const propKey = key;
+            if (propKey === 'style') {
+                continue;
+            }
+            if (styleParagraphFormatting[propKey] === undefined) {
+                continue;
+            }
+            if (propKey === 'indentation') {
+                const paraIndent = this.formatting.indentation;
+                const styleIndent = styleParagraphFormatting.indentation;
+                if (paraIndent?.left === 0 && styleIndent?.left && styleIndent.left > 0) {
+                    continue;
+                }
+                conflictingParaProps.push(propKey);
+                continue;
+            }
+            if (propKey === 'spacing' ||
+                propKey === 'borders' ||
+                propKey === 'shading' ||
+                propKey === 'numbering') {
+                const paraValue = this.formatting[propKey];
+                const styleValue = styleParagraphFormatting[propKey];
+                if (!deepEqual(paraValue, styleValue)) {
+                    conflictingParaProps.push(propKey);
+                }
+            }
+            else {
+                if (this.formatting[propKey] !== styleParagraphFormatting[propKey]) {
+                    conflictingParaProps.push(propKey);
+                }
+            }
+        }
+        for (const prop of conflictingParaProps) {
+            delete this.formatting[prop];
+        }
+        for (const item of this.content) {
+            if (item instanceof Run) {
+                item.clearFormattingConflicts(styleRunFormatting);
+            }
+        }
+        return this;
+    }
+    clearDirectFormatting() {
+        const style = this.formatting.style;
+        const numbering = this.formatting.numbering;
+        this.formatting = {};
+        if (style)
+            this.formatting.style = style;
+        if (numbering)
+            this.formatting.numbering = numbering;
+        for (const item of this.content) {
+            if (item instanceof Run) {
+                item.clearFormatting();
+            }
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=Paragraph.js.map