web-doc 0.6.2 → 0.7.0

package/dist/edit/pptx/geometry.js

@@ -0,0 +1,193 @@
+/*
+ * DrawingML geometry: EMU, 60,000ths of a degree, and the affine transforms
+ * of groups. Slide space is CSS pixels at 96 dpi.
+ */
+export const EMU_PER_PX = 9525;
+export const EMU_PER_PT = 12700;
+export function emuToPx(emu) {
+    return emu / EMU_PER_PX;
+}
+export function pxToEmu(px) {
+    return Math.round(px * EMU_PER_PX);
+}
+/** Reads `a:xfrm` (or `p:xfrm` of a graphic frame); undefined without an offset and an extent. */
+export function readXfrm(part, node) {
+    if (!node)
+        return undefined;
+    const off = node.children.find((child) => child.local === "off");
+    const ext = node.children.find((child) => child.local === "ext");
+    if (!off || !ext)
+        return undefined;
+    const x = integer(part.attribute(off, "x"));
+    const y = integer(part.attribute(off, "y"));
+    const cx = integer(part.attribute(ext, "cx"));
+    const cy = integer(part.attribute(ext, "cy"));
+    if ([x, y, cx, cy].some((value) => value === undefined))
+        return undefined;
+    const chOff = node.children.find((child) => child.local === "chOff");
+    const chExt = node.children.find((child) => child.local === "chExt");
+    const child = chOff && chExt
+        ? {
+            x: integer(part.attribute(chOff, "x")) ?? 0,
+            y: integer(part.attribute(chOff, "y")) ?? 0,
+            cx: integer(part.attribute(chExt, "cx")) ?? 0,
+            cy: integer(part.attribute(chExt, "cy")) ?? 0,
+        }
+        : undefined;
+    return {
+        x: x,
+        y: y,
+        cx: cx,
+        cy: cy,
+        rotation: (integer(part.attribute(node, "rot")) ?? 0) / 60000,
+        flipH: part.attribute(node, "flipH") === "1",
+        flipV: part.attribute(node, "flipV") === "1",
+        ...(child ? { child } : {}),
+    };
+}
+function integer(value) {
+    if (value === undefined)
+        return undefined;
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.trunc(number) : undefined;
+}
+export const IDENTITY = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+export function multiply(m, n) {
+    // m ∘ n: apply n first, then m.
+    return {
+        a: m.a * n.a + m.c * n.b,
+        b: m.b * n.a + m.d * n.b,
+        c: m.a * n.c + m.c * n.d,
+        d: m.b * n.c + m.d * n.d,
+        e: m.a * n.e + m.c * n.f + m.e,
+        f: m.b * n.e + m.d * n.f + m.f,
+    };
+}
+export function translate(tx, ty) {
+    return { a: 1, b: 0, c: 0, d: 1, e: tx, f: ty };
+}
+export function scale(sx, sy) {
+    return { a: sx, b: 0, c: 0, d: sy, e: 0, f: 0 };
+}
+function rotate(degrees) {
+    const radians = (degrees * Math.PI) / 180;
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    return { a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 };
+}
+export function apply(m, point) {
+    return {
+        x: m.a * point.x + m.c * point.y + m.e,
+        y: m.b * point.x + m.d * point.y + m.f,
+    };
+}
+export function invert(m) {
+    const det = m.a * m.d - m.b * m.c;
+    if (det === 0)
+        return IDENTITY;
+    return {
+        a: m.d / det,
+        b: -m.b / det,
+        c: -m.c / det,
+        d: m.a / det,
+        e: (m.c * m.f - m.d * m.e) / det,
+        f: (m.b * m.e - m.a * m.f) / det,
+    };
+}
+/** Rotation and flips of a frame about its centre, in the frame's own space. */
+function frameTransform(frame) {
+    const centre = translate(frame.x + frame.cx / 2, frame.y + frame.cy / 2);
+    const back = translate(-(frame.x + frame.cx / 2), -(frame.y + frame.cy / 2));
+    const flip = scale(frame.flipH ? -1 : 1, frame.flipV ? -1 : 1);
+    return multiply(centre, multiply(rotate(frame.rotation), multiply(flip, back)));
+}
+/**
+ * The transform from a group's child space to its parent space: child
+ * coordinates are scaled from `chOff`/`chExt` into `off`/`ext`, then the
+ * group's rotation and flips apply about its centre.
+ */
+export function groupMatrix(group) {
+    const child = group.child ?? { x: 0, y: 0, cx: group.cx, cy: group.cy };
+    const sx = child.cx === 0 ? 1 : group.cx / child.cx;
+    const sy = child.cy === 0 ? 1 : group.cy / child.cy;
+    const place = multiply(translate(group.x, group.y), multiply(scale(sx, sy), translate(-child.x, -child.y)));
+    return multiply(frameTransform(group), place);
+}
+/**
+ * Places a frame given in its own space (EMU) through the transform of the
+ * groups above it. The reported frame keeps the element's box scaled and
+ * positioned by the groups, with the rotations and flips combined; the
+ * bounds are the axis-aligned box of its four transformed corners.
+ */
+export function placeFrame(frame, parents) {
+    const own = frameTransform(frame);
+    const total = multiply(parents, own);
+    const corners = [
+        { x: frame.x, y: frame.y },
+        { x: frame.x + frame.cx, y: frame.y },
+        { x: frame.x + frame.cx, y: frame.y + frame.cy },
+        { x: frame.x, y: frame.y + frame.cy },
+    ].map((corner) => apply(total, corner));
+    const xs = corners.map((corner) => corner.x);
+    const ys = corners.map((corner) => corner.y);
+    const left = Math.min(...xs);
+    const top = Math.min(...ys);
+    const bounds = {
+        x: emuToPx(left),
+        y: emuToPx(top),
+        width: emuToPx(Math.max(...xs) - left),
+        height: emuToPx(Math.max(...ys) - top),
+    };
+    // The unrotated box in slide space: the parents' transform applied to the
+    // element's box, measured by its centre and its scaled extent.
+    const centre = apply(parents, {
+        x: frame.x + frame.cx / 2,
+        y: frame.y + frame.cy / 2,
+    });
+    const scaleX = Math.hypot(parents.a, parents.b);
+    const scaleY = Math.hypot(parents.c, parents.d);
+    const width = frame.cx * scaleX;
+    const height = frame.cy * scaleY;
+    const parentFlip = parents.a * parents.d - parents.b * parents.c < 0;
+    // A reflecting parent is reported as a rotation followed by flipH, so its
+    // angle comes from the matrix with that flip taken out.
+    const parentRotation = parentFlip
+        ? (Math.atan2(-parents.b, -parents.a) * 180) / Math.PI
+        : (Math.atan2(parents.b, parents.a) * 180) / Math.PI;
+    const rotation = normalizeDegrees(parentRotation + (parentFlip ? -frame.rotation : frame.rotation));
+    return {
+        frame: {
+            x: emuToPx(centre.x - width / 2),
+            y: emuToPx(centre.y - height / 2),
+            width: emuToPx(width),
+            height: emuToPx(height),
+            rotation,
+            flipH: frame.flipH !== parentFlip,
+            flipV: frame.flipV,
+        },
+        bounds,
+    };
+}
+function normalizeDegrees(degrees) {
+    const value = ((degrees % 360) + 360) % 360;
+    return Math.abs(value) < 1e-9 ? 0 : Number(value.toFixed(6));
+}
+/** Whether a slide-space point lies inside a placed frame, rotation and flips included. */
+export function frameContains(placed, point) {
+    const { frame } = placed;
+    const cx = frame.x + frame.width / 2;
+    const cy = frame.y + frame.height / 2;
+    const radians = (-frame.rotation * Math.PI) / 180;
+    const dx = point.x - cx;
+    const dy = point.y - cy;
+    const localX = dx * Math.cos(radians) - dy * Math.sin(radians);
+    const localY = dx * Math.sin(radians) + dy * Math.cos(radians);
+    return (Math.abs(localX) <= frame.width / 2 + 1e-6 &&
+        Math.abs(localY) <= frame.height / 2 + 1e-6);
+}
+export function rectsIntersect(a, b) {
+    return (a.x < b.x + b.width &&
+        b.x < a.x + a.width &&
+        a.y < b.y + b.height &&
+        b.y < a.y + a.height);
+}

package/dist/edit/pptx/handler.d.ts

@@ -0,0 +1,7 @@
+import type { WorkerOperationHandler } from "../../worker-endpoint.js";
+/**
+ * Serves the edit worker protocol for one OOXML document. It runs inside
+ * the OOXML edit worker in the browser and directly in Node tests. The open
+ * payload names the format: PPTX (the default) or DOCX.
+ */
+export declare function createOoxmlEditHandler(): WorkerOperationHandler;

package/dist/edit/pptx/handler.js

@@ -0,0 +1,91 @@
+import { ViewerError } from "../../errors.js";
+import { DocxEditEngine } from "../docx/engine.js";
+import { PptxEditEngine } from "./engine.js";
+/**
+ * Serves the edit worker protocol for one OOXML document. It runs inside
+ * the OOXML edit worker in the browser and directly in Node tests. The open
+ * payload names the format: PPTX (the default) or DOCX.
+ */
+export function createOoxmlEditHandler() {
+    let state;
+    const engine = () => {
+        if (!state)
+            throw new ViewerError("lifecycle-error", "No package is open for editing");
+        return state;
+    };
+    const pptx = () => {
+        const current = engine();
+        if (!(current instanceof PptxEditEngine))
+            throw new ViewerError("edit-unsupported", "The open document is not a presentation", { details: { format: "docx", reason: "no-reads" } });
+        return current;
+    };
+    return async (operation, payload, context) => {
+        const { signal } = context;
+        switch (operation) {
+            case "edit-init":
+                return undefined;
+            case "edit-open": {
+                const open = payload;
+                const format = open.format ?? "pptx";
+                if (format !== "pptx" && format !== "docx")
+                    throw new ViewerError("edit-unsupported", `The OOXML edit worker does not serve ${open.format} yet`, { details: { format: open.format, reason: "no-engine" } });
+                // The live engine stays until the next one opened, so a failed or
+                // aborted open leaves the worker serving what it served before.
+                const bytes = new Uint8Array(open.data);
+                const next = format === "docx"
+                    ? await DocxEditEngine.open(bytes, open.limits, signal)
+                    : await PptxEditEngine.open(bytes, open.limits, signal);
+                await state?.dispose();
+                state = next;
+                const result = { pageCount: state.pageCount };
+                return result;
+            }
+            case "edit-validate": {
+                const { operations } = payload;
+                return engine().validate(operations, signal);
+            }
+            case "edit-apply": {
+                const { batch } = payload;
+                return engine().apply(batch, signal);
+            }
+            case "edit-put-asset": {
+                const { id, data } = payload;
+                await engine().putAsset(id, new Uint8Array(data), signal);
+                return undefined;
+            }
+            case "edit-materialize": {
+                const { purpose, options } = (payload ?? {});
+                const { bytes, warnings } = await engine().materializeDocument(purpose ?? "show", options ?? {}, signal);
+                const data = bytes.slice().buffer;
+                return { data, warnings };
+            }
+            case "edit-restore": {
+                const { batches, base } = payload;
+                await engine().restore({ batches, ...(base ? { base: new Uint8Array(base) } : {}) }, signal);
+                return undefined;
+            }
+            case "edit-elements":
+                return engine().getElements(payload.query, signal);
+            case "edit-element":
+                return engine().getElement(payload.id, signal);
+            case "edit-elements-at": {
+                const { pageIndex, point } = payload;
+                return engine().elementsAt(pageIndex, point, signal);
+            }
+            case "edit-find-text": {
+                const { query, options } = payload;
+                return engine().findText(query, options, signal);
+            }
+            case "edit-pptx-slides":
+                return pptx().slides(signal);
+            case "edit-pptx-layouts":
+                return pptx().layouts(signal);
+            case "edit-dispose":
+                await state?.dispose();
+                state = undefined;
+                return undefined;
+            default:
+                throw new ViewerError("internal", `The OOXML edit worker does not handle ${operation}`);
+        }
+    };
+}

package/dist/edit/pptx/handlers.d.ts

@@ -0,0 +1,3 @@
+import type { PptxOperationHandler } from "./operations.js";
+/** Handlers by operation name; `IMPLEMENTED_OPERATIONS` in schemas.ts lists the same names. */
+export declare const pptxHandlers: ReadonlyMap<string, PptxOperationHandler>;

package/dist/edit/pptx/handlers.js

@@ -0,0 +1,21 @@
+import { deleteElementHandler, insertTextBoxHandler, moveElementHandler, resizeElementHandler, setShapeStyleHandler, } from "./shape-ops.js";
+import { insertImageHandler, insertTableHandler, setTableCellHandler, } from "./image-table-ops.js";
+import { deleteSlideHandler, duplicateSlideHandler, insertSlideHandler, moveSlideHandler, } from "./slide-ops.js";
+import { replaceTextHandler, setTextStyleHandler } from "./text-ops.js";
+/** Handlers by operation name; `IMPLEMENTED_OPERATIONS` in schemas.ts lists the same names. */
+export const pptxHandlers = new Map([
+    ["replaceText", replaceTextHandler],
+    ["setTextStyle", setTextStyleHandler],
+    ["setShapeStyle", setShapeStyleHandler],
+    ["moveElement", moveElementHandler],
+    ["resizeElement", resizeElementHandler],
+    ["deleteElement", deleteElementHandler],
+    ["insertTextBox", insertTextBoxHandler],
+    ["insertImage", insertImageHandler],
+    ["insertTable", insertTableHandler],
+    ["setTableCell", setTableCellHandler],
+    ["insertSlide", insertSlideHandler],
+    ["duplicateSlide", duplicateSlideHandler],
+    ["deleteSlide", deleteSlideHandler],
+    ["moveSlide", moveSlideHandler],
+]);

package/dist/edit/pptx/image-table-ops.d.ts

@@ -0,0 +1,5 @@
+import { type PptxOperationHandler } from "./operations.js";
+import type { PptxInsertImageOperation, PptxInsertTableOperation, PptxSetTableCellOperation } from "./types.js";
+export declare const insertImageHandler: PptxOperationHandler<PptxInsertImageOperation>;
+export declare const insertTableHandler: PptxOperationHandler<PptxInsertTableOperation>;
+export declare const setTableCellHandler: PptxOperationHandler<PptxSetTableCellOperation>;

package/dist/edit/pptx/image-table-ops.js

@@ -0,0 +1,233 @@
+import { resolveBinary } from "../assets.js";
+import { patches } from "../ooxml/patch.js";
+import { escapeText } from "../ooxml/xml.js";
+import { extensionForMime } from "../ooxml/opc.js";
+import { relativeTarget } from "../ooxml/transaction.js";
+import { pxToEmu } from "./geometry.js";
+import { RELATIONSHIP_TYPES } from "./model.js";
+import { committedParts, } from "./operations.js";
+import { paragraphsXml } from "./shape-ops.js";
+import { readTextModel } from "./text.js";
+import { replacedBodyContent } from "./text-ops.js";
+import { normalizeText, textProblem } from "./text-write.js";
+/*
+ * Pictures and tables: a picture is a media part related from the slide
+ * and a p:pic that embeds it; a table is a p:graphicFrame holding a:tbl
+ * with a grid, rows of equal height and one paragraph per cell; a cell's
+ * text is replaced like a shape's.
+ */
+const MEDIA_FOLDER = "/ppt/media";
+const TABLE_URI = "http://schemas.openxmlformats.org/drawingml/2006/table";
+function checkSlide(pageIndex, context, issue) {
+    if (pageIndex < 0 || pageIndex >= context.pageCount) {
+        issue("/pageIndex", "unknown-target", `No slide ${pageIndex}`);
+        return false;
+    }
+    return true;
+}
+export const insertImageHandler = {
+    async validate(operation, context, issue) {
+        checkSlide(operation.pageIndex, context, issue);
+        try {
+            const bytes = resolveBinary(operation.data, context.assets);
+            if (bytes.length === 0)
+                issue("/data", "invalid-value", "The image has no bytes");
+            else if (!matchesMime(bytes, operation.mimeType))
+                issue("/data", "invalid-value", `The bytes are not a ${operation.mimeType} image`);
+        }
+        catch {
+            issue("/data", "unknown-asset", "The asset is not known to the session");
+        }
+    },
+    async apply(operation, context) {
+        const elements = await context.elements(operation.pageIndex);
+        const { part, slide } = elements;
+        const tree = part.find("spTree");
+        const id = context.allocateShapeId(elements);
+        const bytes = resolveBinary(operation.data, context.assets);
+        const transaction = context.pkg.transaction();
+        // The same bytes already in the package are related, not stored again.
+        const existing = await existingMedia(context, bytes, operation.mimeType);
+        const rId = existing
+            ? await transaction.addRelationship(slide.part, RELATIONSHIP_TYPES.image, relativeTarget(slide.part, existing))
+            : (await transaction.addMedia(slide.part, MEDIA_FOLDER, bytes, operation.mimeType)).rId;
+        const { rect } = operation;
+        const xml = `<p:pic><p:nvPicPr><p:cNvPr id="${id}" name="Picture ${id - 1}"/><p:cNvPicPr><a:picLocks noChangeAspect="1"/></p:cNvPicPr><p:nvPr/></p:nvPicPr>` +
+            `<p:blipFill><a:blip r:embed="${rId}"/><a:stretch><a:fillRect/></a:stretch></p:blipFill>` +
+            `<p:spPr><a:xfrm><a:off x="${pxToEmu(rect.x)}" y="${pxToEmu(rect.y)}"/><a:ext cx="${pxToEmu(rect.width)}" cy="${pxToEmu(rect.height)}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr></p:pic>`;
+        transaction.patch(part, [patches.appendChild(part, tree, xml)]);
+        const change = await transaction.commit();
+        return {
+            createdIds: [`${slide.key}:${id}`],
+            changedPages: [operation.pageIndex],
+            warnings: change.warnings,
+            parts: committedParts(change),
+        };
+    },
+};
+/** A media part of the package with these bytes and this type's extension, if any. */
+async function existingMedia(context, bytes, mimeType) {
+    const extension = `.${extensionForMime(mimeType)}`;
+    for (const name of context.pkg.currentPartNames) {
+        if (!name.startsWith(`${MEDIA_FOLDER}/`) || !name.endsWith(extension))
+            continue;
+        const entry = context.pkg.entry(name);
+        if (entry && entry.uncompressedSize !== bytes.length)
+            continue;
+        const candidate = await context.pkg.part(name);
+        if (candidate.length !== bytes.length)
+            continue;
+        let same = true;
+        for (let index = 0; index < bytes.length; index += 1)
+            if (candidate[index] !== bytes[index]) {
+                same = false;
+                break;
+            }
+        if (same)
+            return name;
+    }
+    return undefined;
+}
+/** Whether the bytes carry the signature of the declared image type. */
+function matchesMime(bytes, mimeType) {
+    if (mimeType === "image/png")
+        return (bytes.length >= 8 &&
+            bytes[0] === 0x89 &&
+            bytes[1] === 0x50 &&
+            bytes[2] === 0x4e &&
+            bytes[3] === 0x47);
+    return (bytes.length >= 3 &&
+        bytes[0] === 0xff &&
+        bytes[1] === 0xd8 &&
+        bytes[2] === 0xff);
+}
+/** The default table style id the deck names, when it has a style list. */
+async function defaultTableStyle(context) {
+    const name = "/ppt/tableStyles.xml";
+    if (!context.pkg.has(name))
+        return undefined;
+    const part = await context.pkg.xml(name);
+    return part.attribute(part.root, "def");
+}
+export const insertTableHandler = {
+    async validate(operation, context, issue) {
+        checkSlide(operation.pageIndex, 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", `Expected ${columns} column weights`);
+        operation.rows.forEach((row, rowIndex) => row.forEach((cell, columnIndex) => {
+            const problem = textProblem(normalizeText(cell));
+            if (problem)
+                issue(`/rows/${rowIndex}/${columnIndex}`, "invalid-text", `The text holds ${problem}`);
+        }));
+    },
+    async apply(operation, context) {
+        const elements = await context.elements(operation.pageIndex);
+        const { part, slide } = elements;
+        const tree = part.find("spTree");
+        const id = context.allocateShapeId(elements);
+        const { rect, rows } = operation;
+        const columns = rows[0].length;
+        const weights = operation.columnWidths ?? Array.from({ length: columns }, () => 1);
+        const total = weights.reduce((sum, weight) => sum + weight, 0);
+        const width = pxToEmu(rect.width);
+        const gridWidths = [];
+        let used = 0;
+        weights.forEach((weight, index) => {
+            const value = index === weights.length - 1
+                ? width - used
+                : Math.round((width * weight) / total);
+            gridWidths.push(value);
+            used += value;
+        });
+        const height = pxToEmu(rect.height);
+        const rowHeights = rows.map((_, index) => index === rows.length - 1
+            ? height - Math.round(height / rows.length) * (rows.length - 1)
+            : Math.round(height / rows.length));
+        const style = operation.style ?? {};
+        const styleId = await defaultTableStyle(context);
+        const tblPr = `<a:tblPr firstRow="${style.firstRow === false ? 0 : 1}" bandRow="${style.bandRow === false ? 0 : 1}"${styleId
+            ? `><a:tableStyleId>${escapeText(styleId)}</a:tableStyleId></a:tblPr>`
+            : "/>"}`;
+        const grid = `<a:tblGrid>${gridWidths.map((w) => `<a:gridCol w="${w}"/>`).join("")}</a:tblGrid>`;
+        const body = rows
+            .map((row, rowIndex) => `<a:tr h="${rowHeights[rowIndex]}">${row
+            .map((cell) => `<a:tc><a:txBody><a:bodyPr/><a:lstStyle/>${paragraphsXml(part, normalizeText(cell), undefined)}</a:txBody><a:tcPr/></a:tc>`)
+            .join("")}</a:tr>`)
+            .join("");
+        const xml = `<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id="${id}" name="Table ${id - 1}"/><p:cNvGraphicFramePr><a:graphicFrameLocks noGrp="1"/></p:cNvGraphicFramePr><p:nvPr/></p:nvGraphicFramePr>` +
+            `<p:xfrm><a:off x="${pxToEmu(rect.x)}" y="${pxToEmu(rect.y)}"/><a:ext cx="${width}" cy="${height}"/></p:xfrm>` +
+            `<a:graphic><a:graphicData uri="${TABLE_URI}"><a:tbl>${tblPr}${grid}${body}</a:tbl></a:graphicData></a:graphic></p:graphicFrame>`;
+        const transaction = context.pkg.transaction();
+        transaction.patch(part, [patches.appendChild(part, tree, xml)]);
+        const change = await transaction.commit();
+        return {
+            createdIds: [`${slide.key}:${id}`],
+            changedPages: [operation.pageIndex],
+            warnings: change.warnings,
+            parts: committedParts(change),
+        };
+    },
+};
+async function cellTarget(operation, context, issue) {
+    const record = await context.locate(operation.target);
+    if (!record) {
+        issue("/target", "unknown-target", `No element ${operation.target}`);
+        return undefined;
+    }
+    const tbl = record.part.find("tbl", record.node);
+    if (record.readOnly || record.element.kind !== "table" || !tbl) {
+        issue("/target", "invalid-target", `Element ${operation.target} is not an editable table`);
+        return undefined;
+    }
+    const rows = tbl.children.filter((child) => child.local === "tr");
+    const row = rows[operation.row];
+    const cell = row?.children.filter((child) => child.local === "tc")[operation.column];
+    if (!row) {
+        issue("/row", "range", `The table has ${rows.length} rows`);
+        return undefined;
+    }
+    if (!cell) {
+        issue("/column", "range", `Row ${operation.row} has ${row.children.filter((child) => child.local === "tc").length} cells`);
+        return undefined;
+    }
+    return { record, part: record.part, cell };
+}
+export const setTableCellHandler = {
+    async validate(operation, context, issue) {
+        const problem = textProblem(normalizeText(operation.text));
+        if (problem)
+            issue("/text", "invalid-text", `The text holds ${problem}`);
+        await cellTarget(operation, context, issue);
+    },
+    async apply(operation, context) {
+        const { record, part, cell } = (await cellTarget(operation, context, () => { }));
+        const txBody = cell.children.find((child) => child.local === "txBody");
+        const transaction = context.pkg.transaction();
+        if (txBody) {
+            const model = readTextModel(part, txBody);
+            transaction.patch(part, [
+                patches.replaceContent(part, txBody, replacedBodyContent(part, txBody, model, normalizeText(operation.text), 0, model.text.length, true)),
+            ]);
+        }
+        else {
+            const xml = `<a:txBody><a:bodyPr/><a:lstStyle/>${paragraphsXml(part, normalizeText(operation.text), undefined)}</a:txBody>`;
+            const tcPr = cell.children.find((child) => child.local === "tcPr");
+            transaction.patch(part, [
+                tcPr
+                    ? patches.insertBefore(part, tcPr, xml)
+                    : patches.appendChild(part, cell, xml),
+            ]);
+        }
+        const change = await transaction.commit();
+        const result = {
+            createdIds: [],
+            changedPages: [record.element.pageIndex],
+            warnings: change.warnings,
+            parts: committedParts(change),
+        };
+        return result;
+    },
+};

package/dist/edit/pptx/model.d.ts

@@ -0,0 +1,69 @@
+import type { OoxmlPackage } from "../ooxml/package.js";
+import type { XmlElement, XmlPart } from "../ooxml/xml.js";
+export declare const PRESENTATION_NS = "http://schemas.openxmlformats.org/presentationml/2006/main";
+export declare const RELATIONSHIP_TYPES: {
+    readonly officeDocument: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+    readonly slide: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
+    readonly slideLayout: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+    readonly slideMaster: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+    readonly notesSlide: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+    readonly theme: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+    readonly image: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+};
+export interface MasterRecord {
+    /** "master1", from the part's number. */
+    readonly id: string;
+    readonly part: string;
+    readonly theme?: string;
+    readonly layouts: readonly string[];
+}
+export interface LayoutRecord {
+    /** "layout2", from the part's number. */
+    readonly id: string;
+    readonly part: string;
+    readonly name: string;
+    readonly type?: string;
+    readonly master: MasterRecord;
+}
+export interface SlideRecord {
+    /** "sld3", from the part's number; the slide key of element ids. */
+    readonly key: string;
+    readonly number: number;
+    readonly part: string;
+    /** `p:sldId/@id`. */
+    readonly id: string;
+    /** The presentation relationship that names the part. */
+    readonly rId: string;
+    readonly node: XmlElement;
+    readonly layout?: LayoutRecord;
+}
+export interface ThemeFonts {
+    readonly major: string;
+    readonly minor: string;
+}
+/** The number in a part name like `/ppt/slides/slide12.xml`. */
+export declare function partNumber(part: string): number;
+export declare class DeckModel {
+    #private;
+    readonly revision: number;
+    readonly presentationPart: string;
+    readonly presentation: XmlPart;
+    /** EMU. */
+    readonly slideSize: {
+        readonly cx: number;
+        readonly cy: number;
+    };
+    readonly slides: readonly SlideRecord[];
+    readonly layouts: readonly LayoutRecord[];
+    readonly masters: readonly MasterRecord[];
+    private constructor();
+    static load(pkg: OoxmlPackage, signal?: AbortSignal): Promise<DeckModel>;
+    get pageCount(): number;
+    slideAt(pageIndex: number): SlideRecord;
+    slideByKey(key: string): SlideRecord | undefined;
+    layoutById(id: string): LayoutRecord | undefined;
+    /** Whether a slide is hidden (`p:sld/@show="0"`). */
+    hidden(slide: SlideRecord, signal?: AbortSignal): Promise<boolean>;
+    /** The major and minor Latin faces of a master's theme. */
+    themeFonts(master: MasterRecord | undefined): Promise<ThemeFonts>;
+}