web-doc 0.11.0 → 0.12.1

package/dist/adapters/pdf.js

@@ -90,14 +90,16 @@ class PdfJsBackend {
     #module;
     #document;
     #worker;
+    #workerPort;
     #loadingTask;
     #maxPixels;
     #pages = new Map();
     #closed = false;
-    constructor(module, document, worker, loadingTask, maxPixels) {
+    constructor(module, document, worker, workerPort, loadingTask, maxPixels) {
         this.#module = module;
         this.#document = document;
         this.#worker = worker;
+        this.#workerPort = workerPort;
         this.#loadingTask = loadingTask;
         this.#maxPixels = maxPixels;
         this.pageCount = document.numPages;
@@ -155,7 +157,7 @@ class PdfJsBackend {
             const document = await withTimeout(loadingTask.promise, context.limits.maxOperationMs, "PDF parsing");
             if (context.signal.aborted)
                 throw abortError();
-            return new PdfJsBackend(module, document, worker, loadingTask, context.limits.maxDecodedPixels);
+            return new PdfJsBackend(module, document, worker, workerPort, loadingTask, context.limits.maxDecodedPixels);
         }
         catch (error) {
             await loadingTask.destroy().catch(() => undefined);
@@ -168,9 +170,14 @@ class PdfJsBackend {
         }
     }
     async renderPage(target, pageIndex, zoom, devicePixelRatio, signal) {
-        this.#assertOpen();
-        const page = await this.#page(pageIndex);
-        if (signal?.aborted)
+        if (this.#closed || signal?.aborted)
+            throw abortError();
+        const page = await this.#page(pageIndex).catch((error) => {
+            if (this.#closed || signal?.aborted)
+                throw abortError();
+            throw error;
+        });
+        if (this.#closed || signal?.aborted)
             throw abortError();
         const viewport = page.getViewport({ scale: CSS_UNITS * zoom });
         const dpr = Math.max(1, devicePixelRatio);
@@ -200,11 +207,12 @@ class PdfJsBackend {
         signal?.addEventListener("abort", onAbort, { once: true });
         try {
             await renderTask.promise;
-            if (signal?.aborted)
+            if (this.#closed || signal?.aborted)
                 throw abortError();
         }
         catch (error) {
-            if (signal?.aborted ||
+            if (this.#closed ||
+                signal?.aborted ||
                 error instanceof this.#module.RenderingCancelledException ||
                 (error instanceof Error && error.name === "RenderingCancelledException"))
                 throw abortError();
@@ -251,11 +259,14 @@ class PdfJsBackend {
         this.#closed = true;
         this.#pages.clear();
         try {
-            await this.#document.cleanup();
+            // Destroy cancels and awaits active renders. PDF.js cleanup is only
+            // safe while idle, so it must not run before retiring this document.
             await this.#loadingTask.destroy();
         }
         finally {
             this.#worker.destroy();
+            // PDFWorker does not terminate an externally supplied port; we own it.
+            this.#workerPort.terminate();
         }
     }
     #page(pageIndex) {

package/dist/edit/engine.d.ts

@@ -1,6 +1,6 @@
 import type { DocumentFormat, RegisteredFont, ResourceLimits, TextRun, ViewerWarning } from "../contracts.js";
 import type { EditSession } from "./sessions.js";
-import type { ChangeMode, EditableFormat, EditElement, EditFindOptions, EditOperation, EditSessionBase, ElementQuery, OperationIssue, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, TextTarget } from "./types.js";
+import type { ChangeMode, EditableFormat, EditElement, EditFindOptions, EditOperation, EditSessionBase, ElementQuery, OperationIssue, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, TextTarget, TextAnchorMigration } from "./types.js";
 export interface EditEngineContext {
     readonly format: EditableFormat;
     readonly fileName?: string;
@@ -74,6 +74,7 @@ export interface EngineChange {
     readonly removedIds: readonly string[];
     /** Old id → new id, when the format had to rename an element. */
     readonly remappedIds?: Readonly<Record<string, string>>;
+    readonly textAnchorMigrations?: readonly TextAnchorMigration[];
     /** A superset of the pages whose content changed. */
     readonly changedPages: readonly number[];
     /**

package/dist/edit/pdf/engine/document.d.ts

@@ -1,6 +1,6 @@
 import type { EngineBatch, EngineChange, MaterializedDocument, RestoreTarget } from "../../engine.js";
 import type { EditFindOptions, EditOperation, ElementQuery, OperationIssue, PagePoint, PageRect, TextPosition, TextRange, TextTarget } from "../../types.js";
-import type { PageLayout, PdfElement, PdfOperation, TextFont, TextLayout } from "../types.js";
+import type { PageLayout, PdfElement, PdfOperation, PdfTextParagraph, TextFont, TextLayout } from "../types.js";
 import type { EditWorkerBitmap } from "../../../worker-protocol.js";
 import { FontLibrary } from "./fonts.js";
 import { ImageCache } from "./images.js";
@@ -76,7 +76,9 @@ export declare class PdfEditDocument {
     /** Elements under a point, top-most (drawn last) first. */
     elementsAt(pageIndex: number, point: PagePoint): PdfElement[];
     findText(query: string, options: EditFindOptions): TextTarget[];
-    /** Lines, glyph boxes and styles of a text, text box or table element. */
+    /** Resolves the canonical imported paragraph, when its rows can be grouped safely. */
+    textParagraph(elementId: string): PdfTextParagraph | undefined;
+    /** Lines, glyph boxes and styles of a text, text box, paragraph or table element. */
     textLayout(elementId: string): TextLayout | undefined;
     /** The browser face of the font a text or text box element is drawn in, see `TextFont`. */
     textFont(elementId: string): TextFont | undefined;

package/dist/edit/pdf/engine/document.js

@@ -7,6 +7,8 @@ import { textFaceOf } from "./text-font.js";
 import { fontRequestsOf } from "./text-box.js";
 import { issueCollector, } from "./operations.js";
 import { insertTextBox } from "./text-box.js";
+import { discoverParagraphs, paragraphElement, } from "./paragraph.js";
+import { replaceParagraphText } from "./paragraph-edit.js";
 import { replaceText, setTextStyle } from "./existing-text.js";
 import { deleteElement, moveElement, resizeElement } from "./transform.js";
 import { deletePage, insertPage, movePage, rotatePage } from "./pages.js";
@@ -90,6 +92,7 @@ function referenceOf(operation) {
     return typeof target === "string" ? parseReference(target) : undefined;
 }
 const handlers = {
+    replaceParagraphText: replaceParagraphText,
     insertTextBox: insertTextBox,
     replaceText: replaceText,
     setTextStyle: setTextStyle,
@@ -209,6 +212,7 @@ export class PdfEditDocument {
         const createdIds = [];
         const createdByOperation = [];
         const removedIds = [];
+        const textAnchorMigrations = [];
         const changedPages = new Set();
         const warnings = [];
         // The first change of a signed, certified, tagged or PDF/A file is the
@@ -230,6 +234,8 @@ export class PdfEditDocument {
             createdIds.push(...result.createdIds);
             createdByOperation[operationIndex] = [...result.createdIds];
             removedIds.push(...(result.removedIds ?? []));
+            for (const migration of result.textAnchorMigrations ?? [])
+                textAnchorMigrations.push({ ...migration, operationIndex });
             for (const pageIndex of result.changedPages)
                 changedPages.add(pageIndex);
             warnings.push(...result.warnings);
@@ -238,6 +244,7 @@ export class PdfEditDocument {
         return {
             createdIds,
             removedIds,
+            ...(textAnchorMigrations.length ? { textAnchorMigrations } : {}),
             changedPages: [...changedPages].sort((a, b) => a - b),
             pageCount: this.pageCount,
             warnings,
@@ -368,7 +375,13 @@ export class PdfEditDocument {
         const pageIndex = this.#pageIndexOf(id);
         if (pageIndex === undefined)
             return undefined;
-        return this.#elementsOf(pageIndex).find((element) => element.id === id);
+        const element = this.#elementsOf(pageIndex).find((element) => element.id === id);
+        if (element)
+            return element;
+        const target = this.#pages[pageIndex]?.paragraphs?.get(id);
+        return target?.paragraph.id === id
+            ? paragraphElement(target.paragraph)
+            : undefined;
     }
     /** Elements under a point, top-most (drawn last) first. */
     elementsAt(pageIndex, point) {
@@ -395,25 +408,60 @@ export class PdfEditDocument {
             });
         return targets;
     }
-    /** Lines, glyph boxes and styles of a text, text box or table element. */
+    /** Resolves the canonical imported paragraph, when its rows can be grouped safely. */
+    textParagraph(elementId) {
+        return this.#paragraphOf(elementId)?.paragraph;
+    }
+    #paragraphOf(id) {
+        const pageIndex = this.#pageIndexOf(id);
+        if (pageIndex === undefined)
+            return undefined;
+        this.#elementsOf(pageIndex);
+        return this.#pages[pageIndex]?.paragraphs?.get(id);
+    }
+    /** Lines, glyph boxes and styles of a text, text box, paragraph or table element. */
     textLayout(elementId) {
         const pageIndex = this.#pageIndexOf(elementId);
         if (pageIndex === undefined)
             return undefined;
-        return this.#scanText(pageIndex, (scan) => {
+        const paragraph = this.#paragraphOf(elementId);
+        return this.#scanText(pageIndex, (raw) => {
+            const scan = paragraph?.paragraph.id === elementId
+                ? this.#paragraphScan(raw, paragraph)
+                : raw;
             const element = scan.elements.find((entry) => entry.id === elementId);
-            return element ? layoutOf(this.#pdfium, scan, element) : undefined;
+            const layout = element
+                ? layoutOf(this.#pdfium, scan, element)
+                : undefined;
+            return layout && paragraph?.paragraph.id === elementId
+                ? {
+                    ...layout,
+                    lines: [...layout.lines]
+                        .sort((a, b) => a.range.start.offset - b.range.start.offset)
+                        .map((line) => ({
+                        ...line,
+                        fontSize: paragraph.paragraph.textStyle.fontSize,
+                    })),
+                }
+                : layout;
         });
     }
     /** The browser face of the font a text or text box element is drawn in, see `TextFont`. */
     textFont(elementId) {
         const location = this.#locate(elementId);
-        const element = location && this.getElement(elementId);
-        if (!element || (element.kind !== "text" && element.kind !== "textBox"))
+        if (!location)
+            return undefined;
+        // A paragraph not yet edited is not listed among the elements; its id
+        // still locates its rows.
+        const kind = this.getElement(elementId)?.kind ??
+            (this.#paragraphOf(elementId)?.paragraph.id === elementId
+                ? "paragraph"
+                : undefined);
+        if (kind !== "text" && kind !== "textBox" && kind !== "paragraph")
             return undefined;
         const { lib } = this.#pdfium;
         return this.#withPage(location.pageIndex, (page) => {
-            // A text box's lines share their font; its first line answers.
+            // A text box's lines and a paragraph's rows share their font; the first answers.
             const object = location.indexes
                 .map((index) => lib.FPDFPage_GetObject(page, index))
                 .find((entry) => lib.FPDFPageObj_GetType(entry) === OBJECT_TEXT);
@@ -465,7 +513,10 @@ export class PdfEditDocument {
             if (!Number.isSafeInteger(pixels) ||
                 pixels > this.#limits.maxDecodedPixels)
                 throw new ViewerError("resource-limit", "The rendered page exceeds maxDecodedPixels", { details: { actual: pixels, limit: this.#limits.maxDecodedPixels } });
-            const wanted = new Set(elementIds);
+            const wanted = new Set(elementIds.flatMap((id) => {
+                const paragraph = this.#paragraphOf(id)?.paragraph;
+                return paragraph?.id === id ? paragraph.memberIds : [id];
+            }));
             const records = this.#objectsOf(pageIndex, page);
             const suppressed = [];
             records.forEach((record, index) => {
@@ -529,7 +580,12 @@ export class PdfEditDocument {
         if (pageIndex === undefined ||
             pageIndex !== this.#pageIndexOf(range.end.elementId))
             return [];
-        return this.#scanText(pageIndex, (scan) => rectsOf(this.#pdfium, scan, range));
+        const paragraph = range.start.elementId === range.end.elementId
+            ? this.#paragraphOf(range.start.elementId)
+            : undefined;
+        return this.#scanText(pageIndex, (scan) => rectsOf(this.#pdfium, paragraph?.paragraph.id === range.start.elementId
+            ? this.#paragraphScan(scan, paragraph)
+            : scan, range));
     }
     dispose() {
         this.#fonts.release(this.#pdfium, this.#document.handle);
@@ -561,10 +617,14 @@ export class PdfEditDocument {
             // part of the base, so a replay meets them and picks the same id.
             newId: (pageIndex, suffix = "") => `${this.#unusedId(pageIndex, `${this.#pages[pageIndex].key}:n${stateId}.${operationIndex}.${created++}`)}${suffix}`,
             withPage: (pageIndex, use) => this.#writePage(pageIndex, use),
+            readPage: (pageIndex, use) => this.#withPage(pageIndex, use),
+            paragraph: (id) => this.#paragraphOf(id),
+            pageElements: (pageIndex) => this.#elementsOf(pageIndex),
             appendObjects: (pageIndex, records) => {
                 const page = this.#pages[pageIndex];
                 page.objects = [...(page.objects ?? []), ...records];
                 delete page.elements;
+                delete page.paragraphs;
             },
             locate: (id) => this.#locate(id),
             element: (id) => this.getElement(id),
@@ -591,6 +651,7 @@ export class PdfEditDocument {
                     return;
                 delete page.geometry;
                 delete page.elements;
+                delete page.paragraphs;
             },
             spliceObjects: (pageIndex, start, count, records) => {
                 const page = this.#pages[pageIndex];
@@ -598,13 +659,16 @@ export class PdfEditDocument {
                 objects.splice(start, count, ...records);
                 page.objects = objects;
                 delete page.elements;
+                delete page.paragraphs;
             },
         };
     }
     /** Cached elements carry page indexes, which a structure change makes stale. */
     #forgetElements() {
-        for (const page of this.#pages)
+        for (const page of this.#pages) {
             delete page.elements;
+            delete page.paragraphs;
+        }
     }
     #locate(id) {
         const pageIndex = this.#pageIndexOf(id);
@@ -617,7 +681,17 @@ export class PdfEditDocument {
                 indexes.push(index);
         });
         const record = records[indexes[0] ?? -1];
-        return record ? { pageIndex, indexes, record } : undefined;
+        if (record)
+            return { pageIndex, indexes, record };
+        const paragraph = this.#paragraphOf(id);
+        const first = paragraph && records[paragraph.indexes[0] ?? -1];
+        return paragraph?.paragraph.id === id && first
+            ? {
+                pageIndex,
+                indexes: paragraph.indexes,
+                record: { ...first, id, mark: paragraph.spec },
+            }
+            : undefined;
     }
     /** Loads a page, lets `use` change it, regenerates its content stream. */
     #writePage(pageIndex, use) {
@@ -636,6 +710,7 @@ export class PdfEditDocument {
                     details: { stage: "apply", pageIndex },
                 });
             delete this.#pages[pageIndex].elements;
+            delete this.#pages[pageIndex].paragraphs;
             return result;
         }
         finally {
@@ -657,7 +732,13 @@ export class PdfEditDocument {
             return record.elements;
         return this.#withPage(pageIndex, (page, textPage, geometry) => {
             const { elements } = scanPage(this.#pdfium, page, textPage, pageIndex, geometry, this.#objectsOf(pageIndex, page));
-            record.elements = Object.freeze(elements);
+            record.paragraphs = discoverParagraphs(this.#pdfium, page, pageIndex, geometry, this.#objectsOf(pageIndex, page), elements, textPage, this.#measurer);
+            record.elements = Object.freeze(elements.map((element) => {
+                const paragraph = record.paragraphs?.get(element.id)?.paragraph;
+                return paragraph && paragraph.id !== element.id
+                    ? { ...element, textEditingTarget: paragraph.id }
+                    : element;
+            }));
             return record.elements;
         });
     }
@@ -779,6 +860,28 @@ export class PdfEditDocument {
         };
         return record.geometry;
     }
+    #paragraphScan(scan, target) {
+        const paragraph = target.paragraph;
+        if (paragraph.memberIds.includes(paragraph.id))
+            return scan;
+        const members = new Map(paragraph.members.map((member) => [member.elementId, member]));
+        return {
+            ...scan,
+            elements: [
+                ...scan.elements.filter((element) => !members.has(element.id)),
+                paragraphElement(paragraph),
+            ],
+            offsets: scan.offsets.map((position) => {
+                const member = position && members.get(position.elementId);
+                return member && position
+                    ? {
+                        elementId: paragraph.id,
+                        offset: Math.min(member.end, member.start + position.offset),
+                    }
+                    : position;
+            }),
+        };
+    }
     /** Loads a page with its text page and the character-to-element mapping. */
     #scanText(pageIndex, use) {
         return this.#withPage(pageIndex, (page, textPage, geometry) => {

package/dist/edit/pdf/engine/elements.d.ts

@@ -2,6 +2,7 @@ import type { PageRect } from "../../types.js";
 import type { PdfElement, PdfTextStyle } from "../types.js";
 import { type PageGeometry } from "./geometry.js";
 import type { Pdfium } from "./pdfium.js";
+import type { ParagraphSpec } from "./paragraph.js";
 /** FPDFPageObj_GetType values. */
 export declare const OBJECT_TEXT = 1;
 export declare const OBJECT_PATH = 2;
@@ -11,10 +12,13 @@ export declare const MARK_NAME = "WebDoc";
 export declare const MARK_PARAM = "webdoc";
 /** What a `WebDoc` mark says about the objects it tags. */
 export interface MarkParams {
-    readonly kind: "textBox" | "table";
+    readonly kind: "textBox" | "table" | "paragraph";
     readonly id: string;
     readonly [key: string]: unknown;
 }
+export declare function paragraphSpecOf(mark: unknown): ParagraphSpec | undefined;
+/** Paragraph marks store the upright frame; the page may subsequently rotate. */
+export declare function paragraphBounds(spec: ParagraphSpec, geometry: PageGeometry): PageRect;
 /** One PDFium page object with what the model knows about it. */
 export interface ObjectRecord {
     /** Element id of a plain object; objects of a marked group share their group id. */

package/dist/edit/pdf/engine/elements.js

@@ -1,6 +1,6 @@
 import { validateSchema } from "../../schema.js";
-import { tableMarkSchema, tableMemberMarkSchema, textBoxMarkSchema, } from "../schemas.js";
-import { round, roundRect, unionRects, userRectToPage, } from "./geometry.js";
+import { tableMarkSchema, tableMemberMarkSchema, textBoxMarkSchema, paragraphMarkSchema, } from "../schemas.js";
+import { pageToUser, round, roundRect, unionRects, userRectToPage, } from "./geometry.js";
 /** FPDFPageObj_GetType values. */
 export const OBJECT_TEXT = 1;
 export const OBJECT_PATH = 2;
@@ -11,6 +11,20 @@ export const MARK_PARAM = "webdoc";
 /** Font descriptor flag bits (PDF 32000-1 table 123). */
 const FLAG_ITALIC = 1 << 6;
 const FLAG_FORCE_BOLD = 1 << 18;
+export function paragraphSpecOf(mark) {
+    return validateSchema(mark, paragraphMarkSchema, 0).length === 0
+        ? mark
+        : undefined;
+}
+/** Paragraph marks store the upright frame; the page may subsequently rotate. */
+export function paragraphBounds(spec, geometry) {
+    if (geometry.rotation === 0)
+        return spec.rect;
+    const upright = { ...geometry, rotation: 0 };
+    const top = pageToUser(upright, spec.rect.x, spec.rect.y);
+    const bottom = pageToUser(upright, spec.rect.x + spec.rect.width, spec.rect.y + spec.rect.height);
+    return roundRect(userRectToPage(geometry, top.x, bottom.y, bottom.x, top.y));
+}
 /**
  * Reads the objects of a loaded page in drawing order and turns them into
  * elements: plain objects become one element each, objects tagged with the
@@ -46,7 +60,7 @@ export function scanPage(pdfium, page, textPage, pageIndex, geometry, records) {
             const members = groups.get(element.id);
             const record = members && records.find((entry) => entry.id === element.id);
             return members && record?.mark
-                ? compositeElement(record.mark, members, pageIndex)
+                ? compositeElement(record.mark, members, pageIndex, geometry)
                 : element;
         }),
         byObject,
@@ -77,6 +91,8 @@ function isValidMark(params) {
     switch (params.kind) {
         case "textBox":
             return validateSchema(params, textBoxMarkSchema, 0).length === 0;
+        case "paragraph":
+            return validateSchema(params, paragraphMarkSchema, 0).length === 0;
         case "table":
             return (validateSchema(params, tableMarkSchema, 0).length === 0 ||
                 validateSchema(params, tableMemberMarkSchema, 0).length === 0);
@@ -104,11 +120,58 @@ export function markIsFresh(pdfium, page, textPage, geometry, mark, indexes) {
         .map((object) => textOf(pdfium, object, textPage))
         .join(" "));
     const tolerance = 2;
-    if (mark.kind === "textBox") {
+    if (mark.kind === "paragraph") {
+        const spec = paragraphSpecOf(mark);
+        if (!spec ||
+            objects.some((object) => {
+                if (lib.FPDFPageObj_GetType(object) !== OBJECT_TEXT) {
+                    if (spec.text.trim().length !== 0 ||
+                        lib.FPDFPageObj_GetType(object) !== OBJECT_PATH)
+                        return true;
+                    const mode = pdfium.readNumbers(2, "i32", ([fill, stroke]) => lib.FPDFPath_GetDrawMode(object, fill, stroke));
+                    const color = pdfium.readNumbers(4, "i32", ([r, g, b, a]) => lib.FPDFPageObj_GetFillColor(object, r, g, b, a));
+                    return mode?.[0] !== 1 || mode[1] !== 0 || color?.[3] !== 0;
+                }
+                const current = textStyle(pdfium, object);
+                return (current.fontSize !== round(spec.style.fontSize) ||
+                    current.color !== spec.style.color ||
+                    current.bold !== spec.style.bold ||
+                    current.italic !== spec.style.italic);
+            }))
+            return false;
+        const frame = paragraphBounds(spec, geometry);
+        if (union.y + union.height > frame.y + frame.height + tolerance)
+            return false;
+        const nativeLines = objects
+            .filter((object) => lib.FPDFPageObj_GetType(object) === OBJECT_TEXT)
+            .map((object) => textOf(pdfium, object, textPage).trimEnd());
+        if (nativeLines.length !== spec.lines.length ||
+            nativeLines.some((line, index) => line !== spec.lines[index]))
+            return false;
+        // Native wrapping may split at whitespace or inside a long word, but it
+        // cannot invent, reorder or omit any non-whitespace logical character.
+        let cursor = 0;
+        for (const line of nativeLines) {
+            while (!spec.text.startsWith(line, cursor) &&
+                cursor < spec.text.length &&
+                /\s/u.test(spec.text[cursor]))
+                cursor += 1;
+            if (!spec.text.startsWith(line, cursor))
+                return false;
+            cursor += line.length;
+        }
+        if (spec.text.slice(cursor).trim())
+            return false;
+        if (geometry.rotation !== 0)
+            return (union.x >= frame.x - tolerance &&
+                union.y >= frame.y - tolerance &&
+                union.x + union.width <= frame.x + frame.width + tolerance);
+    }
+    if (mark.kind === "textBox" || mark.kind === "paragraph") {
         const rect = mark.rect;
         const text = mark.text;
         const style = mark.style;
-        return (drawn === normalizeText(text) &&
+        return ((mark.kind === "paragraph" || drawn === normalizeText(text)) &&
             union.x >= rect.x - tolerance &&
             union.x + union.width <= rect.x + rect.width + tolerance &&
             // The first line's ink starts inside the box's first line band; the
@@ -169,7 +232,7 @@ function plainElement(pdfium, object, textPage, record, pageIndex, geometry) {
             return { ...base, kind: "other", operations: TRANSFORM_OPERATIONS };
     }
 }
-function compositeElement(mark, members, pageIndex) {
+function compositeElement(mark, members, pageIndex, geometry) {
     const bounds = roundRect(unionRects(members.map((member) => member.bounds)));
     const text = members
         .filter((member) => member.kind === "text" && member.text)
@@ -198,6 +261,25 @@ function compositeElement(mark, members, pageIndex) {
             operations: TABLE_OPERATIONS,
         };
     }
+    const paragraph = paragraphSpecOf(mark);
+    if (paragraph)
+        return {
+            id: mark.id,
+            kind: "paragraph",
+            pageIndex,
+            bounds: paragraphBounds(paragraph, geometry),
+            text: paragraph.text,
+            textStyle: paragraph.style,
+            ...(geometry.rotation ? { rotation: geometry.rotation * 90 } : {}),
+            operations: geometry.rotation
+                ? ["deleteElement"]
+                : [
+                    "replaceText",
+                    "replaceParagraphText",
+                    "setTextStyle",
+                    "deleteElement",
+                ],
+        };
     const style = members.find((member) => member.textStyle)?.textStyle;
     return {
         id: mark.id,