web-doc 0.7.0 → 0.9.0

package/dist/edit/docx/table-ops.js

@@ -2,6 +2,7 @@ import { patches } from "../ooxml/patch.js";
 import { W_NS } from "./ids.js";
 import { LINE_BREAK } from "./text.js";
 import { replacedParagraph } from "./text-ops.js";
+import { deletedParagraphXml, trackedRangeProblem, unsupportedTracked, } from "./tracked.js";
 import { namespacePatches, normalizeText, paragraphXml, runContentXml, runXml, textProblem, } from "./write.js";
 /*
  * Tables: a new `w:tbl` next to a paragraph or table of the body, with a
@@ -101,6 +102,10 @@ function commit(context, items, result) {
 }
 export const insertTableHandler = {
     async validate(operation, context, issue) {
+        if (context.tracked) {
+            unsupportedTracked(issue, "", "Inserting a table");
+            return;
+        }
         placement(operation, context, issue);
         const columns = operation.rows[0]?.length ?? 0;
         if (operation.rows.some((row) => row.length !== columns))
@@ -186,6 +191,11 @@ export const setTableCellHandler = {
             issue("/target", "invalid-target", "The cell holds no paragraph");
         else if (first.readOnlyReason)
             issue("/target", "invalid-target", `The cell's paragraph is read-only (${first.readOnlyReason})`);
+        else if (context.tracked)
+            for (const paragraph of cell.paragraphs)
+                if (paragraph.readOnlyReason ||
+                    trackedRangeProblem(paragraph, 0, paragraph.text.text.length, issue, "/target"))
+                    return;
     },
     async apply(operation, context) {
         const { model } = context;
@@ -198,10 +208,22 @@ export const setTableCellHandler = {
         const items = [...replaced.items];
         const removedIds = [...replaced.removedIds];
         const removedParagraphIds = [...replaced.removedParagraphIds];
+        const stamped = model.unauthoredSet.has(first.id)
+            ? [first.id]
+            : [];
         for (const paragraph of rest) {
-            items.push(patches.removeElement(part, paragraph.node));
-            removedIds.push(paragraph.elementId, ...paragraph.inlines.map((inline) => inline.elementId));
-            removedParagraphIds.push(paragraph.id);
+            if (context.tracked) {
+                if (model.unauthoredSet.has(paragraph.id))
+                    stamped.push(paragraph.id);
+                // The paragraph stays, marked deleted, until Word accepts.
+                items.push(patches.replaceElement(part, paragraph.node, deletedParagraphXml(context, paragraph)));
+                removedIds.push(...paragraph.inlines.map((inline) => inline.elementId));
+            }
+            else {
+                items.push(patches.removeElement(part, paragraph.node));
+                removedIds.push(paragraph.elementId, ...paragraph.inlines.map((inline) => inline.elementId));
+                removedParagraphIds.push(paragraph.id);
+            }
             for (const nested of part.findAll("p", paragraph.node)) {
                 const id = model.paragraphIds.get(nested);
                 if (id && nested !== paragraph.node)
@@ -212,7 +234,7 @@ export const setTableCellHandler = {
             createdIds: replaced.createdIds,
             ...(removedIds.length > 0 ? { removedIds } : {}),
             ...(removedParagraphIds.length > 0 ? { removedParagraphIds } : {}),
-            ...(model.unauthoredSet.has(first.id) ? { stamped: [first.id] } : {}),
+            ...(stamped.length > 0 ? { stamped } : {}),
             reflowFrom: record.id,
         });
     },

package/dist/edit/docx/text-ops.d.ts

@@ -1,7 +1,29 @@
 import { type XmlPatch } from "../ooxml/patch.js";
+import type { XmlElement, XmlPart } from "../ooxml/xml.js";
 import type { ParagraphRecord } from "./model.js";
 import type { DocxOperationContext, DocxOperationHandler } from "./operations.js";
+import type { RunItem } from "./text.js";
 import type { DocxReplaceTextOperation, DocxSetParagraphStyleOperation, DocxSetTextStyleOperation } from "./types.js";
+/** A direct child of a container, or the children a complex field spans. */
+export interface Unit {
+    readonly nodes: readonly XmlElement[];
+    readonly kind: "zero" | "run" | "wrapper" | "field";
+    /** Half-open text span; `start === end` for a unit without text. */
+    readonly start: number;
+    readonly end: number;
+    readonly items: readonly RunItem[];
+}
+/** The units of a container's children for the items it holds. */
+export declare function unitsOf(container: XmlElement, items: readonly RunItem[]): Unit[];
+export declare function rPrOf(part: XmlPart, item: RunItem | undefined): string;
+/**
+ * The content of a run's items in `[from, to]`: `w:t` text sliced, every
+ * other child (tab, break, picture, symbol, note reference) as its bytes
+ * when it lies inside. A zero-width item at `from` belongs to the slice
+ * only when `includeStart` says so, which is how a caret or a range edge
+ * hands such an item to exactly one side.
+ */
+export declare function contentOf(part: XmlPart, items: readonly RunItem[], from: number, to: number, includeStart: boolean): string;
 export declare const replaceTextHandler: DocxOperationHandler<DocxReplaceTextOperation>;
 /**
  * The patches that replace `[start, end)` of a paragraph's text with

package/dist/edit/docx/text-ops.js

@@ -1,5 +1,6 @@
 import { patches } from "../ooxml/patch.js";
 import { W_NS } from "./ids.js";
+import { insertedRunXml, markedParagraphProperties, revisionAttributes, trackedRangeProblem, trackedSplit, } from "./tracked.js";
 import { changedParagraphProperties, changedRunProperties, attributeProblem, colorProblem, namespacePatches, normalizeText, paragraphMarkProperties, paragraphPropertiesWithoutSection, paragraphXml, runContentXml, runXml, sliceOf, textProblem, } from "./write.js";
 /** The child of `container` an item sits under. */
 function topOf(node, container) {
@@ -9,7 +10,7 @@ function topOf(node, container) {
     return current;
 }
 /** The units of a container's children for the items it holds. */
-function unitsOf(container, items) {
+export function unitsOf(container, items) {
     const byTop = new Map();
     for (const item of items) {
         const top = topOf(item.run, container);
@@ -57,7 +58,7 @@ function unitsOf(container, items) {
     }
     return units;
 }
-function rPrOf(part, item) {
+export function rPrOf(part, item) {
     return item ? sliceOf(part, item.rPr) : "";
 }
 function startTagOf(part, node) {
@@ -73,7 +74,7 @@ function endTagOf(part, node) {
  * only when `includeStart` says so, which is how a caret or a range edge
  * hands such an item to exactly one side.
  */
-function contentOf(part, items, from, to, includeStart) {
+export function contentOf(part, items, from, to, includeStart) {
     let out = "";
     for (const item of items) {
         if (item.start === item.end) {
@@ -291,6 +292,10 @@ export const replaceTextHandler = {
         if (!target)
             return;
         const range = checkRange(target, operation.target, operation.range, issue, true);
+        if (range &&
+            context.tracked &&
+            trackedRangeProblem(target.record, range.start, range.end, issue, "/range"))
+            return;
         if (!range || !text.includes("\n"))
             return;
         // A paragraph cannot be split inside a hyperlink or content control.
@@ -317,19 +322,47 @@ export const replaceTextHandler = {
 export function replacedParagraph(context, record, start, end, text) {
     const part = context.model.document;
     const segments = text.split("\n");
-    const split = splitAt(part, record.node, record.text.items, start, end, (rPr) => runXml(rPr, runContentXml(segments[0])), paragraphMarkRPr(part, record));
-    const pPr = sliceOf(part, record.pPr);
     const single = segments.length === 1;
-    const first = paragraphXml(record.node, record.id, pPr, split.before + (single ? split.after : ""));
-    const items = [patches.replaceElement(part, record.node, first)];
+    const items = [];
     const createdIds = [];
     const copiedPPr = paragraphPropertiesWithoutSection(part, record.pPr);
-    segments.slice(1).forEach((segment, index) => {
-        const id = context.freshParagraphId();
-        createdIds.push(`p:${id}`);
-        const last = index === segments.length - 2;
-        items.push(patches.insertAfter(part, record.node, paragraphXml(record.node, id, copiedPPr, runXml(split.rPr, runContentXml(segment)) + (last ? split.after : ""))));
-    });
+    if (context.tracked) {
+        // The removed runs stay as a deletion, the new text goes in as an
+        // insertion; a paragraph split marks the new paragraph marks inserted
+        // and leaves the original mark on the last paragraph.
+        const split = trackedSplit(context, record, start, end, paragraphMarkRPr(part, record));
+        const inserted = (segment) => insertedRunXml(context, split.rPr, segment);
+        // The original mark (section properties included) ends the last
+        // paragraph; every mark before it is an insertion.
+        const originalPPr = sliceOf(part, record.pPr);
+        const firstPPr = single
+            ? originalPPr
+            : markedParagraphProperties(context, record.pPr, "ins");
+        items.push(patches.replaceElement(part, record.node, paragraphXml(record.node, record.id, firstPPr, split.before +
+            split.deleted +
+            inserted(segments[0]) +
+            (single ? split.after : ""))));
+        segments.slice(1).forEach((segment, index) => {
+            const id = context.freshParagraphId();
+            createdIds.push(`p:${id}`);
+            const last = index === segments.length - 2;
+            items.push(patches.insertAfter(part, record.node, paragraphXml(record.node, id, last
+                ? originalPPr
+                : markedParagraphProperties(context, record.pPr, "ins"), inserted(segment) + (last ? split.after : ""))));
+        });
+    }
+    else {
+        const split = splitAt(part, record.node, record.text.items, start, end, (rPr) => runXml(rPr, runContentXml(segments[0])), paragraphMarkRPr(part, record));
+        const pPr = sliceOf(part, record.pPr);
+        items.push(patches.replaceElement(part, record.node, paragraphXml(record.node, record.id, pPr, split.before + (single ? split.after : ""))));
+        segments.slice(1).forEach((segment, index) => {
+            const id = context.freshParagraphId();
+            createdIds.push(`p:${id}`);
+            const last = index === segments.length - 2;
+            items.push(patches.insertAfter(part, record.node, paragraphXml(record.node, id, copiedPPr, runXml(split.rPr, runContentXml(segment)) +
+                (last ? split.after : ""))));
+        });
+    }
     const dropped = droppedInlines(context.model, record, record.text.items, start, end);
     const removedIds = dropped.removedIds;
     // Inline objects that moved to a new paragraph change their id.
@@ -362,7 +395,7 @@ function restyledRun(part, run, rPr) {
 /** The container's content with the runs in `[start, end)` restyled. */
 function restyled(part, container, items, start, end, change, context) {
     let out = "";
-    const changed = (rPr) => changedRunProperties(part, rPr, change, context.model.styles);
+    const changed = (rPr) => changedRunProperties(part, rPr, change, context.model.styles, context.tracked ? revisionAttributes(context) : undefined);
     for (const unit of unitsOf(container, items)) {
         const raw = unit.nodes.map((node) => sliceOf(part, node)).join("");
         const overlaps = unit.start < end && start < unit.end
@@ -428,7 +461,7 @@ export const setTextStyleHandler = {
             return { createdIds: [], warnings: [] };
         const content = restyled(part, record.node, record.text.items, start, end, operation.style, context);
         const pPr = end >= record.text.text.length
-            ? paragraphMarkProperties(part, record.pPr, operation.style, context.model.styles)
+            ? paragraphMarkProperties(part, record.pPr, operation.style, context.model.styles, context.tracked ? revisionAttributes(context) : undefined)
             : sliceOf(part, record.pPr);
         return commitParagraph(context, target, [
             patches.replaceElement(part, record.node, paragraphXml(record.node, record.id, pPr, content)),
@@ -446,7 +479,7 @@ export const setParagraphStyleHandler = {
         if (style.align === undefined &&
             (style.spacing === undefined || Object.keys(style.spacing).length === 0))
             return { createdIds: [], warnings: [] };
-        const pPr = changedParagraphProperties(part, record.pPr, style);
+        const pPr = changedParagraphProperties(part, record.pPr, style, context.tracked ? revisionAttributes(context) : undefined);
         const node = record.node;
         const content = node.selfClosing
             ? ""

package/dist/edit/docx/text.js

@@ -43,6 +43,11 @@ class Reader {
             this.#child(child, undefined);
         if (this.#field)
             this.#closeField();
+        // A paragraph mark inserted, deleted or moved under revision marks the
+        // paragraph as well.
+        const pPr = paragraph.children.find((child) => child.local === "pPr" && child.namespace === W_NS);
+        if (pPr && paragraphMarkTracked(pPr))
+            this.#tracked();
     }
     #child(node, wrapper) {
         if (node.namespace !== W_NS) {
@@ -251,6 +256,22 @@ class Reader {
     }
 }
 _a = Reader;
+const MARK_REVISIONS = new Set(["ins", "del", "moveFrom", "moveTo"]);
+/**
+ * Whether the paragraph mark's `w:rPr` carries an insertion, deletion or
+ * move. Changed properties alone (`w:rPrChange`, `w:pPrChange`) leave a
+ * paragraph editable, as module 06 decided.
+ */
+function paragraphMarkTracked(pPr) {
+    for (const child of pPr.children) {
+        if (child.namespace !== W_NS)
+            continue;
+        if (child.local === "rPr" &&
+            child.children.some((mark) => mark.namespace === W_NS && MARK_REVISIONS.has(mark.local)))
+            return true;
+    }
+    return false;
+}
 /** Reads the text of a `w:p`. */
 export function readParagraphText(part, paragraph) {
     const reader = new Reader(part);

package/dist/edit/docx/tracked.d.ts

@@ -0,0 +1,52 @@
+import type { XmlElement, XmlPart } from "../ooxml/xml.js";
+import type { ParagraphRecord } from "./model.js";
+import type { DocxOperationContext, Issue } from "./operations.js";
+import type { DocxRevision } from "./types.js";
+/** The attributes of one revision element, with a fresh `w:id`. */
+export declare function revisionAttributes(context: DocxOperationContext): string;
+/** A refusal for an operation, or a part of one, that has no tracked form. */
+export declare function unsupportedTracked(issue: Issue, path: string, what: string): void;
+/**
+ * Whether a tracked change of `[start, end)` would touch a hyperlink, a
+ * content control, a field or a run already under revision, which the
+ * tracked rebuild cannot express; reports it as an issue at `path`.
+ */
+export declare function trackedRangeProblem(record: ParagraphRecord, start: number, end: number, issue: Issue, path: string): boolean;
+/** A deleted run: its properties and its content, text as `w:delText`. */
+export declare function deletedRunXml(rPr: string, content: string): string;
+export interface TrackedSplit {
+    /** Everything before the change, bytes kept. */
+    readonly before: string;
+    /** The removed runs inside one `w:del`, or "". */
+    readonly deleted: string;
+    /** The `w:rPr` bytes new text takes. */
+    readonly rPr: string;
+    /** Everything after the change, bytes kept. */
+    readonly after: string;
+}
+/**
+ * The paragraph's content around `[start, end)`, unit by unit as the direct
+ * edit walks it: the runs the range covers re-serialized as deleted, a cut
+ * run split into a kept head, a deleted middle and a kept tail, everything
+ * else as its bytes. New text takes the style of the first replaced run,
+ * else of the run before a caret, else of the run after it. The caller
+ * places the insertion between `deleted` and `after`. A wrapper or a field
+ * inside the range never reaches here: validation refuses it.
+ */
+export declare function trackedSplit(context: DocxOperationContext, record: ParagraphRecord, start: number, end: number, fallbackRPr: string): TrackedSplit;
+/** `text` as an inserted run under revision; nothing for empty text. */
+export declare function insertedRunXml(context: DocxOperationContext, rPr: string, text: string): string;
+/** `w:pPr` bytes with the paragraph mark under revision (`w:ins` or `w:del` first in its `w:rPr`), section properties left out. */
+export declare function markedParagraphProperties(context: DocxOperationContext, pPr: XmlElement | undefined, mark: "ins" | "del"): string;
+/**
+ * A whole paragraph marked deleted: its mark under `w:del`, every run
+ * inside `w:del` with `w:delText`, other children kept. Word removes the
+ * paragraph when the deletion is accepted.
+ */
+export declare function deletedParagraphXml(context: DocxOperationContext, record: ParagraphRecord): string;
+/**
+ * The revisions a paragraph holds, in document order: run-level
+ * insertions, deletions and moves with their text, the paragraph mark's
+ * own revision, and changed run or paragraph properties.
+ */
+export declare function revisionsOf(part: XmlPart, paragraph: XmlElement): DocxRevision[];

package/dist/edit/docx/tracked.js

@@ -0,0 +1,347 @@
+import { W_NS } from "./ids.js";
+import { LINE_BREAK, TAB } from "./text.js";
+import { contentOf, rPrOf, unitsOf } from "./text-ops.js";
+import { escapeAttributeValue, innerPropertiesXml, mergedProperties, paragraphXml, PPR_ORDER, runContentXml, runXml, sliceOf, } from "./write.js";
+/*
+ * Tracked changes: the same paragraph rebuild as a direct edit, but what a
+ * direct edit drops is kept inside `w:del` (text as `w:delText`) and what
+ * it adds goes inside `w:ins`, each with an id, the author and the date of
+ * the batch, so Word and Pages show the edit as a suggestion to accept or
+ * reject. A paragraph rebuilt this way holds revisions and is read-only
+ * for the next edit (decision 6 of the ai-edit module). Hyperlinks,
+ * content controls and fields have no tracked form here: a change that
+ * touches one is refused.
+ */
+/** The attributes of one revision element, with a fresh `w:id`. */
+export function revisionAttributes(context) {
+    const tracked = context.tracked;
+    return ` w:id="${context.nextRevisionId()}" w:author="${escapeAttributeValue(tracked.author)}"${tracked.date === undefined
+        ? ""
+        : ` w:date="${escapeAttributeValue(tracked.date)}"`}`;
+}
+/** A refusal for an operation, or a part of one, that has no tracked form. */
+export function unsupportedTracked(issue, path, what) {
+    issue(path, "unsupported-change-mode", `${what} has no tracked form; apply it directly and review with checkpoints`);
+}
+/** The child of `container` an item sits under. */
+function topOf(node, container) {
+    let current = node;
+    while (current.parent && current.parent !== container)
+        current = current.parent;
+    return current;
+}
+/**
+ * Whether a tracked change of `[start, end)` would touch a hyperlink, a
+ * content control, a field or a run already under revision, which the
+ * tracked rebuild cannot express; reports it as an issue at `path`.
+ */
+export function trackedRangeProblem(record, start, end, issue, path) {
+    for (const item of record.text.items) {
+        const overlaps = item.start === item.end
+            ? start < item.start && item.start < end
+            : item.start < end && start < item.end;
+        if (!overlaps)
+            continue;
+        const top = topOf(item.run, record.node);
+        // An equation or an alternate-content block sits in the paragraph
+        // without a run; a revision cannot wrap it either.
+        const plainRun = item.run.local === "r" && item.run.namespace === W_NS;
+        if (!plainRun ||
+            item.fieldRuns ||
+            item.kind === "field" ||
+            top !== item.run ||
+            item.wrapper !== undefined) {
+            unsupportedTracked(issue, path, "A change touching a hyperlink, content control, field or equation");
+            return true;
+        }
+    }
+    return false;
+}
+/** Run content with `w:t` as `w:delText`, for a deleted run. */
+function deletedContent(content) {
+    return content
+        .replaceAll("<w:t>", "<w:delText>")
+        .replaceAll("<w:t ", "<w:delText ")
+        .replaceAll("</w:t>", "</w:delText>")
+        .replaceAll("<w:instrText", "<w:delInstrText")
+        .replaceAll("</w:instrText>", "</w:delInstrText>");
+}
+/** A deleted run: its properties and its content, text as `w:delText`. */
+export function deletedRunXml(rPr, content) {
+    return content.length === 0
+        ? ""
+        : `<w:r>${rPr}${deletedContent(content)}</w:r>`;
+}
+/** The whole content of a run (every child but `w:rPr`) as bytes. */
+function runContentOf(part, run) {
+    return run.children
+        .filter((child) => !(child.local === "rPr" && child.namespace === W_NS))
+        .map((child) => sliceOf(part, child))
+        .join("");
+}
+/** `w:rPr` bytes of a run element. */
+function runPropertiesOf(part, run) {
+    const rPr = run.children.find((child) => child.local === "rPr" && child.namespace === W_NS);
+    return sliceOf(part, rPr);
+}
+/**
+ * The deleted part of a cut run: like `contentOf`, but a zero-width item
+ * (a note reference, an anchored drawing) belongs to the deletion only
+ * strictly inside `(from, to)`, so the kept head or tail keeps it instead
+ * and nothing is written twice.
+ */
+function deletedContentOf(part, items, from, to) {
+    let out = "";
+    for (const item of items) {
+        if (item.start === item.end) {
+            if (from < item.start && item.start < to)
+                out += sliceOf(part, item.child);
+            continue;
+        }
+        const begin = Math.max(item.start, from);
+        const stop = Math.min(item.end, to);
+        if (stop <= begin)
+            continue;
+        if (item.kind === "text" && item.child.local === "t")
+            out += runContentXml(item.text.slice(begin - item.start, stop - item.start));
+        else if (begin === item.start && stop === item.end)
+            out += sliceOf(part, item.child);
+    }
+    return out;
+}
+/**
+ * The paragraph's content around `[start, end)`, unit by unit as the direct
+ * edit walks it: the runs the range covers re-serialized as deleted, a cut
+ * run split into a kept head, a deleted middle and a kept tail, everything
+ * else as its bytes. New text takes the style of the first replaced run,
+ * else of the run before a caret, else of the run after it. The caller
+ * places the insertion between `deleted` and `after`. A wrapper or a field
+ * inside the range never reaches here: validation refuses it.
+ */
+export function trackedSplit(context, record, start, end, fallbackRPr) {
+    const part = context.model.document;
+    let before = "";
+    let after = "";
+    const deletedRuns = [];
+    let rPr;
+    let lastRPr;
+    /** The change has been passed: zero-width children now follow it. */
+    let passed = false;
+    const raw = (unit) => unit.nodes.map((node) => sliceOf(part, node)).join("");
+    for (const unit of unitsOf(record.node, record.text.items)) {
+        if (unit.kind === "zero") {
+            if (passed)
+                after += raw(unit);
+            else
+                before += raw(unit);
+            continue;
+        }
+        if (unit.end <= start) {
+            before += raw(unit);
+            lastRPr = rPrOf(part, unit.items.at(-1));
+            // A caret right after this unit: the new text follows its style.
+            if (start === end && unit.end === start) {
+                rPr ??= lastRPr;
+                passed = true;
+            }
+            continue;
+        }
+        if (unit.start >= end) {
+            rPr ??= lastRPr ?? rPrOf(part, unit.items[0]);
+            passed = true;
+            after += raw(unit);
+            continue;
+        }
+        if (unit.kind !== "run")
+            throw new Error("A tracked change cannot cut a field or a wrapper");
+        const run = unit.nodes[0];
+        const style = runPropertiesOf(part, run);
+        if (unit.start >= start && unit.end <= end) {
+            // Covered whole: the run goes into the deletion as it is.
+            deletedRuns.push(deletedRunXml(style, runContentOf(part, run)));
+        }
+        else {
+            const head = contentOf(part, unit.items, unit.start, start, true);
+            const middle = deletedContentOf(part, unit.items, Math.max(unit.start, start), Math.min(unit.end, end));
+            const tail = contentOf(part, unit.items, end, unit.end, start < end);
+            if (head)
+                before += runXml(style, head);
+            if (middle)
+                deletedRuns.push(deletedRunXml(style, middle));
+            if (tail)
+                after += runXml(style, tail);
+        }
+        rPr ??= style;
+        if (unit.end >= end)
+            passed = true;
+    }
+    const deleted = deletedRuns.length > 0
+        ? `<w:del${revisionAttributes(context)}>${deletedRuns.join("")}</w:del>`
+        : "";
+    return { before, deleted, rPr: rPr ?? lastRPr ?? fallbackRPr, after };
+}
+/** `text` as an inserted run under revision; nothing for empty text. */
+export function insertedRunXml(context, rPr, text) {
+    const content = runContentXml(text);
+    return content.length === 0
+        ? ""
+        : `<w:ins${revisionAttributes(context)}>${runXml(rPr, content)}</w:ins>`;
+}
+/** `w:pPr` bytes with the paragraph mark under revision (`w:ins` or `w:del` first in its `w:rPr`), section properties left out. */
+export function markedParagraphProperties(context, pPr, mark) {
+    const part = context.model.document;
+    const rPr = pPr?.children.find((child) => child.local === "rPr" && child.namespace === W_NS);
+    const inner = innerPropertiesXml(part, rPr, ["ins", "del"]);
+    const marked = `<w:rPr><w:${mark}${revisionAttributes(context)}/>${inner}</w:rPr>`;
+    return mergedProperties(part, pPr, "w:pPr", PPR_ORDER, new Map([
+        ["rPr", marked],
+        ["sectPr", null],
+    ]));
+}
+/**
+ * A whole paragraph marked deleted: its mark under `w:del`, every run
+ * inside `w:del` with `w:delText`, other children kept. Word removes the
+ * paragraph when the deletion is accepted.
+ */
+export function deletedParagraphXml(context, record) {
+    const part = context.model.document;
+    const pPr = markedParagraphProperties(context, record.pPr, "del");
+    let content = "";
+    let open = [];
+    const flush = () => {
+        if (open.length > 0)
+            content += `<w:del${revisionAttributes(context)}>${open.join("")}</w:del>`;
+        open = [];
+    };
+    for (const child of record.node.children) {
+        if (child.local === "pPr" && child.namespace === W_NS)
+            continue;
+        if (child.local === "r" && child.namespace === W_NS) {
+            const run = deletedRunXml(runPropertiesOf(part, child), runContentOf(part, child));
+            if (run)
+                open.push(run);
+            continue;
+        }
+        flush();
+        content += sliceOf(part, child);
+    }
+    flush();
+    return paragraphXml(record.node, record.id, pPr, content);
+}
+const RUN_REVISIONS = new Set(["ins", "del", "moveFrom", "moveTo"]);
+/**
+ * The revisions a paragraph holds, in document order: run-level
+ * insertions, deletions and moves with their text, the paragraph mark's
+ * own revision, and changed run or paragraph properties.
+ */
+export function revisionsOf(part, paragraph) {
+    const out = [];
+    const attributes = (node) => {
+        const author = part.attribute(node, "w:author");
+        const date = part.attribute(node, "w:date");
+        const raw = part.attribute(node, "w:id");
+        return {
+            id: raw !== undefined && /^\d+$/.test(raw) ? Number(raw) : -1,
+            ...(author === undefined ? {} : { author }),
+            ...(date === undefined ? {} : { date }),
+        };
+    };
+    const visit = (node, inRPr, inPPr) => {
+        for (const child of node.children) {
+            if (child.namespace !== W_NS) {
+                visit(child, inRPr, inPPr);
+                continue;
+            }
+            if (child.local === "pPr") {
+                visit(child, false, true);
+                continue;
+            }
+            if (child.local === "rPr") {
+                visit(child, true, inPPr);
+                continue;
+            }
+            if (inRPr && RUN_REVISIONS.has(child.local)) {
+                out.push({
+                    start: child.start,
+                    revision: {
+                        kind: child.local,
+                        scope: inPPr ? "mark" : "runs",
+                        ...attributes(child),
+                        ...(inPPr ? { text: "\n" } : {}),
+                    },
+                });
+                continue;
+            }
+            if (inRPr && child.local === "rPrChange") {
+                out.push({
+                    start: child.start,
+                    revision: {
+                        kind: "rPrChange",
+                        scope: inPPr ? "mark" : "runs",
+                        ...attributes(child),
+                        ...(inPPr || !node.parent
+                            ? {}
+                            : { text: textOf(part, node.parent) }),
+                    },
+                });
+                continue;
+            }
+            if (inPPr && child.local === "pPrChange") {
+                out.push({
+                    start: child.start,
+                    revision: {
+                        kind: "pPrChange",
+                        scope: "paragraph",
+                        ...attributes(child),
+                    },
+                });
+                continue;
+            }
+            if (!inRPr && !inPPr && RUN_REVISIONS.has(child.local)) {
+                out.push({
+                    start: child.start,
+                    revision: {
+                        kind: child.local,
+                        scope: "runs",
+                        ...attributes(child),
+                        text: textOf(part, child),
+                    },
+                });
+                visit(child, false, false);
+                continue;
+            }
+            visit(child, inRPr, inPPr);
+        }
+    };
+    visit(paragraph, false, false);
+    return out
+        .sort((a, b) => a.start - b.start)
+        .map((entry) => Object.freeze(entry.revision));
+}
+/** The text of every run under `node`: `w:t` and `w:delText`, tabs and breaks. */
+function textOf(part, node) {
+    let text = "";
+    const visit = (current) => {
+        for (const child of current.children) {
+            if (child.namespace === W_NS) {
+                if (child.local === "t" || child.local === "delText") {
+                    text += part.textOf(child);
+                    continue;
+                }
+                if (child.local === "tab") {
+                    text += TAB;
+                    continue;
+                }
+                if (child.local === "br" || child.local === "cr") {
+                    text += LINE_BREAK;
+                    continue;
+                }
+                if (child.local === "rPr" || child.local === "pPr")
+                    continue;
+            }
+            visit(child);
+        }
+    };
+    visit(node);
+    return text;
+}