web-doc 0.6.2 → 0.7.0

package/dist/edit/pdf/session.js

@@ -0,0 +1,273 @@
+import { ViewerError } from "../../errors.js";
+import { reportError } from "../session.js";
+import { rectContains } from "./engine/geometry.js";
+import { mapRangeThrough } from "./range-map.js";
+import { resolveSelection } from "./selection.js";
+/**
+ * The PDF session: the core session narrowed to PDF operations and elements.
+ * Typed methods are added here as their operations ship; each is `apply()`
+ * with a single operation.
+ */
+export class PdfSession {
+    format = "pdf";
+    #core;
+    /** Committed calls, oldest first, for `mapRange`; bounded by `LOG_LIMIT`. */
+    #log = [];
+    /** Batches applied and not undone, and those undone and not redone. */
+    #applied = [];
+    #undone = [];
+    /** The last elements read per page, with the revision they describe. */
+    #geometry = new Map();
+    constructor(core) {
+        this.#core = core;
+    }
+    get sessionId() {
+        return this.#core.sessionId;
+    }
+    get state() {
+        return this.#core.state;
+    }
+    get schemas() {
+        return this.#core.schemas;
+    }
+    async apply(operations, options) {
+        const receipt = await this.#core.apply(operations, options);
+        this.#record("apply", operations, receipt);
+        return receipt;
+    }
+    async applyJson(operations, options) {
+        const receipt = await this.#core.applyJson(operations, options);
+        this.#record("apply", operations, receipt);
+        return receipt;
+    }
+    async undo(options) {
+        const receipt = await this.#core.undo(options);
+        this.#record("undo", [], receipt);
+        return receipt;
+    }
+    async redo(options) {
+        const receipt = await this.#core.redo(options);
+        this.#record("redo", [], receipt);
+        return receipt;
+    }
+    async reset(options) {
+        const receipt = await this.#core.reset(options);
+        this.#record("reset", [], receipt);
+        return receipt;
+    }
+    /** Keeps the mutation log in step with the core after a committed call. */
+    #record(kind, operations, receipt) {
+        const last = this.#log.at(-1)?.revision ?? 0;
+        // A dry run or a no-op leaves the revision alone and changes nothing.
+        if (receipt.dryRun || receipt.revision === last)
+            return;
+        this.#refreshGeometry(receipt);
+        let involved = operations;
+        switch (kind) {
+            case "apply":
+                this.#applied.push(operations);
+                this.#undone = [];
+                break;
+            case "undo":
+                involved = this.#applied.pop() ?? [];
+                this.#undone.push(involved);
+                break;
+            case "redo":
+                involved = this.#undone.pop() ?? [];
+                this.#applied.push(involved);
+                break;
+            case "reset":
+                involved = this.#applied.flat();
+                this.#applied = [];
+                this.#undone = [];
+                break;
+        }
+        this.#log.push({
+            revision: receipt.revision,
+            kind,
+            operations: involved,
+            receipt,
+        });
+        if (this.#log.length > LOG_LIMIT)
+            this.#log.splice(0, 1);
+    }
+    save(options) {
+        return this.#core.save(options);
+    }
+    markSaved(stateToken) {
+        this.#core.markSaved(stateToken);
+    }
+    addAsset(data, options) {
+        return this.#core.addAsset(data, options);
+    }
+    async getElements(query, options) {
+        const result = (await this.#core.getElements(query, options));
+        // A whole page's elements feed the geometry cache.
+        if (query?.pageIndex !== undefined &&
+            query.kinds === undefined &&
+            query.intersects === undefined)
+            this.#remember(query.pageIndex, result);
+        return result;
+    }
+    elementsAtSync(pageIndex, point) {
+        const cached = this.#geometry.get(pageIndex);
+        return Object.freeze({
+            sessionId: this.sessionId,
+            revision: cached?.revision ?? this.state.revision,
+            items: Object.freeze((cached?.elements ?? [])
+                .filter((element) => rectContains(element.bounds, point))
+                .reverse()),
+        });
+    }
+    get cachedPages() {
+        return [...this.#geometry.keys()].sort((a, b) => a - b);
+    }
+    #remember(pageIndex, result) {
+        const cached = this.#geometry.get(pageIndex);
+        if (cached && cached.revision > result.revision)
+            return;
+        this.#geometry.set(pageIndex, {
+            revision: result.revision,
+            elements: result.items,
+        });
+    }
+    /**
+     * After a committed change the changed pages' entries are stale: they are
+     * dropped and, while the page still exists, read again in the background
+     * so the next hover answers from the new revision.
+     */
+    #refreshGeometry(receipt) {
+        for (const pageIndex of [...this.#geometry.keys()]) {
+            const changed = pageIndex >= receipt.pageCount ||
+                receipt.changedPages.includes(pageIndex);
+            if (!changed)
+                continue;
+            this.#geometry.delete(pageIndex);
+            if (pageIndex < receipt.pageCount)
+                this.getElements({ pageIndex }).catch(reportError);
+        }
+    }
+    getElement(id, options) {
+        return this.#core.getElement(id, options);
+    }
+    elementsAt(pageIndex, point, options) {
+        return this.#core.elementsAt(pageIndex, point, options);
+    }
+    findText(query, options) {
+        return this.#core.findText(query, options);
+    }
+    getTextLayout(elementId, options) {
+        return this.#core.readItem(options, (engine, signal) => pdfReads(engine).textLayout(elementId, signal));
+    }
+    positionAt(pageIndex, point, options) {
+        return this.#core.readItem(options, (engine, signal) => pdfReads(engine).positionAt(pageIndex, point, signal));
+    }
+    rangeRects(range, options) {
+        return this.#core.readItems(options, (engine, signal) => pdfReads(engine).rangeRects(range, signal));
+    }
+    getPageLayout(pageIndex, options) {
+        return this.#core.readItem(options, (engine, signal) => pdfReads(engine).pageLayout(pageIndex, signal));
+    }
+    elementsForSelection(selection, options) {
+        return this.#core.readItems(options, async (engine, signal) => {
+            const first = selection.pageIndex;
+            const last = selection.endPageIndex ?? first;
+            const pages = [];
+            for (let pageIndex = first; pageIndex <= last; pageIndex += 1) {
+                const layout = await pdfReads(engine).pageLayout(pageIndex, signal);
+                if (layout)
+                    pages.push(layout);
+            }
+            return resolveSelection(selection, pages);
+        });
+    }
+    mapRange(range, fromRevision, options) {
+        // Queued like any read, so every call committed before it is in the log.
+        return this.#core.readItem(options, async (engine, signal) => {
+            const current = this.state.revision;
+            if (fromRevision > current || fromRevision < 0)
+                return undefined;
+            const records = this.#log.filter((record) => record.revision > fromRevision);
+            // A gap means the log no longer reaches back that far.
+            if (records.length !== current - fromRevision)
+                return undefined;
+            const mapped = mapRangeThrough(range, records);
+            if (!mapped)
+                return undefined;
+            // The element as it is now bounds the offsets; a missing one ends it.
+            const clamp = async (position) => {
+                const element = engine.getElement
+                    ? await engine.getElement(position.elementId, signal)
+                    : (await engine.getElements({}, signal)).find((entry) => entry.id === position.elementId);
+                if (!element)
+                    return undefined;
+                const length = element.text?.length ?? 0;
+                return { ...position, offset: Math.min(position.offset, length) };
+            };
+            const start = await clamp(mapped.start);
+            const end = await clamp(mapped.end);
+            return start && end ? { start, end } : undefined;
+        });
+    }
+    renderPageWithout(pageIndex, elementIds, options = {}) {
+        return this.#core.readItem(options, (engine, signal) => pdfReads(engine).renderWithout(pageIndex, [...elementIds], options.scale ?? 1, signal));
+    }
+    insertTextBox(fields, options) {
+        return this.apply([{ op: "insertTextBox", ...fields }], options);
+    }
+    replaceText(fields, options) {
+        return this.apply([{ op: "replaceText", ...fields }], options);
+    }
+    setTextStyle(fields, options) {
+        return this.apply([{ op: "setTextStyle", ...fields }], options);
+    }
+    resizeElement(fields, options) {
+        return this.apply([{ op: "resizeElement", ...fields }], options);
+    }
+    moveElement(fields, options) {
+        return this.apply([{ op: "moveElement", ...fields }], options);
+    }
+    deleteElement(fields, options) {
+        return this.apply([{ op: "deleteElement", ...fields }], options);
+    }
+    insertPage(fields, options) {
+        return this.apply([{ op: "insertPage", ...fields }], options);
+    }
+    deletePage(fields, options) {
+        return this.apply([{ op: "deletePage", ...fields }], options);
+    }
+    movePage(fields, options) {
+        return this.apply([{ op: "movePage", ...fields }], options);
+    }
+    rotatePage(fields, options) {
+        return this.apply([{ op: "rotatePage", ...fields }], options);
+    }
+    insertShape(fields, options) {
+        return this.apply([{ op: "insertShape", ...fields }], options);
+    }
+    setShapeStyle(fields, options) {
+        return this.apply([{ op: "setShapeStyle", ...fields }], options);
+    }
+    insertImage(fields, options) {
+        return this.apply([{ op: "insertImage", ...fields }], options);
+    }
+    insertTable(fields, options) {
+        return this.apply([{ op: "insertTable", ...fields }], options);
+    }
+    setTableCell(fields, options) {
+        return this.apply([{ op: "setTableCell", ...fields }], options);
+    }
+}
+/** How many committed calls `mapRange` can look back over. */
+const LOG_LIMIT = 512;
+/** The engine behind a PDF session answers the overlay reads; a stand-in may not. */
+function pdfReads(engine) {
+    const reads = engine;
+    if (!reads.textLayout ||
+        !reads.positionAt ||
+        !reads.rangeRects ||
+        !reads.renderWithout ||
+        !reads.pageLayout)
+        throw new ViewerError("edit-unsupported", "This engine does not implement the PDF overlay primitives", { details: { format: "pdf", reason: "no-overlay-primitives" } });
+    return reads;
+}

package/dist/edit/pdf/types.d.ts

@@ -0,0 +1,336 @@
+import type { TextSelection } from "../../contracts.js";
+import type { ApplyOptions, BinaryData, EditElement, EditReceipt, EditSessionBase, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextPosition, TextRange } from "../types.js";
+export type PdfElementKind = "text" | "image" | "shape" | "textBox" | "table" | "other";
+export type PdfTextAlign = "left" | "center" | "right";
+export interface PdfTextStyle {
+    readonly fontFamily: string;
+    /** Points. */
+    readonly fontSize: number;
+    readonly bold: boolean;
+    readonly italic: boolean;
+    /** `#RRGGBB`. */
+    readonly color: string;
+    /** Text boxes only. */
+    readonly align?: PdfTextAlign;
+    /** Text boxes only; a multiple of the font size. */
+    readonly lineHeight?: number;
+}
+export interface PdfShapeStyle {
+    readonly stroke?: {
+        readonly color: string;
+        readonly width: number;
+    };
+    readonly fill?: {
+        readonly color: string;
+    };
+}
+export interface PdfElement extends EditElement {
+    readonly kind: PdfElementKind;
+    /** Present for `text` and `textBox`. */
+    readonly textStyle?: PdfTextStyle;
+    /** Present for `shape` and `table`. */
+    readonly shapeStyle?: PdfShapeStyle;
+    /** Present for `table`. */
+    readonly table?: {
+        readonly rows: readonly (readonly string[])[];
+    };
+}
+export interface PdfTextBoxStyle {
+    /** "Helvetica" (default), "Times" or "Courier"; registered families follow. */
+    readonly fontFamily?: string;
+    /** 1–500 points, default 12. */
+    readonly fontSize?: number;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    /** `#RRGGBB`, default "#000000". */
+    readonly color?: string;
+    readonly align?: PdfTextAlign;
+    /** Multiple of the font size, 0.5–5, default 1.2. */
+    readonly lineHeight?: number;
+}
+export interface InsertTextBoxOperation {
+    readonly op: "insertTextBox";
+    readonly pageIndex: number;
+    readonly rect: PageRect;
+    readonly text: string;
+    readonly style?: PdfTextBoxStyle;
+}
+export interface ReplaceTextOperation {
+    readonly op: "replaceText";
+    /** A `textBox` or `text` element. */
+    readonly target: string;
+    readonly text: string;
+    /**
+     * The part of the target's text to replace, both ends on the target;
+     * absent, the whole text. A text object is split around the range only
+     * when its font cannot draw the new text; the parts keep their font, size,
+     * colour and baseline and the first part keeps the id.
+     */
+    readonly range?: TextRange;
+}
+export interface SetTextStyleOperation {
+    readonly op: "setTextStyle";
+    /** A `textBox` or `text` element. */
+    readonly target: string;
+    readonly style: PdfTextBoxStyle;
+}
+export interface ResizeElementOperation {
+    readonly op: "resizeElement";
+    readonly target: string;
+    /** New bounds in page space; a text box is laid out again inside them. */
+    readonly rect: PageRect;
+}
+export interface MoveElementOperation {
+    readonly op: "moveElement";
+    readonly target: string;
+    /** New top-left corner of the element's bounds, in page space. */
+    readonly to?: PagePoint;
+    /** Offset in page space. Exactly one of `to` and `by` is given. */
+    readonly by?: {
+        readonly dx: number;
+        readonly dy: number;
+    };
+}
+export interface DeleteElementOperation {
+    readonly op: "deleteElement";
+    readonly target: string;
+}
+export interface InsertPageOperation {
+    readonly op: "insertPage";
+    /** Position of the new page, 0 to the current page count. */
+    readonly index: number;
+    /** Points; defaults to the size of the page before, else after, the position. */
+    readonly size?: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+export interface DeletePageOperation {
+    readonly op: "deletePage";
+    readonly pageIndex: number;
+}
+export interface MovePageOperation {
+    readonly op: "movePage";
+    readonly from: number;
+    /** The page's index after the move. */
+    readonly to: number;
+}
+export interface PdfStroke {
+    readonly color: string;
+    /** Points; 0 draws the thinnest line the device can. */
+    readonly width: number;
+}
+export interface PdfFill {
+    readonly color: string;
+}
+export type InsertShapeOperation = {
+    readonly op: "insertShape";
+    readonly pageIndex: number;
+    readonly shape: "rectangle" | "ellipse";
+    readonly rect: PageRect;
+    readonly stroke?: PdfStroke;
+    readonly fill?: PdfFill;
+} | {
+    readonly op: "insertShape";
+    readonly pageIndex: number;
+    readonly shape: "line";
+    readonly from: PagePoint;
+    readonly to: PagePoint;
+    readonly stroke?: PdfStroke;
+};
+export interface InsertImageOperation {
+    readonly op: "insertImage";
+    readonly pageIndex: number;
+    readonly rect: PageRect;
+    /** PNG or JPEG bytes; base64 over pure-JSON transports. */
+    readonly data: BinaryData;
+    readonly mimeType: "image/png" | "image/jpeg";
+}
+export interface PdfTableStyle {
+    /** "Helvetica" (default), "Times", "Courier" or a registered family. */
+    readonly fontFamily?: string;
+    /** 1–500 points, default 10. */
+    readonly fontSize?: number;
+    /** Text colour, `#RRGGBB`, default "#000000". */
+    readonly color?: string;
+    /** Grid colour, default "#000000". */
+    readonly borderColor?: string;
+    /** Grid stroke in points, 0–20, default 0.75. */
+    readonly borderWidth?: number;
+    /** Space between a cell's edges and its text, 0–100, default 4. */
+    readonly cellPadding?: number;
+    /** Fill of the first row; none by default. */
+    readonly headerFill?: string;
+}
+export interface InsertTableOperation {
+    readonly op: "insertTable";
+    readonly pageIndex: number;
+    /** Top-left corner in page space. */
+    readonly at: PagePoint;
+    /** Total width in points; the height follows the wrapped cell text. */
+    readonly width: number;
+    /** Cell text by row; every row has the same number of cells. 1–100 rows, 1–20 columns. */
+    readonly rows: readonly (readonly string[])[];
+    /** Relative column weights, one per column; equal when omitted. */
+    readonly columnWidths?: readonly number[];
+    readonly style?: PdfTableStyle;
+}
+export interface SetTableCellOperation {
+    readonly op: "setTableCell";
+    /** A `table` element. */
+    readonly target: string;
+    readonly row: number;
+    readonly column: number;
+    /** The cell's new text; empty clears the cell. */
+    readonly text: string;
+}
+export interface SetShapeStyleOperation {
+    readonly op: "setShapeStyle";
+    readonly target: string;
+    /** A new stroke, `null` to remove it, or absent to keep it. */
+    readonly stroke?: PdfStroke | null;
+    /** A new fill, `null` to remove it, or absent to keep it. */
+    readonly fill?: PdfFill | null;
+}
+export interface RotatePageOperation {
+    readonly op: "rotatePage";
+    readonly pageIndex: number;
+    /** Absolute clockwise rotation in degrees. */
+    readonly rotation: 0 | 90 | 180 | 270;
+}
+/** The PDF operation union; operations are added as they ship. */
+export type PdfOperation = InsertTextBoxOperation | ReplaceTextOperation | SetTextStyleOperation | ResizeElementOperation | MoveElementOperation | DeleteElementOperation | InsertPageOperation | DeletePageOperation | MovePageOperation | RotatePageOperation | InsertShapeOperation | SetShapeStyleOperation | InsertImageOperation | InsertTableOperation | SetTableCellOperation;
+export interface PdfSaveOptions extends SaveOptions {
+    /**
+     * `full` rewrites the file, so deleted content is gone and the bytes do not
+     * depend on which pages were read; `incremental` appends to the original
+     * bytes and keeps earlier signed revisions intact. The default is `full`
+     * for a document without signature fields and `incremental` for a signed one.
+     */
+    readonly mode?: "full" | "incremental";
+}
+/** One drawn character of a layout line. */
+export interface TextLayoutGlyph {
+    /** Offset of the character in `EditElement.text`. */
+    readonly offset: number;
+    /** Tight box of the glyph in page space; a space takes its advance box. */
+    readonly box: PageRect;
+    /** Advance width along the baseline, in points. */
+    readonly advance: number;
+}
+/** One line of a text element: one PDFium text object, as the file stores it. */
+export interface TextLayoutLine {
+    /** The part of the element's text the line draws, half-open. */
+    readonly range: TextRange;
+    readonly text: string;
+    /** Union of the glyph boxes, in page space. */
+    readonly bounds: PageRect;
+    /** Start of the baseline, in page space. */
+    readonly baseline: PagePoint;
+    readonly glyphs: readonly TextLayoutGlyph[];
+    readonly fontFamily: string;
+    readonly fontSize: number;
+    readonly color: string;
+}
+/** The drawn geometry of a `text`, `textBox` or `table` element. */
+export interface TextLayout {
+    readonly elementId: string;
+    readonly pageIndex: number;
+    /** Lines in reading order: a text box's lines, a table's cells. */
+    readonly lines: readonly TextLayoutLine[];
+}
+/** Every text element of a page with its layout, plus the page's displayed size in points. */
+export interface PageLayout {
+    readonly pageIndex: number;
+    readonly width: number;
+    readonly height: number;
+    /** In reading order. */
+    readonly layouts: readonly TextLayout[];
+}
+/** A page rendered by PDFium in the worker: RGBA pixels, row-major, unpremultiplied over white. */
+export interface PageBitmap {
+    readonly pageIndex: number;
+    /** Device pixels per point the page was rendered at. */
+    readonly scale: number;
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+}
+export interface RenderOptions extends ReadOptions {
+    /** Device pixels per point, default 1; bounded by `maxDecodedPixels`. */
+    readonly scale?: number;
+}
+/**
+ * An operation's fields without its `op`, as the typed methods take them.
+ * Distributes over unions so `insertShape` keeps its per-shape fields.
+ */
+export type Fields<T extends PdfOperation> = T extends unknown ? Omit<T, "op"> : never;
+export interface PdfEditSession extends EditSessionBase<PdfOperation, PdfElement> {
+    readonly format: "pdf";
+    save(options?: PdfSaveOptions): Promise<SavedDocument>;
+    /** Lines, glyph boxes and styles of a `text`, `textBox` or `table` element. */
+    getTextLayout(elementId: string, options?: ReadOptions): Promise<ReadItem<TextLayout>>;
+    /** The text position nearest to a page-space point; none on a page without text. */
+    positionAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadItem<TextPosition>>;
+    /** The rectangles a range covers, one per line fragment, in reading order. */
+    rangeRects(range: TextRange, options?: ReadOptions): Promise<ReadResult<PageRect>>;
+    /**
+     * The page rendered by PDFium with the listed elements left out, so a host's
+     * input surface can stand in for them on screen. Nothing is reopened and the
+     * session's bytes stay as they are; unknown ids are ignored.
+     */
+    renderPageWithout(pageIndex: number, elementIds: readonly string[], options?: RenderOptions): Promise<ReadItem<PageBitmap>>;
+    /** The layouts of every text element on a page, in one read. */
+    getPageLayout(pageIndex: number, options?: ReadOptions): Promise<ReadItem<PageLayout>>;
+    /**
+     * Maps the viewer's text selection (PDF.js runs in page space) to elements
+     * and ranges: a line whose box the run covers by half, else the one line
+     * that contains the run, else a line whose folded text contains the run's.
+     */
+    elementsForSelection(selection: TextSelection, options?: ReadOptions): Promise<ReadResult<TextRange>>;
+    /**
+     * Elements under a point from the session's main-thread geometry cache,
+     * without waiting: the last `getElements({ pageIndex })` result of the
+     * page, refreshed after every committed change. A page never read answers
+     * no items; `cachedPages` says which pages answer.
+     */
+    elementsAtSync(pageIndex: number, point: PagePoint): ReadResult<PdfElement>;
+    /** Pages whose geometry the cache holds. */
+    readonly cachedPages: readonly number[];
+    /**
+     * Where a range taken at `fromRevision` is now, after the batches, undos,
+     * redos and resets of this session since then; none when its element is
+     * gone or the revision is older than the session remembers.
+     */
+    mapRange(range: TextRange, fromRevision: number, options?: ReadOptions): Promise<ReadItem<TextRange>>;
+    /** Lays `text` out inside `rect` as new text objects; the box's id is in `createdIds`. */
+    insertTextBox(fields: Fields<InsertTextBoxOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Replaces the text of a text box (laid out again) or of a text object. */
+    replaceText(fields: Fields<ReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Changes style fields; unspecified fields keep their value. */
+    setTextStyle(fields: Fields<SetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Gives an element new bounds; text boxes reflow, other elements stretch. */
+    resizeElement(fields: Fields<ResizeElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Moves an element to a point or by an offset, in page space. */
+    moveElement(fields: Fields<MoveElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Removes an element and, for a group, every object in it. */
+    deleteElement(fields: Fields<DeleteElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Adds a blank page. */
+    insertPage(fields: Fields<InsertPageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Removes a page; the last page cannot be removed. */
+    deletePage(fields: Fields<DeletePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Reorders pages. */
+    movePage(fields: Fields<MovePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Sets a page's rotation. */
+    rotatePage(fields: Fields<RotatePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Draws a rectangle, ellipse or line as a path object. */
+    insertShape(fields: Fields<InsertShapeOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Changes or removes a shape's stroke and fill. */
+    setShapeStyle(fields: Fields<SetShapeStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Places a PNG or JPEG inside `rect`; JPEG data is embedded as it is. */
+    insertImage(fields: Fields<InsertImageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Draws a grid with wrapped cell text; rows grow to fit their tallest cell. */
+    insertTable(fields: Fields<InsertTableOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Changes one cell's text and lays the table out again. */
+    setTableCell(fields: Fields<SetTableCellOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+}

package/dist/edit/pdf/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,74 @@
+import type { OoxmlPackage } from "../ooxml/package.js";
+import type { XmlElement, XmlPart } from "../ooxml/xml.js";
+import { type Matrix, type PlacedFrame, type Xfrm } from "./geometry.js";
+import type { DeckModel, SlideRecord } from "./model.js";
+import { type StyleSource } from "./style.js";
+import { type TextModel } from "./text.js";
+import type { PptxElement, PptxPlaceholder } from "./types.js";
+/** What the engine knows about one element beyond what it reports. */
+export interface ShapeRecord {
+    readonly element: PptxElement;
+    readonly slide: SlideRecord;
+    readonly part: XmlPart;
+    /** The element node in the slide part (`p:sp`, `p:pic`, …). */
+    readonly node: XmlElement;
+    readonly cNvPr: XmlElement;
+    readonly cNvPrId: number;
+    /** The element's own `a:xfrm` or `p:xfrm` node, when it has one. */
+    readonly xfrmNode?: XmlElement;
+    /** The frame in the element's own space (EMU), inherited when `inherited` is true. */
+    readonly xfrm?: Xfrm;
+    readonly inherited: boolean;
+    /** Transform from the element's space to slide space. */
+    readonly parents: Matrix;
+    readonly placed?: PlacedFrame;
+    readonly txBody?: XmlElement;
+    readonly spPr?: XmlElement;
+    readonly text?: TextModel;
+    /** Inside the fallback branch of `mc:AlternateContent`. */
+    readonly readOnly: boolean;
+    readonly parent?: ShapeRecord;
+}
+export interface SlideElements {
+    readonly slide: SlideRecord;
+    readonly pageIndex: number;
+    readonly part: XmlPart;
+    /** Document order, groups before their children. */
+    readonly records: readonly ShapeRecord[];
+    byId(id: string): ShapeRecord | undefined;
+}
+/** A placeholder of a layout or master, for inheritance. */
+export interface PlaceholderRecord {
+    readonly part: XmlPart;
+    readonly node: XmlElement;
+    readonly type: string;
+    readonly idx?: number;
+    readonly xfrm?: Xfrm;
+    readonly lstStyle?: XmlElement;
+}
+export interface PlaceholderTable {
+    readonly part: XmlPart;
+    readonly placeholders: readonly PlaceholderRecord[];
+    /** `p:txStyles` of a master. */
+    readonly txStyles?: XmlElement;
+}
+/** The placeholders of a layout or master part. */
+export declare function readPlaceholders(pkg: OoxmlPackage, partName: string, signal?: AbortSignal): Promise<PlaceholderTable>;
+export declare function placeholderOf(part: XmlPart, node: XmlElement): PptxPlaceholder | undefined;
+/** Placeholder types that share position and style: titles, and body-like content. */
+export declare function placeholderFamily(type: string): string;
+/** The placeholder a slide placeholder inherits from: same idx first, then the same family. */
+export declare function matchPlaceholder(table: PlaceholderTable | undefined, ph: PptxPlaceholder): PlaceholderRecord | undefined;
+export interface InheritanceSources {
+    layout?: PlaceholderTable;
+    master?: PlaceholderTable;
+    /** `p:defaultTextStyle` of the presentation. */
+    defaults?: StyleSource;
+}
+/** Reads every element of a slide. */
+export declare function readSlideElements(pkg: OoxmlPackage, model: DeckModel, slide: SlideRecord, pageIndex: number, sources: InheritanceSources, signal?: AbortSignal): Promise<SlideElements>;
+/** The list-style chain of a shape, in priority order. */
+export declare function listStylesOf(context: {
+    readonly part: XmlPart;
+    readonly sources: InheritanceSources;
+}, txBody: XmlElement, placeholder: PptxPlaceholder | undefined): StyleSource[];