@ansonlai/docx-redline-js 0.8.3 → 0.9.0

package/engine/reconstruction-mode.js

@@ -1,183 +1,183 @@
-/**
- * Reconstruction reconciliation mode orchestration.
- */
-
-import { computeWordDiffs } from '../pipeline/diff-engine.js';
-import { buildReconstructionMapping, findReconstructionParagraphRange } from './reconstruction-mapper.js';
-import { applyReconstructionDiffs } from './reconstruction-writer.js';
-import { withOoxmlSourceType } from '../core/word-xml.js';
-
-/**
- * Applies reconstruction mode reconciliation.
- *
- * @param {Document} xmlDoc - XML document
- * @param {string} originalText - Original text (kept for signature compatibility)
- * @param {string} modifiedText - Modified text
- * @param {XMLSerializer} serializer - Serializer instance
- * @param {string} author - Author name
- * @param {Array} formatHints - Format hints
- * @param {boolean} [generateRedlines=true] - Track change toggle
- * @param {{ diffTimeoutSeconds?: number }} [diffOptions={}] - Diff configuration
- * @returns {{ oxml: string, hasChanges: boolean }}
- */
-export function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, diffOptions = {}, options = {}) {
-    const selectedParagraphs = findReconstructionParagraphRange(xmlDoc, originalText);
-    if (selectedParagraphs === null) {
-        return withOoxmlSourceType({
-            oxml: serializer.serializeToString(xmlDoc),
-            hasChanges: false,
-            status: 'error',
-            error: {
-                code: 'PARTIAL_TARGET',
-                message: 'Original text did not identify a complete contiguous paragraph range for reconstruction.'
-            }
-        });
-    }
-
-    const mapping = buildReconstructionMapping(xmlDoc, modifiedText, selectedParagraphs);
-    if (mapping.paragraphs.length === 0) {
-        return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
-    }
-
-    const wordDiffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, {
-        ...diffOptions,
-        atomicChars: new Set(mapping.referenceMap.keys())
-    });
-    const diffs = keepUnchangedTextOutsideWrappers(anchorSharedReferences(wordDiffs, mapping.referenceMap), mapping);
-
-    return withOoxmlSourceType(applyReconstructionDiffs(
-        xmlDoc,
-        diffs,
-        mapping,
-        serializer,
-        author,
-        formatHints,
-        generateRedlines,
-        options
-    ));
-}
-
-/** Splits diffs into runs of equal parts and change groups (deleted + inserted text). */
-function forEachChangeGroup(diffs, onEqual, onGroup) {
-    let index = 0;
-    while (index < diffs.length) {
-        if (diffs[index][0] === 0) {
-            onEqual(diffs[index]);
-            index++;
-            continue;
-        }
-        const group = [];
-        while (index < diffs.length && diffs[index][0] !== 0) group.push(diffs[index++]);
-        onGroup(
-            group,
-            group.filter(([op]) => op === -1).map(([, text]) => text).join(''),
-            group.filter(([op]) => op === 1).map(([, text]) => text).join('')
-        );
-    }
-}
-
-function pushChange(result, deleted, inserted) {
-    if (deleted === inserted) {
-        if (deleted) result.push([0, deleted]);
-        return;
-    }
-    if (deleted) result.push([-1, deleted]);
-    if (inserted) result.push([1, inserted]);
-}
-
-/**
- * The writer keeps a reference placeholder (manual break, note reference) that
- * appears in both the deleted and inserted text of one change group, but only
- * emits it with the insertion, after all deleted text. Semantic cleanup can
- * merge edits on both sides of a break into such a group, so Reject All would
- * move deleted text across the break. Split the group at shared references so
- * each one stays an unchanged anchor between its own before/after edits.
- */
-function anchorSharedReferences(diffs, referenceMap) {
-    if (referenceMap.size === 0) return diffs;
-    const result = [];
-    forEachChangeGroup(diffs, part => result.push(part), (group, deleted, inserted) => {
-        const deletedRefs = [...deleted].filter(char => referenceMap.has(char) && inserted.includes(char));
-        const insertedRefs = [...inserted].filter(char => deletedRefs.includes(char));
-        if (deletedRefs.length === 0 || deletedRefs.join('') !== insertedRefs.join('')) {
-            result.push(...group);
-            return;
-        }
-        let deletedStart = 0;
-        let insertedStart = 0;
-        for (const ref of deletedRefs) {
-            const deletedAt = deleted.indexOf(ref, deletedStart);
-            const insertedAt = inserted.indexOf(ref, insertedStart);
-            pushChange(result, deleted.slice(deletedStart, deletedAt), inserted.slice(insertedStart, insertedAt));
-            result.push([0, ref]);
-            deletedStart = deletedAt + 1;
-            insertedStart = insertedAt + 1;
-        }
-        pushChange(result, deleted.slice(deletedStart), inserted.slice(insertedStart));
-    });
-    return result;
-}
-
-function commonPrefixLength(left, right) {
-    const limit = Math.min(left.length, right.length);
-    let length = 0;
-    while (length < limit && left[length] === right[length]) length++;
-    return length;
-}
-
-function commonSuffixLength(left, right, limit) {
-    let length = 0;
-    while (length < limit && left[left.length - 1 - length] === right[right.length - 1 - length]) length++;
-    return length;
-}
-
-/**
- * Word tokens can span a hyperlink boundary (`example.org` + plain `.`), so a
- * replaced token would delete and reinsert unchanged text across it and move
- * that text into or out of the link. Where the replacement's shared prefix or
- * suffix reaches a wrapper boundary in the original, keep that part unchanged.
- */
-function keepUnchangedTextOutsideWrappers(diffs, mapping) {
-    const wrapperAt = index => mapping.getRunProperties(index).wrapper || null;
-    const result = [];
-    let originalOffset = 0;
-
-    forEachChangeGroup(diffs, part => {
-        result.push(part);
-        originalOffset += part[1].length;
-    }, (group, deleted, inserted) => {
-        const start = originalOffset;
-        const end = start + deleted.length;
-        originalOffset = end;
-        // Only a boundary strictly inside the deleted text splits it; an edge
-        // of the whole change (`link` -> `hyperlink` inside a link) does not.
-        const isWrapperBoundary = index => index > start && index < end
-            && wrapperAt(index - 1) !== wrapperAt(index);
-
-        let prefix = 0;
-        let suffix = 0;
-        if (deleted && inserted) {
-            const sharedSuffix = commonSuffixLength(deleted, inserted, Math.min(deleted.length, inserted.length));
-            for (let length = sharedSuffix; length > 0; length--) {
-                if (isWrapperBoundary(end - length)) { suffix = length; break; }
-            }
-            const sharedPrefix = Math.min(
-                commonPrefixLength(deleted, inserted),
-                Math.min(deleted.length, inserted.length) - suffix
-            );
-            for (let length = sharedPrefix; length > 0; length--) {
-                if (isWrapperBoundary(start + length)) { prefix = length; break; }
-            }
-        }
-        if (prefix === 0 && suffix === 0) {
-            result.push(...group);
-            return;
-        }
-
-        if (prefix > 0) result.push([0, deleted.slice(0, prefix)]);
-        pushChange(result, deleted.slice(prefix, deleted.length - suffix), inserted.slice(prefix, inserted.length - suffix));
-        if (suffix > 0) result.push([0, deleted.slice(deleted.length - suffix)]);
-    });
-
-    return result;
-}
+/**
+ * Reconstruction reconciliation mode orchestration.
+ */
+
+import { computeWordDiffs } from '../pipeline/diff-engine.js';
+import { buildReconstructionMapping, findReconstructionParagraphRange } from './reconstruction-mapper.js';
+import { applyReconstructionDiffs } from './reconstruction-writer.js';
+import { withOoxmlSourceType } from '../core/word-xml.js';
+
+/**
+ * Applies reconstruction mode reconciliation.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {string} originalText - Original text (kept for signature compatibility)
+ * @param {string} modifiedText - Modified text
+ * @param {XMLSerializer} serializer - Serializer instance
+ * @param {string} author - Author name
+ * @param {Array} formatHints - Format hints
+ * @param {boolean} [generateRedlines=true] - Track change toggle
+ * @param {{ diffTimeoutSeconds?: number }} [diffOptions={}] - Diff configuration
+ * @returns {{ oxml: string, hasChanges: boolean }}
+ */
+export function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, diffOptions = {}, options = {}) {
+    const selectedParagraphs = findReconstructionParagraphRange(xmlDoc, originalText);
+    if (selectedParagraphs === null) {
+        return withOoxmlSourceType({
+            oxml: serializer.serializeToString(xmlDoc),
+            hasChanges: false,
+            status: 'error',
+            error: {
+                code: 'PARTIAL_TARGET',
+                message: 'Original text did not identify a complete contiguous paragraph range for reconstruction.'
+            }
+        });
+    }
+
+    const mapping = buildReconstructionMapping(xmlDoc, modifiedText, selectedParagraphs);
+    if (mapping.paragraphs.length === 0) {
+        return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
+    }
+
+    const wordDiffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, {
+        ...diffOptions,
+        atomicChars: new Set(mapping.referenceMap.keys())
+    });
+    const diffs = keepUnchangedTextOutsideWrappers(anchorSharedReferences(wordDiffs, mapping.referenceMap), mapping);
+
+    return withOoxmlSourceType(applyReconstructionDiffs(
+        xmlDoc,
+        diffs,
+        mapping,
+        serializer,
+        author,
+        formatHints,
+        generateRedlines,
+        options
+    ));
+}
+
+/** Splits diffs into runs of equal parts and change groups (deleted + inserted text). */
+function forEachChangeGroup(diffs, onEqual, onGroup) {
+    let index = 0;
+    while (index < diffs.length) {
+        if (diffs[index][0] === 0) {
+            onEqual(diffs[index]);
+            index++;
+            continue;
+        }
+        const group = [];
+        while (index < diffs.length && diffs[index][0] !== 0) group.push(diffs[index++]);
+        onGroup(
+            group,
+            group.filter(([op]) => op === -1).map(([, text]) => text).join(''),
+            group.filter(([op]) => op === 1).map(([, text]) => text).join('')
+        );
+    }
+}
+
+function pushChange(result, deleted, inserted) {
+    if (deleted === inserted) {
+        if (deleted) result.push([0, deleted]);
+        return;
+    }
+    if (deleted) result.push([-1, deleted]);
+    if (inserted) result.push([1, inserted]);
+}
+
+/**
+ * The writer keeps a reference placeholder (manual break, note reference) that
+ * appears in both the deleted and inserted text of one change group, but only
+ * emits it with the insertion, after all deleted text. Semantic cleanup can
+ * merge edits on both sides of a break into such a group, so Reject All would
+ * move deleted text across the break. Split the group at shared references so
+ * each one stays an unchanged anchor between its own before/after edits.
+ */
+function anchorSharedReferences(diffs, referenceMap) {
+    if (referenceMap.size === 0) return diffs;
+    const result = [];
+    forEachChangeGroup(diffs, part => result.push(part), (group, deleted, inserted) => {
+        const deletedRefs = [...deleted].filter(char => referenceMap.has(char) && inserted.includes(char));
+        const insertedRefs = [...inserted].filter(char => deletedRefs.includes(char));
+        if (deletedRefs.length === 0 || deletedRefs.join('') !== insertedRefs.join('')) {
+            result.push(...group);
+            return;
+        }
+        let deletedStart = 0;
+        let insertedStart = 0;
+        for (const ref of deletedRefs) {
+            const deletedAt = deleted.indexOf(ref, deletedStart);
+            const insertedAt = inserted.indexOf(ref, insertedStart);
+            pushChange(result, deleted.slice(deletedStart, deletedAt), inserted.slice(insertedStart, insertedAt));
+            result.push([0, ref]);
+            deletedStart = deletedAt + 1;
+            insertedStart = insertedAt + 1;
+        }
+        pushChange(result, deleted.slice(deletedStart), inserted.slice(insertedStart));
+    });
+    return result;
+}
+
+function commonPrefixLength(left, right) {
+    const limit = Math.min(left.length, right.length);
+    let length = 0;
+    while (length < limit && left[length] === right[length]) length++;
+    return length;
+}
+
+function commonSuffixLength(left, right, limit) {
+    let length = 0;
+    while (length < limit && left[left.length - 1 - length] === right[right.length - 1 - length]) length++;
+    return length;
+}
+
+/**
+ * Word tokens can span a hyperlink boundary (`example.org` + plain `.`), so a
+ * replaced token would delete and reinsert unchanged text across it and move
+ * that text into or out of the link. Where the replacement's shared prefix or
+ * suffix reaches a wrapper boundary in the original, keep that part unchanged.
+ */
+function keepUnchangedTextOutsideWrappers(diffs, mapping) {
+    const wrapperAt = index => mapping.getRunProperties(index).wrapper || null;
+    const result = [];
+    let originalOffset = 0;
+
+    forEachChangeGroup(diffs, part => {
+        result.push(part);
+        originalOffset += part[1].length;
+    }, (group, deleted, inserted) => {
+        const start = originalOffset;
+        const end = start + deleted.length;
+        originalOffset = end;
+        // Only a boundary strictly inside the deleted text splits it; an edge
+        // of the whole change (`link` -> `hyperlink` inside a link) does not.
+        const isWrapperBoundary = index => index > start && index < end
+            && wrapperAt(index - 1) !== wrapperAt(index);
+
+        let prefix = 0;
+        let suffix = 0;
+        if (deleted && inserted) {
+            const sharedSuffix = commonSuffixLength(deleted, inserted, Math.min(deleted.length, inserted.length));
+            for (let length = sharedSuffix; length > 0; length--) {
+                if (isWrapperBoundary(end - length)) { suffix = length; break; }
+            }
+            const sharedPrefix = Math.min(
+                commonPrefixLength(deleted, inserted),
+                Math.min(deleted.length, inserted.length) - suffix
+            );
+            for (let length = sharedPrefix; length > 0; length--) {
+                if (isWrapperBoundary(start + length)) { prefix = length; break; }
+            }
+        }
+        if (prefix === 0 && suffix === 0) {
+            result.push(...group);
+            return;
+        }
+
+        if (prefix > 0) result.push([0, deleted.slice(0, prefix)]);
+        pushChange(result, deleted.slice(prefix, deleted.length - suffix), inserted.slice(prefix, inserted.length - suffix));
+        if (suffix > 0) result.push([0, deleted.slice(deleted.length - suffix)]);
+    });
+
+    return result;
+}

package/engine/reconstruction-writer.js

@@ -7,14 +7,42 @@
 import { getApplicableFormatHints } from '../pipeline/markdown-processor.js';
 import {
     createTrackChange,
-    createFormattedRuns,
-    markParagraphMarkDeleted,
-    markParagraphMarkInserted
+    createFormattedRuns
 } from './run-builders.js';
+import { markParagraphDeleted, markParagraphInserted } from './paragraph-mark-revisions.js';
 import { getFirstElementByTagNSOrTag } from '../core/xml-query.js';
 import { NS_W, createReplacementRevisionEvent, createRevisionMetadata } from '../core/types.js';
 import { createWordElement, isWordElement } from '../core/word-xml.js';
 
+const NS_W14 = 'http://schemas.microsoft.com/office/word/2010/wordml';
+const IDENTITY_ATTRIBUTES = ['paraId', 'textId'];
+
+function hasMarkRevision(paragraph, kind) {
+    const pPr = Array.from(paragraph.childNodes).find(node => isWordElement(node, 'pPr'));
+    const rPr = pPr && Array.from(pPr.childNodes).find(node => isWordElement(node, 'rPr'));
+    return !!rPr && Array.from(rPr.childNodes).some(node => isWordElement(node, kind));
+}
+
+/**
+ * Carries the source paragraph identity (`w14:paraId`, `w14:textId`) onto the rebuilt paragraph that survives
+ * for it. Several rebuilt paragraphs can derive from one source paragraph (an inserted split), so the identity
+ * goes to exactly one: the paragraph whose mark is not tracked, else one whose mark is not tracked-deleted,
+ * else the first. Ids therefore stay unique; inserted paragraphs carry none, as on
+ * every other insertion path (Word assigns them on open).
+ */
+function carrySourceIdentity(claims) {
+    claims.forEach((rebuilt, source) => {
+        const survivor = rebuilt.find(p => !hasMarkRevision(p, 'ins') && !hasMarkRevision(p, 'del'))
+            || rebuilt.find(p => !hasMarkRevision(p, 'del'))
+            || rebuilt[0];
+        if (!survivor) return;
+        IDENTITY_ATTRIBUTES.forEach(name => {
+            const value = source.getAttributeNS?.(NS_W14, name) || source.getAttribute?.(`w14:${name}`);
+            if (value) survivor.setAttributeNS(NS_W14, `w14:${name}`, value);
+        });
+    });
+}
+
 /**
  * Applies diffs to reconstruction context and writes updated XML.
  *
@@ -40,8 +68,13 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
         isParagraphStart
     } = context;
 
-    const createNewParagraph = (pPr) => {
+    const identityClaims = new Map();
+    const createNewParagraph = (pPr, sourceParagraph = null) => {
         const newParagraph = createWordElement(xmlDoc, 'w:p');
+        if (sourceParagraph) {
+            if (!identityClaims.has(sourceParagraph)) identityClaims.set(sourceParagraph, []);
+            identityClaims.get(sourceParagraph).push(newParagraph);
+        }
         if (pPr) {
             const clonedPPr = pPr.cloneNode(true);
             // Safeguard: Never place w:sectPr on both paragraphs during split
@@ -55,7 +88,7 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
     };
 
     const startInfo = getParagraphInfo(0);
-    let currentParagraph = createNewParagraph(startInfo.pPr);
+    let currentParagraph = createNewParagraph(startInfo.pPr, startInfo.paragraph);
     const initialFragment = containerFragments.get(startInfo.container);
     if (initialFragment) {
         initialFragment.appendChild(currentParagraph);
@@ -83,7 +116,7 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
                     if (diffs[k][0] === 0) break;
                 }
                 if (pairReplacements && generateRedlines && hasInsert) {
-                    pendingReplacementEvent = createReplacementRevisionEvent(author, xmlDoc);
+                    pendingReplacementEvent = createReplacementRevisionEvent(author, xmlDoc, { deferReceipt: true });
                 }
             }
             let offset = 0;
@@ -189,7 +222,7 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
                     const hasVisibleText = Array.from(node.getElementsByTagNameNS(NS_W, 't')).length > 0;
                     const hasDeletedText = Array.from(node.getElementsByTagNameNS(NS_W, 'delText')).length > 0;
                     if (paragraphs.length === 1 && !hasVisibleText && (hasDeletedText || context.originalFullText.trim() !== '')) {
-                        markParagraphMarkDeleted(xmlDoc, node, author);
+                        markParagraphDeleted(node, { author, revisionIdAllocator: xmlDoc });
                     }
                 }
             });
@@ -215,6 +248,8 @@ export function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, aut
         }
     });
 
+    carrySourceIdentity(identityClaims);
+
     const paragraphSet = new Set(paragraphs);
     const insertionAnchors = new Map();
     paragraphs.forEach(paragraph => {
@@ -327,11 +362,11 @@ function appendTextToCurrent(
 
         if (part === '\n') {
             const info = getParagraphInfo(localBaseIndex + 1);
-            const nextParagraph = createNewParagraph(info.pPr);
+            const nextParagraph = createNewParagraph(info.pPr, info.paragraph);
             if (generateRedlines && type === 'insert') {
-                markParagraphMarkInserted(xmlDoc, localParagraph, author);
+                markParagraphInserted(localParagraph, { author, revisionIdAllocator: xmlDoc });
             } else if (generateRedlines && type === 'delete') {
-                markParagraphMarkDeleted(xmlDoc, localParagraph, author);
+                markParagraphDeleted(localParagraph, { author, revisionIdAllocator: xmlDoc });
             }
 
             const fragment = containerFragments.get(info.container);
@@ -370,6 +405,26 @@ function appendTextToCurrent(
         }
 
         if (referenceMap.has(part)) {
+            if (type === 'delete' && generateRedlines) {
+                // A deleted manual break, tab or inline object must be a tracked deletion so Reject All
+                // restores it; silently dropping the node loses it from the rejected view.
+                const refNode = referenceMap.get(part);
+                if (refNode) {
+                    const run = createWordElement(xmlDoc, 'w:r');
+                    if (rPr) run.appendChild(rPr.cloneNode(true));
+                    run.appendChild(refNode.cloneNode(true));
+                    let metadata = null;
+                    if (replacementEvent) {
+                        const id = replacementEvent.usedDeletionId
+                            ? createRevisionMetadata(author, xmlDoc, 'del').id
+                            : replacementEvent.deletionId;
+                        if (!replacementEvent.usedDeletionId) replacementEvent.recordUsed?.('del');
+                        replacementEvent.usedDeletionId = true;
+                        metadata = { id, author: replacementEvent.author, date: replacementEvent.date };
+                    }
+                    localParagraph.appendChild(createTrackChange(xmlDoc, 'del', run, author, metadata));
+                }
+            }
             if (type !== 'delete') {
                 const refNode = referenceMap.get(part);
                 if (refNode) {
@@ -408,6 +463,7 @@ function appendTextToCurrent(
                     const id = replacementEvent.usedDeletionId
                         ? createRevisionMetadata(author, xmlDoc, 'del').id
                         : replacementEvent.deletionId;
+                    if (!replacementEvent.usedDeletionId) replacementEvent.recordUsed?.('del');
                     replacementEvent.usedDeletionId = true;
                     metadata = {
                         id,
@@ -428,6 +484,7 @@ function appendTextToCurrent(
                     const id = replacementEvent.usedInsertionId
                         ? createRevisionMetadata(author, xmlDoc, 'ins').id
                         : replacementEvent.insertionId;
+                    if (!replacementEvent.usedInsertionId) replacementEvent.recordUsed?.('ins');
                     replacementEvent.usedInsertionId = true;
                     metadata = {
                         id,

package/engine/rpr-helpers.js

@@ -6,6 +6,7 @@
  */
 
 import { createWordElement } from '../core/word-xml.js';
+import { getCurrentChild } from '../core/current-properties.js';
 
 /**
  * Canonical OOXML run-property schema ordering.
@@ -419,9 +420,34 @@ export function checkParagraphPropertiesChanged(pPr, properties) {
         if (currentVal !== properties.style) return true;
     }
 
+    if (properties.numbering !== undefined) {
+        const current = readDirectNumbering(pPr);
+        const desired = properties.numbering;
+        if (desired === null) return current != null;
+        if (!current) return true;
+        if (current.numId !== String(Number(desired.numId))) return true;
+        if (current.level !== (Number(desired.level) || 0)) return true;
+    }
+
     return false;
 }
 
+/**
+ * Reads the paragraph's own (direct, non-snapshot) numbering binding.
+ *
+ * @param {Element|null} pPr
+ * @returns {{ numId: string, level: number }|null}
+ */
+function readDirectNumbering(pPr) {
+    const numPr = getCurrentChild(pPr, 'numPr');
+    if (!numPr) return null;
+    const read = (name) => {
+        const el = getCurrentChild(numPr, name);
+        return el ? (el.getAttribute('w:val') ?? el.getAttribute('val')) : null;
+    };
+    return { numId: String(Number(read('numId'))), level: Number(read('ilvl')) || 0 };
+}
+
 /**
  * Applies explicit paragraph formatting to a pPr in schema order.
  *
@@ -492,4 +518,20 @@ export function applyParagraphPropertiesToPPr(xmlDoc, pPr, properties) {
             insertPPrChildInOrder(pPr, pStyle);
         }
     }
+
+    if (properties.numbering !== undefined) {
+        removeTags(['w:numPr']);
+        if (properties.numbering) {
+            // CT_PPr sequence: numPr follows widowControl and precedes suppressLineNumbers ... ind; inside
+            // CT_NumPr the order is ilvl, numId.
+            const numPr = createWordElement(xmlDoc, 'w:numPr');
+            const ilvl = createWordElement(xmlDoc, 'w:ilvl');
+            ilvl.setAttribute('w:val', String(Number(properties.numbering.level) || 0));
+            const numId = createWordElement(xmlDoc, 'w:numId');
+            numId.setAttribute('w:val', String(Number(properties.numbering.numId)));
+            numPr.appendChild(ilvl);
+            numPr.appendChild(numId);
+            insertPPrChildInOrder(pPr, numPr);
+        }
+    }
 }

package/engine/run-builders.js

@@ -33,79 +33,6 @@ export function createTrackChange(xmlDoc, type, run, author, revisionMetadata =
     return wrapper;
 }
 
-function getDirectWordChild(node, localName) {
-    return Array.from(node?.childNodes || []).find(child => child.nodeType === 1
-        && (child.localName === localName || child.nodeName === `w:${localName}`)) || null;
-}
-
-function ensureParagraphProperties(xmlDoc, paragraph) {
-    let pPr = getDirectWordChild(paragraph, 'pPr');
-    if (!pPr) {
-        pPr = createWordElement(xmlDoc, 'w:pPr');
-        paragraph.insertBefore(pPr, paragraph.firstChild || null);
-    } else if (paragraph.firstChild !== pPr) {
-        paragraph.insertBefore(pPr, paragraph.firstChild || null);
-    }
-    return pPr;
-}
-
-function ensureParagraphMarkRunProperties(xmlDoc, pPr) {
-    let rPr = getDirectWordChild(pPr, 'rPr');
-    if (!rPr) {
-        rPr = createWordElement(xmlDoc, 'w:rPr');
-        pPr.appendChild(rPr);
-    } else if (pPr.lastChild !== rPr) {
-        pPr.appendChild(rPr);
-    }
-    return rPr;
-}
-
-function markParagraphMark(xmlDoc, paragraph, author, type, revisionMetadata = null) {
-    const pPr = ensureParagraphProperties(xmlDoc, paragraph);
-    const rPr = ensureParagraphMarkRunProperties(xmlDoc, pPr);
-
-    for (const child of Array.from(rPr.childNodes || [])) {
-        if (child.nodeType !== 1) continue;
-        if (child.localName === 'ins' || child.localName === 'del' || child.nodeName === 'w:ins' || child.nodeName === 'w:del') {
-            rPr.removeChild(child);
-        }
-    }
-
-    const marker = createWordElement(xmlDoc, type === 'ins' ? 'w:ins' : 'w:del');
-    const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc, type === 'ins' ? 'ins' : 'del');
-    marker.setAttribute('w:id', String(metadata.id));
-    marker.setAttribute('w:author', metadata.author);
-    marker.setAttribute('w:date', metadata.date);
-    rPr.appendChild(marker);
-    return marker;
-}
-
-/**
- * Marks a paragraph mark as inserted.
- *
- * @param {Document} xmlDoc - XML document
- * @param {Element} paragraph - Paragraph to mark
- * @param {string} author - Change author
- * @param {Object|null} [revisionMetadata=null] - Optional explicit revision metadata
- * @returns {Element}
- */
-export function markParagraphMarkInserted(xmlDoc, paragraph, author, revisionMetadata = null) {
-    return markParagraphMark(xmlDoc, paragraph, author, 'ins', revisionMetadata);
-}
-
-/**
- * Marks a paragraph mark as deleted.
- *
- * @param {Document} xmlDoc - XML document
- * @param {Element} paragraph - Paragraph to mark
- * @param {string} author - Change author
- * @param {Object|null} [revisionMetadata=null] - Optional explicit revision metadata
- * @returns {Element}
- */
-export function markParagraphMarkDeleted(xmlDoc, paragraph, author, revisionMetadata = null) {
-    return markParagraphMark(xmlDoc, paragraph, author, 'del', revisionMetadata);
-}
-
 /**
  * Creates a text run with optional formatting.
  *