web-doc 0.6.2 → 0.8.0

package/dist/edit/docx/text.js

@@ -0,0 +1,284 @@
+var _a;
+import { W_NS } from "./ids.js";
+/*
+ * The text model of a paragraph: `w:t` text, a tab, a line break (`\v`), a
+ * page or column break (`\f`), an inline picture or an embedded object as
+ * one object character, a field (`w:fldSimple`, or a complex field from
+ * `fldChar begin` to `end`) as its cached result text, hyperlinks and
+ * inline `w:sdt` as their runs, hidden runs as text, deleted text (`w:del`)
+ * left out. Offsets are UTF-16 code units of the paragraph's text. Every
+ * item remembers the XML it came from, so a later patch can keep the bytes
+ * of what an edit does not touch.
+ */
+export const TAB = "\t";
+export const LINE_BREAK = "\u000b";
+export const PAGE_BREAK = "\f";
+/** The object replacement character: an inline picture or an embedded object. */
+export const OBJECT = "";
+/** Wrappers whose children are read as the paragraph's own runs. */
+const TRANSPARENT = new Set([
+    "hyperlink",
+    "smartTag",
+    "customXml",
+    "dir",
+    "bdo",
+    "ins",
+    "moveTo",
+    "sdtContent",
+    "fldSimple",
+]);
+/** Wrappers whose content is deleted text: left out, the paragraph is tracked. */
+const DELETED = new Set(["del", "moveFrom"]);
+class Reader {
+    part;
+    items = [];
+    text = "";
+    tracked = false;
+    #field;
+    constructor(part) {
+        this.part = part;
+    }
+    paragraph(paragraph) {
+        for (const child of paragraph.children)
+            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) {
+            // DrawingML, math and markup compatibility live outside w:; a math
+            // zone or an alternate-content block counts as one object.
+            if (node.local === "oMath" ||
+                node.local === "oMathPara" ||
+                node.local === "AlternateContent")
+                this.#push("object", OBJECT, node, node, wrapper);
+            return;
+        }
+        switch (node.local) {
+            case "r":
+                this.#run(node, wrapper);
+                return;
+            case "sdt": {
+                const content = node.children.find((child) => child.local === "sdtContent" && child.namespace === W_NS);
+                if (content)
+                    for (const child of content.children)
+                        this.#child(child, node);
+                return;
+            }
+            case "ins":
+            case "moveTo":
+                this.#tracked();
+                for (const child of node.children)
+                    this.#child(child, node);
+                return;
+            default:
+                break;
+        }
+        if (DELETED.has(node.local)) {
+            this.#tracked();
+            return;
+        }
+        if (TRANSPARENT.has(node.local)) {
+            if (node.local === "fldSimple") {
+                this.#simpleField(node, wrapper);
+                return;
+            }
+            for (const child of node.children)
+                this.#child(child, node);
+        }
+    }
+    #tracked() {
+        this.tracked = true;
+    }
+    /** A simple field: one item carrying the text of its result runs. */
+    #simpleField(node, wrapper) {
+        const inner = new _a(this.part);
+        for (const child of node.children)
+            inner.#child(child, node);
+        this.tracked ||= inner.tracked;
+        this.#push("field", inner.text, node, node, wrapper);
+    }
+    #run(run, wrapper) {
+        const rPr = run.children.find((child) => child.local === "rPr" && child.namespace === W_NS);
+        if (rPr) {
+            const marked = rPr.children.some((child) => child.namespace === W_NS &&
+                (child.local === "ins" || child.local === "del"));
+            if (marked)
+                this.#tracked();
+        }
+        if (this.#field)
+            this.#field.runs.push(run);
+        for (const child of run.children) {
+            if (child.namespace !== W_NS) {
+                if (child.local === "AlternateContent")
+                    this.#emit("object", OBJECT, run, child, rPr, wrapper);
+                continue;
+            }
+            switch (child.local) {
+                case "rPr":
+                case "lastRenderedPageBreak":
+                case "instrText":
+                case "delInstrText":
+                case "delText":
+                    break;
+                case "fldChar":
+                    this.#fieldChar(child, run);
+                    break;
+                case "t":
+                    this.#emit("text", this.part.textOf(child), run, child, rPr, wrapper);
+                    break;
+                case "tab":
+                case "ptab":
+                    this.#emit("tab", TAB, run, child, rPr, wrapper);
+                    break;
+                case "br": {
+                    const type = this.part.attribute(child, "w:type");
+                    if (type === "page" || type === "column")
+                        this.#emit("pageBreak", PAGE_BREAK, run, child, rPr, wrapper);
+                    else
+                        this.#emit("break", LINE_BREAK, run, child, rPr, wrapper);
+                    break;
+                }
+                case "cr":
+                    this.#emit("break", LINE_BREAK, run, child, rPr, wrapper);
+                    break;
+                case "sym": {
+                    const code = Number.parseInt(this.part.attribute(child, "w:char") ?? "", 16);
+                    this.#emit("text", Number.isFinite(code) && code > 0 && code <= 0x10ffff
+                        ? String.fromCodePoint(code)
+                        : "", run, child, rPr, wrapper);
+                    break;
+                }
+                case "noBreakHyphen":
+                    this.#emit("text", "‑", run, child, rPr, wrapper);
+                    break;
+                case "softHyphen":
+                    this.#emit("text", "­", run, child, rPr, wrapper);
+                    break;
+                case "drawing": {
+                    const inline = child.children.some((node) => node.local === "inline");
+                    if (inline)
+                        this.#emit("picture", OBJECT, run, child, rPr, wrapper);
+                    else
+                        this.#emit("anchor", "", run, child, rPr, wrapper);
+                    break;
+                }
+                case "object":
+                case "pict":
+                    this.#emit("object", OBJECT, run, child, rPr, wrapper);
+                    break;
+                case "footnoteReference":
+                case "endnoteReference":
+                    this.#emit("note", "", run, child, rPr, wrapper);
+                    break;
+                case "ruby": {
+                    const base = child.children.find((node) => node.local === "rubyBase");
+                    if (base)
+                        for (const node of base.children)
+                            this.#child(node, wrapper);
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+    }
+    #fieldChar(node, run) {
+        const type = this.part.attribute(node, "w:fldCharType");
+        if (type === "begin") {
+            if (this.#field)
+                this.#field.inResult.push(false);
+            else
+                this.#field = { begin: run, runs: [run], text: "", inResult: [false] };
+            return;
+        }
+        if (!this.#field)
+            return;
+        const levels = this.#field.inResult;
+        if (type === "separate") {
+            levels[levels.length - 1] = true;
+            return;
+        }
+        if (type === "end") {
+            if (levels.length > 1)
+                levels.pop();
+            else
+                this.#closeField();
+        }
+    }
+    #closeField() {
+        const field = this.#field;
+        this.#field = undefined;
+        const rPr = field.begin.children.find((child) => child.local === "rPr" && child.namespace === W_NS);
+        this.#append({
+            kind: "field",
+            start: this.text.length,
+            end: this.text.length + field.text.length,
+            text: field.text,
+            run: field.begin,
+            child: field.begin,
+            ...(rPr ? { rPr } : {}),
+            fieldRuns: field.runs,
+        });
+    }
+    /** Text inside an open field goes to its result; outside it is an item. */
+    #emit(kind, text, run, child, rPr, wrapper) {
+        const field = this.#field;
+        if (field) {
+            // What Word shows: the result of the outer field, which holds the
+            // results of the fields nested in it and none of their instructions.
+            if (field.inResult.every(Boolean))
+                field.text += text;
+            return;
+        }
+        this.#push(kind, text, run, child, wrapper, rPr);
+    }
+    #push(kind, text, run, child, wrapper, rPr) {
+        this.#append({
+            kind,
+            start: this.text.length,
+            end: this.text.length + text.length,
+            text,
+            run,
+            child,
+            ...(rPr ? { rPr } : {}),
+            ...(wrapper ? { wrapper } : {}),
+        });
+    }
+    #append(item) {
+        this.items.push(item);
+        this.text += item.text;
+    }
+}
+_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);
+    reader.paragraph(paragraph);
+    return { text: reader.text, items: reader.items, tracked: reader.tracked };
+}
+/** The first item that draws text, for the resolved style of a paragraph. */
+export function firstTextItem(model) {
+    return model.items.find((item) => (item.kind === "text" || item.kind === "field") && item.text.length > 0);
+}

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;
+}