web-doc 0.6.2 → 0.7.0

package/dist/edit/docx/style.js

@@ -0,0 +1,375 @@
+import { OFFICE_RELATIONSHIPS, W_NS } from "./ids.js";
+/*
+ * Resolved styles of WordprocessingML. A run property comes from the first
+ * of: the run's own `w:rPr`, its character style chain (`w:rStyle`, then
+ * `w:basedOn` up), the paragraph style chain's run properties, the default
+ * paragraph style, the document defaults, Word's built-in defaults. A
+ * paragraph property comes from `w:pPr`, the paragraph style chain, the
+ * default paragraph style, the document defaults. Theme fonts and colours
+ * are reported in their theme form where the file uses them.
+ */
+const HIGHLIGHTS = new Set([
+    "yellow",
+    "green",
+    "cyan",
+    "magenta",
+    "blue",
+    "red",
+    "darkBlue",
+    "darkCyan",
+    "darkGreen",
+    "darkMagenta",
+    "darkRed",
+    "darkYellow",
+    "darkGray",
+    "lightGray",
+    "black",
+    "white",
+]);
+const BUILTIN_FONTS = { major: "Calibri Light", minor: "Calibri" };
+/** Word's `w:themeColor` names to the theme's colour scheme slots. */
+const THEME_SLOTS = {
+    dark1: "dk1",
+    text1: "dk1",
+    light1: "lt1",
+    background1: "lt1",
+    dark2: "dk2",
+    text2: "dk2",
+    light2: "lt2",
+    background2: "lt2",
+    accent1: "accent1",
+    accent2: "accent2",
+    accent3: "accent3",
+    accent4: "accent4",
+    accent5: "accent5",
+    accent6: "accent6",
+    hyperlink: "hlink",
+    followedHyperlink: "folHlink",
+};
+/** Whether a name is one Word accepts in `w:themeColor`. */
+export function isThemeColorName(name) {
+    return Object.hasOwn(THEME_SLOTS, name);
+}
+/** The styles and theme of a document, read once per revision. */
+export class DocxStyles {
+    part;
+    styles;
+    defaultParagraph;
+    defaultCharacter;
+    docDefaultsRPr;
+    docDefaultsPPr;
+    fonts;
+    colors;
+    constructor(part, styles, defaultParagraph, defaultCharacter, docDefaultsRPr, docDefaultsPPr, fonts, colors) {
+        this.part = part;
+        this.styles = styles;
+        this.defaultParagraph = defaultParagraph;
+        this.defaultCharacter = defaultCharacter;
+        this.docDefaultsRPr = docDefaultsRPr;
+        this.docDefaultsPPr = docDefaultsPPr;
+        this.fonts = fonts;
+        this.colors = colors;
+    }
+    /** The `#RRGGBB` a `w:themeColor` name resolves to in this theme, when it has one. */
+    themeColor(name) {
+        const slot = THEME_SLOTS[name];
+        return slot ? this.colors.get(slot) : undefined;
+    }
+    static async load(pkg, documentPart, signal) {
+        const rels = await pkg.relationships(documentPart, signal);
+        const stylesPart = rels.byType(`${OFFICE_RELATIONSHIPS}styles`)[0]
+            ?.targetPart;
+        const themePart = rels.byType(`${OFFICE_RELATIONSHIPS}theme`)[0]
+            ?.targetPart;
+        const { fonts, colors } = await readTheme(pkg, themePart, signal);
+        if (!stylesPart || !pkg.has(stylesPart))
+            return new DocxStyles(undefined, new Map(), undefined, undefined, undefined, undefined, fonts, colors);
+        const part = await pkg.xml(stylesPart, signal);
+        const styles = new Map();
+        let defaultParagraph;
+        let defaultCharacter;
+        for (const node of part.root.children) {
+            if (node.namespace !== W_NS || node.local !== "style")
+                continue;
+            const id = part.attribute(node, "w:styleId");
+            if (!id)
+                continue;
+            const basedOn = part.attribute(node.children.find((child) => child.local === "basedOn") ?? node, "w:val");
+            const record = {
+                id,
+                type: part.attribute(node, "w:type") ?? "paragraph",
+                ...(basedOn && basedOn !== id ? { basedOn } : {}),
+                isDefault: isOn(part.attribute(node, "w:default")),
+                ...pick(node, "rPr", "pPr"),
+            };
+            styles.set(id, record);
+            if (record.isDefault && record.type === "paragraph" && !defaultParagraph)
+                defaultParagraph = record;
+            if (record.isDefault && record.type === "character" && !defaultCharacter)
+                defaultCharacter = record;
+        }
+        const docDefaults = part.root.children.find((child) => child.local === "docDefaults");
+        const rPrDefault = docDefaults?.children.find((child) => child.local === "rPrDefault");
+        const pPrDefault = docDefaults?.children.find((child) => child.local === "pPrDefault");
+        return new DocxStyles(part, styles, defaultParagraph, defaultCharacter, rPrDefault?.children.find((child) => child.local === "rPr"), pPrDefault?.children.find((child) => child.local === "pPr"), fonts, colors);
+    }
+    /** A style and the styles it is based on, nearest first; cycles stop. */
+    chain(id) {
+        const out = [];
+        const seen = new Set();
+        let current = id;
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            const record = this.styles.get(current);
+            if (!record)
+                break;
+            out.push(record);
+            current = record.basedOn;
+        }
+        return out;
+    }
+}
+function pick(node, ...names) {
+    const out = {};
+    for (const name of names) {
+        const child = node.children.find((candidate) => candidate.local === name && candidate.namespace === W_NS);
+        if (child)
+            out[name] = child;
+    }
+    return out;
+}
+async function readTheme(pkg, themePart, signal) {
+    const none = { fonts: BUILTIN_FONTS, colors: new Map() };
+    if (!themePart || !pkg.has(themePart))
+        return none;
+    try {
+        const xml = await pkg.xml(themePart, signal);
+        const face = (scheme) => {
+            const node = xml.find(scheme);
+            const latin = node?.children.find((child) => child.local === "latin");
+            return latin ? xml.attribute(latin, "typeface") : undefined;
+        };
+        const colors = new Map();
+        const scheme = xml.find("clrScheme");
+        for (const slot of scheme?.children ?? []) {
+            const value = slot.children[0];
+            const rgb = value
+                ? value.local === "srgbClr"
+                    ? xml.attribute(value, "val")
+                    : value.local === "sysClr"
+                        ? xml.attribute(value, "lastClr")
+                        : undefined
+                : undefined;
+            if (rgb && /^[0-9A-Fa-f]{6}$/.test(rgb))
+                colors.set(slot.local, rgb.toUpperCase());
+        }
+        return {
+            fonts: {
+                major: face("majorFont") || BUILTIN_FONTS.major,
+                minor: face("minorFont") || BUILTIN_FONTS.minor,
+            },
+            colors,
+        };
+    }
+    catch {
+        return none;
+    }
+}
+/** `w:b`, `w:i`, `w:default`-style toggles: present without a value means on. */
+export function isOn(value) {
+    return value === undefined || !/^(0|false|off)$/i.test(value);
+}
+/** The run property holders in resolution order for a run of a paragraph. */
+export function runPropertySources(styles, pPr, rPr) {
+    const out = [];
+    if (rPr)
+        out.push(rPr);
+    const rStyle = rPr
+        ? attributeOf(rPr.children.find((child) => child.local === "rStyle"), "w:val")
+        : undefined;
+    for (const record of styles.chain(rStyle))
+        if (record.rPr)
+            out.push(record.rPr);
+    const pStyle = pPr
+        ? attributeOf(pPr.children.find((child) => child.local === "pStyle"), "w:val")
+        : undefined;
+    for (const record of styles.chain(pStyle ?? styles.defaultParagraph?.id))
+        if (record.rPr)
+            out.push(record.rPr);
+    if (pStyle &&
+        styles.defaultParagraph &&
+        !styles.chain(pStyle).includes(styles.defaultParagraph) &&
+        styles.defaultParagraph.rPr)
+        out.push(styles.defaultParagraph.rPr);
+    if (styles.docDefaultsRPr)
+        out.push(styles.docDefaultsRPr);
+    return out;
+}
+/** The paragraph property holders in resolution order. */
+export function paragraphPropertySources(styles, pPr) {
+    const out = [];
+    if (pPr)
+        out.push(pPr);
+    const pStyle = pPr
+        ? attributeOf(pPr.children.find((child) => child.local === "pStyle"), "w:val")
+        : undefined;
+    const chain = styles.chain(pStyle ?? styles.defaultParagraph?.id);
+    for (const record of chain)
+        if (record.pPr)
+            out.push(record.pPr);
+    if (pStyle &&
+        styles.defaultParagraph &&
+        !chain.includes(styles.defaultParagraph) &&
+        styles.defaultParagraph.pPr)
+        out.push(styles.defaultParagraph.pPr);
+    if (styles.docDefaultsPPr)
+        out.push(styles.docDefaultsPPr);
+    return out;
+}
+function attributeOf(node, name) {
+    return node?.attributes.find((attribute) => attribute.name === name)?.value;
+}
+/** The first holder that has a `name` child, with that child. */
+function firstChild(sources, name) {
+    for (const source of sources) {
+        const child = source.children.find((candidate) => candidate.local === name && candidate.namespace === W_NS);
+        if (child)
+            return child;
+    }
+    return undefined;
+}
+export function resolveTextStyle(styles, pPr, rPr) {
+    const sources = runPropertySources(styles, pPr, rPr);
+    const toggle = (name) => {
+        const node = firstChild(sources, name);
+        return node ? isOn(attributeOf(node, "w:val")) : false;
+    };
+    const sz = firstChild(sources, "sz");
+    const half = Number(sz ? attributeOf(sz, "w:val") : NaN);
+    const underlineNode = firstChild(sources, "u");
+    const underline = underlineNode
+        ? (attributeOf(underlineNode, "w:val") ?? "single") !== "none"
+        : false;
+    const highlightNode = firstChild(sources, "highlight");
+    const highlight = highlightNode
+        ? attributeOf(highlightNode, "w:val")
+        : undefined;
+    return {
+        fontFamily: resolveFont(sources, styles.fonts),
+        fontSize: Number.isFinite(half) && half > 0 ? half / 2 : 10,
+        bold: toggle("b"),
+        italic: toggle("i"),
+        underline,
+        color: resolveColor(firstChild(sources, "color")),
+        ...(highlight && HIGHLIGHTS.has(highlight) && highlight !== "none"
+            ? { highlight: highlight }
+            : {}),
+    };
+}
+function resolveFont(sources, fonts) {
+    for (const source of sources) {
+        const rFonts = source.children.find((child) => child.local === "rFonts" && child.namespace === W_NS);
+        if (!rFonts)
+            continue;
+        const theme = attributeOf(rFonts, "w:asciiTheme") ??
+            attributeOf(rFonts, "w:hAnsiTheme");
+        if (theme)
+            return theme.startsWith("major") ? fonts.major : fonts.minor;
+        const face = attributeOf(rFonts, "w:ascii") ?? attributeOf(rFonts, "w:hAnsi");
+        if (face)
+            return face;
+    }
+    return fonts.minor;
+}
+function resolveColor(node) {
+    if (!node)
+        return "auto";
+    const theme = attributeOf(node, "w:themeColor");
+    if (theme)
+        return { theme };
+    const value = attributeOf(node, "w:val");
+    return value && /^[0-9A-Fa-f]{6}$/.test(value)
+        ? `#${value.toUpperCase()}`
+        : "auto";
+}
+export function alignOf(value) {
+    switch (value) {
+        case "left":
+        case "start":
+            return "left";
+        case "center":
+            return "center";
+        case "right":
+        case "end":
+            return "right";
+        case "both":
+        case "distribute":
+        case "thaiDistribute":
+        case "lowKashida":
+        case "mediumKashida":
+        case "highKashida":
+            return "justify";
+        default:
+            return undefined;
+    }
+}
+export function resolveParagraphStyle(styles, pPr) {
+    const sources = paragraphPropertySources(styles, pPr);
+    const styleId = pPr
+        ? attributeOf(pPr.children.find((child) => child.local === "pStyle"), "w:val")
+        : undefined;
+    const jc = firstChild(sources, "jc");
+    const numPr = firstChild(sources, "numPr");
+    // Spacing attributes inherit one by one: a style that sets `w:before`
+    // keeps the base style's `w:after` and `w:line`.
+    const spacings = sources
+        .map((source) => source.children.find((child) => child.local === "spacing" && child.namespace === W_NS))
+        .filter((node) => node !== undefined);
+    const spacingAttribute = (name) => {
+        for (const node of spacings) {
+            const value = attributeOf(node, name);
+            if (value !== undefined)
+                return value;
+        }
+        return undefined;
+    };
+    const twips = (name) => {
+        const value = Number(spacingAttribute(name) ?? NaN);
+        return Number.isFinite(value) ? value / 20 : undefined;
+    };
+    const before = twips("w:before");
+    const after = twips("w:after");
+    const lineHolder = spacings.find((node) => attributeOf(node, "w:line") !== undefined);
+    const lineRaw = Number(lineHolder ? attributeOf(lineHolder, "w:line") : NaN);
+    const lineRule = lineHolder
+        ? (attributeOf(lineHolder, "w:lineRule") ?? "auto")
+        : undefined;
+    const line = Number.isFinite(lineRaw)
+        ? lineRule === "auto"
+            ? lineRaw / 240
+            : lineRaw / 20
+        : undefined;
+    const out = {
+        ...(before === undefined ? {} : { before }),
+        ...(after === undefined ? {} : { after }),
+        ...(line === undefined ? {} : { line }),
+        ...(line === undefined ||
+            (lineRule !== "auto" && lineRule !== "exact" && lineRule !== "atLeast")
+            ? {}
+            : { lineRule }),
+    };
+    const numId = Number(numPr
+        ? attributeOf(numPr.children.find((c) => c.local === "numId"), "w:val")
+        : NaN);
+    const level = Number(numPr
+        ? attributeOf(numPr.children.find((c) => c.local === "ilvl"), "w:val")
+        : 0);
+    return {
+        ...(styleId ? { styleId } : {}),
+        align: alignOf(jc ? attributeOf(jc, "w:val") : undefined) ?? "left",
+        spacing: out,
+        ...(Number.isInteger(numId) && numId > 0
+            ? { numbering: { numId, level: Number.isInteger(level) ? level : 0 } }
+            : {}),
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { DocxOperationHandler } from "./operations.js";
+import type { DocxInsertTableOperation, DocxSetTableCellOperation } from "./types.js";
+export declare const insertTableHandler: DocxOperationHandler<DocxInsertTableOperation>;
+export declare const setTableCellHandler: DocxOperationHandler<DocxSetTableCellOperation>;

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

@@ -0,0 +1,219 @@
+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 { 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
+ * grid over the section's content width, one paragraph per cell and a
+ * paragraph after it where the body needs one; a cell's text replaced in
+ * its first paragraph with the cell's other paragraphs removed.
+ */
+/** US Letter with one-inch margins: the content width Word assumes without a section. */
+const DEFAULT_CONTENT_WIDTH = 12240 - 2 * 1440;
+/** Exactly one of `before` and `after`, resolved to a body-level block. */
+function placement(operation, context, issue) {
+    const named = [operation.before, operation.after].filter((value) => value !== undefined);
+    if (named.length !== 1) {
+        issue("/before", "invalid-value", "Exactly one of before and after names the reference element");
+        return undefined;
+    }
+    const side = operation.before !== undefined ? "before" : "after";
+    const id = operation[side];
+    const record = context.model.byId.get(id);
+    if (!record || (record.kind !== "paragraph" && record.kind !== "table")) {
+        issue(`/${side}`, record ? "invalid-target" : "unknown-target", record
+            ? `Element ${id} is not a paragraph or a table`
+            : `No element ${id}`);
+        return undefined;
+    }
+    if (record.kind === "paragraph" && record.table) {
+        issue(`/${side}`, "invalid-target", "A table cannot be placed inside a cell");
+        return undefined;
+    }
+    return { record, side };
+}
+/** The content width, in twentieths of a point, of the section a block belongs to. */
+function contentWidth(model, node, side) {
+    const part = model.document;
+    const geometry = (sectPr) => {
+        if (!sectPr)
+            return undefined;
+        const read = (local, name) => {
+            const holder = sectPr.children.find((child) => child.local === local && child.namespace === W_NS);
+            const value = Number(holder ? part.attribute(holder, name) : NaN);
+            return Number.isFinite(value) && value >= 0 ? value : undefined;
+        };
+        const width = read("pgSz", "w:w");
+        if (width === undefined)
+            return undefined;
+        return (width -
+            (read("pgMar", "w:left") ?? 1440) -
+            (read("pgMar", "w:right") ?? 1440));
+    };
+    // The section a block belongs to ends at the next paragraph carrying a
+    // w:sectPr, else at the body's own; a table placed after a paragraph
+    // that ends a section lands in the section after it.
+    let passed = false;
+    for (const block of model.blocks) {
+        const own = block.node === node;
+        if (own)
+            passed = true;
+        if (own && side === "after")
+            continue;
+        if (passed && block.kind === "paragraph" && block.sectPr) {
+            const width = geometry(block.sectPr);
+            if (width !== undefined)
+                return width;
+            break;
+        }
+    }
+    return geometry(model.bodySectPr) ?? DEFAULT_CONTENT_WIDTH;
+}
+/** Column widths in twentieths of a point from relative weights over `total`. */
+function columnWidths(weights, total) {
+    const sum = weights.reduce((a, b) => a + b, 0);
+    const widths = weights.map((weight) => Math.floor((weight / sum) * total));
+    const remainder = total - widths.reduce((a, b) => a + b, 0);
+    widths[widths.length - 1] += remainder;
+    return widths;
+}
+/** `w:tblPr`: the TableGrid style when the document defines it, else single borders. */
+function tablePropertiesXml(model) {
+    const grid = model.styles.styles.get("TableGrid");
+    const look = '<w:tblLook w:val="04A0" w:firstRow="1" w:lastRow="0" w:firstColumn="1" w:lastColumn="0" w:noHBand="0" w:noVBand="1"/>';
+    if (grid && grid.type === "table")
+        return `<w:tblPr><w:tblStyle w:val="TableGrid"/><w:tblW w:w="0" w:type="auto"/>${look}</w:tblPr>`;
+    const edge = (name) => `<w:${name} w:val="single" w:sz="4" w:space="0" w:color="auto"/>`;
+    return `<w:tblPr><w:tblW w:w="0" w:type="auto"/><w:tblBorders>${["top", "left", "bottom", "right", "insideH", "insideV"].map(edge).join("")}</w:tblBorders>${look}</w:tblPr>`;
+}
+/** The text of a cell as one paragraph: newlines become line breaks. */
+function cellRunXml(text) {
+    return runXml("", runContentXml(normalizeText(text).replaceAll("\n", LINE_BREAK)));
+}
+function commit(context, items, result) {
+    const part = context.model.document;
+    const transaction = context.pkg.transaction();
+    transaction.patch(part, [...namespacePatches(part), ...items]);
+    return transaction
+        .commit()
+        .then((change) => ({ ...result, warnings: change.warnings }));
+}
+export const insertTableHandler = {
+    async validate(operation, context, issue) {
+        placement(operation, context, issue);
+        const columns = operation.rows[0]?.length ?? 0;
+        if (operation.rows.some((row) => row.length !== columns))
+            issue("/rows", "invalid-value", "Every row needs the same number of cells");
+        if (operation.columnWidths && operation.columnWidths.length !== columns)
+            issue("/columnWidths", "invalid-value", "One weight per column is needed");
+        operation.rows.forEach((row, rowIndex) => row.forEach((cell, columnIndex) => {
+            const problem = textProblem(cell);
+            if (problem)
+                issue(`/rows/${rowIndex}/${columnIndex}`, "invalid-text", `The text holds ${problem}`);
+        }));
+    },
+    async apply(operation, context) {
+        const { model } = context;
+        const { record, side } = placement(operation, context, () => { });
+        const part = model.document;
+        const node = record.node;
+        const widths = columnWidths(operation.columnWidths ?? operation.rows[0].map(() => 1), contentWidth(model, node, side));
+        const createdIds = [];
+        const cellIds = [];
+        const rows = operation.rows
+            .map((row) => `<w:tr>${row
+            .map((cell, column) => {
+            const id = context.freshParagraphId();
+            cellIds.push(`p:${id}`);
+            return `<w:tc><w:tcPr><w:tcW w:w="${widths[column]}" w:type="dxa"/></w:tcPr>${paragraphXml(undefined, id, "", cellRunXml(cell))}</w:tc>`;
+        })
+            .join("")}</w:tr>`)
+            .join("");
+        const table = `<w:tbl>${tablePropertiesXml(model)}<w:tblGrid>${widths
+            .map((width) => `<w:gridCol w:w="${width}"/>`)
+            .join("")}</w:tblGrid>${rows}</w:tbl>`;
+        createdIds.push(`tbl:${cellIds[0].slice(2)}`, ...cellIds);
+        // A paragraph must follow the table when the next sibling would be a
+        // table or the body's section properties.
+        const siblings = model.blocks;
+        const index = siblings.indexOf(record);
+        const next = side === "before" ? record : siblings[index + 1];
+        let trailing = "";
+        if (!next || next.kind === "table") {
+            const id = context.freshParagraphId();
+            createdIds.push(`p:${id}`);
+            trailing = paragraphXml(undefined, id, "", "");
+        }
+        return commit(context, [
+            side === "before"
+                ? patches.insertBefore(part, node, table)
+                : patches.insertAfter(part, node, table),
+            ...(trailing
+                ? [
+                    side === "before"
+                        ? patches.insertBefore(part, node, trailing)
+                        : patches.insertAfter(part, node, trailing),
+                ]
+                : []),
+        ], { createdIds, reflowFrom: record.id });
+    },
+};
+export const setTableCellHandler = {
+    async validate(operation, context, issue) {
+        const problem = textProblem(normalizeText(operation.text));
+        if (problem)
+            issue("/text", "invalid-text", `The text holds ${problem}`);
+        const record = context.model.byId.get(operation.target);
+        if (!record || record.kind !== "table") {
+            issue("/target", record ? "invalid-target" : "unknown-target", record
+                ? `Element ${operation.target} is not a table`
+                : `No element ${operation.target}`);
+            return;
+        }
+        const row = record.rows[operation.row];
+        if (!row) {
+            issue("/row", "range", `The table has ${record.rows.length} rows`);
+            return;
+        }
+        const cell = row[operation.column];
+        if (!cell) {
+            issue("/column", "range", `Row ${operation.row} has ${row.length} cells`);
+            return;
+        }
+        const first = cell.paragraphs[0];
+        if (!first)
+            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})`);
+    },
+    async apply(operation, context) {
+        const { model } = context;
+        const record = model.byId.get(operation.target);
+        const cell = record.rows[operation.row][operation.column];
+        const [first, ...rest] = cell.paragraphs;
+        const text = normalizeText(operation.text).replaceAll("\n", LINE_BREAK);
+        const replaced = replacedParagraph(context, first, 0, first.text.text.length, text);
+        const part = model.document;
+        const items = [...replaced.items];
+        const removedIds = [...replaced.removedIds];
+        const removedParagraphIds = [...replaced.removedParagraphIds];
+        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);
+            for (const nested of part.findAll("p", paragraph.node)) {
+                const id = model.paragraphIds.get(nested);
+                if (id && nested !== paragraph.node)
+                    removedParagraphIds.push(id);
+            }
+        }
+        return commit(context, items, {
+            createdIds: replaced.createdIds,
+            ...(removedIds.length > 0 ? { removedIds } : {}),
+            ...(removedParagraphIds.length > 0 ? { removedParagraphIds } : {}),
+            ...(model.unauthoredSet.has(first.id) ? { stamped: [first.id] } : {}),
+            reflowFrom: record.id,
+        });
+    },
+};

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

@@ -0,0 +1,18 @@
+import { type XmlPatch } from "../ooxml/patch.js";
+import type { ParagraphRecord } from "./model.js";
+import type { DocxOperationContext, DocxOperationHandler } from "./operations.js";
+import type { DocxReplaceTextOperation, DocxSetParagraphStyleOperation, DocxSetTextStyleOperation } from "./types.js";
+export declare const replaceTextHandler: DocxOperationHandler<DocxReplaceTextOperation>;
+/**
+ * The patches that replace `[start, end)` of a paragraph's text with
+ * `text`, newlines splitting it into new paragraphs after it: the first
+ * paragraph rebuilt in place, the others inserted with fresh ids.
+ */
+export declare function replacedParagraph(context: DocxOperationContext, record: ParagraphRecord, start: number, end: number, text: string): {
+    items: XmlPatch[];
+    createdIds: string[];
+    removedIds: string[];
+    removedParagraphIds: string[];
+};
+export declare const setTextStyleHandler: DocxOperationHandler<DocxSetTextStyleOperation>;
+export declare const setParagraphStyleHandler: DocxOperationHandler<DocxSetParagraphStyleOperation>;