@extend-ai/react-docx 0.9.0 → 0.9.1

package/dist/index.js

@@ -1,10 +1,3 @@
-import {
-  createMinimalDocxPackage,
-  getPart,
-  packageToArrayBuffer,
-  parseDocx,
-  withPart
-} from "./chunk-KB6YHU6O.js";
 import {
   allocateBlockId,
   buildDocModel,
@@ -16,14 +9,21 @@ import {
   deepFreezeDocModel,
   ensureDocModelBlockIds,
   normalizeDocModel
-} from "./chunk-4CPXLVFB.js";
+} from "./chunk-GRQPIBJJ.js";
+import {
+  createMinimalDocxPackage,
+  getPart,
+  packageToArrayBuffer,
+  parseDocx,
+  withPart
+} from "./chunk-6NVXVLTW.js";
 import {
   initWasm,
   mapsToWasmPackage,
   setWasmSource,
   wasmModelToDocumentXml,
   wasmSerializeDocx
-} from "./chunk-THNPK4N7.js";
+} from "./chunk-AKDFE4ZH.js";
 
 // src/index.tsx
 import * as React2 from "react";
@@ -333,28 +333,24 @@ async function importDocxOnMainThread(buffer, signal) {
     throw createAbortError();
   }
   const startedAt = performanceNow();
-  const [{ parseDocx: parseDocx2 }, { buildDocModel: buildDocModel2, ensureDocModelBlockIds: ensureDocModelBlockIds2 }] = await Promise.all([
-    import("./src-JS3OX73I.js"),
-    import("./src-KC2H22CB.js")
-  ]);
-  const pkg = await parseDocx2(buffer);
-  const parsedAt = performanceNow();
+  const { buildDocModelFromBytes: buildDocModelFromBytes2, ensureDocModelBlockIds: ensureDocModelBlockIds2 } = await import("./src-D3NRHPLE.js");
   if (signal?.aborted) {
     throw createAbortError();
   }
-  const model = ensureDocModelBlockIds2(await buildDocModel2(pkg));
+  const result = await buildDocModelFromBytes2(buffer);
+  const model = ensureDocModelBlockIds2(result.model);
   const finishedAt = performanceNow();
   if (signal?.aborted) {
     throw createAbortError();
   }
   return {
-    package: pkg,
+    package: result.package,
     model,
     source: "main-thread",
     timings: {
       totalMs: finishedAt - startedAt,
-      parseMs: parsedAt - startedAt,
-      buildModelMs: finishedAt - parsedAt
+      parseMs: result.timings.parseMs,
+      buildModelMs: result.timings.buildModelMs
     }
   };
 }
@@ -366,12 +362,18 @@ async function importDocxBuffer(buffer, options = {}) {
     throw createAbortError();
   }
   if (!canUseDocxImportWorker(options)) {
+    if (options.useWorker === "required") {
+      throw new Error("DOCX import requires a Web Worker and a worker-compatible WASM source");
+    }
     return importDocxOnMainThread(buffer, options.signal);
   }
   let worker;
   try {
     worker = createDocxImportWorker();
-  } catch {
+  } catch (error) {
+    if (options.useWorker === "required") {
+      throw new Error("Unable to start the DOCX import worker", { cause: error });
+    }
     return importDocxOnMainThread(buffer, options.signal);
   }
   const requestId = nextImportWorkerRequestId;
@@ -441,7 +443,7 @@ async function importDocxBuffer(buffer, options = {}) {
     }
   });
   const result = await workerResult;
-  const { ensureDocModelBlockIds: ensureDocModelBlockIds2 } = await import("./src-KC2H22CB.js");
+  const { ensureDocModelBlockIds: ensureDocModelBlockIds2 } = await import("./src-D3NRHPLE.js");
   ensureDocModelBlockIds2(result.model);
   return result;
 }
@@ -449,6 +451,269 @@ async function importDocxBuffer(buffer, options = {}) {
 // src/editor.tsx
 import * as React from "react";
 import { flushSync } from "react-dom";
+
+// src/pointer-drag.ts
+function startObjectDrag(options) {
+  const { event, element } = options;
+  const doc = element.ownerDocument;
+  const win = doc.defaultView;
+  const rect = element.getBoundingClientRect();
+  const grabX = event.clientX - rect.left;
+  const grabY = event.clientY - rect.top;
+  let clientX = event.clientX;
+  let clientY = event.clientY;
+  let active = false;
+  let ended = false;
+  let animationFrame = 0;
+  let ghost;
+  let previousTime = 0;
+  const hiddenElements = /* @__PURE__ */ new Map();
+  const scrollContainers = [];
+  for (let parent = element.parentElement; parent; parent = parent.parentElement) {
+    if (/(auto|scroll)/.test(win.getComputedStyle(parent).overflowY)) {
+      scrollContainers.push(parent);
+    }
+  }
+  const scrollingElement = doc.scrollingElement;
+  if (scrollingElement && !scrollContainers.includes(scrollingElement)) {
+    scrollContainers.push(scrollingElement);
+  }
+  const scrollAnchors = /* @__PURE__ */ new Map();
+  const frame = () => ({
+    clientX,
+    clientY,
+    left: clientX - grabX,
+    top: clientY - grabY,
+    width: rect.width,
+    height: rect.height
+  });
+  const hideSource = () => {
+    const source = options.resolveElement();
+    if (source && !hiddenElements.has(source)) {
+      hiddenElements.set(source, source.style.visibility);
+      source.style.visibility = "hidden";
+    }
+  };
+  const observer = new MutationObserver(() => {
+    if (active && !ended) hideSource();
+  });
+  observer.observe(
+    element.closest("[data-testid=docx-editor-viewer]") ?? element.parentElement ?? element,
+    { childList: true, subtree: true }
+  );
+  const tick = (time) => {
+    if (ended) return;
+    const elapsed = previousTime ? Math.min(32, time - previousTime) : 16;
+    previousTime = time;
+    for (const container of scrollContainers) {
+      const bounds = container === scrollingElement ? { top: 0, bottom: win.innerHeight, left: 0, right: win.innerWidth } : container.getBoundingClientRect();
+      if (clientX < bounds.left || clientX > bounds.right) continue;
+      const edge = 40;
+      const speed = clientY < bounds.top + edge ? -Math.min(1, (bounds.top + edge - clientY) / edge) : clientY > bounds.bottom - edge ? Math.min(1, (clientY - bounds.bottom + edge) / edge) : 0;
+      const before = container.scrollTop;
+      container.scrollTop += speed * elapsed * 0.7;
+      if (container.scrollTop !== before) break;
+    }
+    hideSource();
+    const next = frame();
+    if (ghost) {
+      ghost.style.left = `${next.left}px`;
+      ghost.style.top = `${next.top}px`;
+    }
+    options.onFrame(next);
+    animationFrame = win.requestAnimationFrame(tick);
+  };
+  const cleanup = () => {
+    ended = true;
+    win.cancelAnimationFrame(animationFrame);
+    win.removeEventListener("pointermove", move, true);
+    win.removeEventListener("pointerup", up, true);
+    win.removeEventListener("pointercancel", cancelPointer, true);
+    win.removeEventListener("keydown", keydown);
+    win.removeEventListener("blur", cancel);
+    observer.disconnect();
+    win.requestAnimationFrame(
+      () => win.requestAnimationFrame(() => {
+        scrollAnchors.forEach((value, container) => {
+          container.style.overflowAnchor = value;
+        });
+      })
+    );
+    ghost?.remove();
+    hiddenElements.forEach((visibility, source) => {
+      source.style.visibility = visibility;
+    });
+  };
+  const cancel = () => {
+    if (ended) return;
+    cleanup();
+    options.onCancel();
+  };
+  const cancelPointer = (next) => {
+    if (next.pointerId === event.pointerId) cancel();
+  };
+  const keydown = (next) => {
+    if (next.key === "Escape") {
+      next.preventDefault();
+      cancel();
+    }
+  };
+  const move = (next) => {
+    if (next.pointerId !== event.pointerId || ended) return;
+    clientX = next.clientX;
+    clientY = next.clientY;
+    if (!active) {
+      if (Math.hypot(clientX - event.clientX, clientY - event.clientY) < 4)
+        return;
+      active = true;
+      for (const container of scrollContainers) {
+        scrollAnchors.set(container, container.style.overflowAnchor);
+        container.style.overflowAnchor = "none";
+      }
+      ghost = element.cloneNode(true);
+      ghost.querySelectorAll(
+        "[data-image-resize-handle], [data-docx-table-move-handle]"
+      ).forEach((handle) => handle.remove());
+      for (const node of [ghost, ...ghost.querySelectorAll("*")]) {
+        node.removeAttribute("id");
+        for (const attribute of [...node.attributes]) {
+          if (attribute.name.startsWith("data-docx-"))
+            node.removeAttribute(attribute.name);
+        }
+        node.setAttribute("contenteditable", "false");
+      }
+      const style = win.getComputedStyle(element);
+      Object.assign(ghost.style, {
+        position: "fixed",
+        margin: "0",
+        left: `${rect.left}px`,
+        top: `${rect.top}px`,
+        width: `${rect.width / options.zoom}px`,
+        height: `${rect.height / options.zoom}px`,
+        transform: `scale(${options.zoom})`,
+        transformOrigin: "top left",
+        visibility: "visible",
+        pointerEvents: "none",
+        zIndex: "2147483647",
+        opacity: "0.9",
+        userSelect: "none",
+        font: style.font,
+        color: style.color
+      });
+      ghost.setAttribute("aria-hidden", "true");
+      ghost.setAttribute("data-docx-drag-ghost", "true");
+      doc.body.appendChild(ghost);
+      hideSource();
+      animationFrame = win.requestAnimationFrame(tick);
+    }
+    next.preventDefault();
+    next.stopPropagation();
+  };
+  const up = (next) => {
+    if (next.pointerId !== event.pointerId || ended) return;
+    clientX = next.clientX;
+    clientY = next.clientY;
+    const finalFrame = frame();
+    if (active) {
+      next.preventDefault();
+      next.stopPropagation();
+    }
+    try {
+      if (active) options.onDrop(finalFrame);
+      else options.onCancel();
+    } finally {
+      cleanup();
+    }
+  };
+  win.addEventListener("pointermove", move, { passive: false, capture: true });
+  win.addEventListener("pointerup", up, true);
+  win.addEventListener("pointercancel", cancelPointer, true);
+  win.addEventListener("keydown", keydown);
+  win.addEventListener("blur", cancel);
+  return cancel;
+}
+
+// src/image-drop.ts
+function copyModelForParagraphEdits(model, locations) {
+  const copies = /* @__PURE__ */ new Map();
+  const copy = (value) => {
+    const existing = copies.get(value);
+    if (existing) return existing;
+    const next2 = Array.isArray(value) ? [...value] : { ...value };
+    copies.set(value, next2);
+    copies.set(next2, next2);
+    return next2;
+  };
+  const next = { ...model, nodes: [...model.nodes] };
+  for (const location of locations) {
+    if (location.kind === "paragraph") {
+      const node = next.nodes[location.nodeIndex];
+      if (node?.type !== "paragraph") continue;
+      const paragraph = copy(node);
+      paragraph.children = copy(paragraph.children);
+      next.nodes[location.nodeIndex] = paragraph;
+    } else {
+      const node = next.nodes[location.tableIndex];
+      if (node?.type !== "table") continue;
+      const row = node.rows[location.rowIndex];
+      const cell = row?.cells[location.cellIndex];
+      if (!cell) continue;
+      let paragraphIndex = -1;
+      const contentIndex = cell.nodes.findIndex((content) => {
+        if (content.type === "paragraph") paragraphIndex++;
+        return content.type === "paragraph" && paragraphIndex === location.paragraphIndex;
+      });
+      const paragraph = cell.nodes[contentIndex];
+      if (paragraph?.type !== "paragraph") continue;
+      const nextTable = copy(node);
+      next.nodes[location.tableIndex] = nextTable;
+      nextTable.rows = copy(node.rows);
+      const nextRow = copy(row);
+      nextTable.rows[location.rowIndex] = nextRow;
+      nextRow.cells = copy(row.cells);
+      const nextCell = copy(cell);
+      nextRow.cells[location.cellIndex] = nextCell;
+      nextCell.nodes = copy(cell.nodes);
+      const nextParagraph = copy(paragraph);
+      nextCell.nodes[contentIndex] = nextParagraph;
+      nextParagraph.children = copy(paragraph.children);
+    }
+  }
+  return next;
+}
+function imageDropPositionAtTextOffset(paragraph, textOffset, options) {
+  let remaining = Math.max(0, Math.round(textOffset));
+  for (let childIndex = 0; childIndex < paragraph.children.length; childIndex++) {
+    const child = paragraph.children[childIndex];
+    const length = child.type === "image" ? !child.floating && options?.countInlineImages ? 1 : 0 : child.type === "text" ? child.text.length : (options?.fieldText?.(child) ?? child.value ?? "").length;
+    if (remaining <= length && length > 0) {
+      if (remaining === 0) return { childIndex };
+      if (remaining === length) return { childIndex: childIndex + 1 };
+      return child.type === "text" ? { childIndex, textOffset: remaining } : { childIndex: childIndex + 1 };
+    }
+    remaining -= length;
+  }
+  return { childIndex: paragraph.children.length };
+}
+function insertImageAtDropPosition(paragraph, image, childIndex, textOffset) {
+  const index = Math.max(0, Math.min(childIndex, paragraph.children.length));
+  const child = paragraph.children[index];
+  if (child?.type === "text" && textOffset !== void 0) {
+    const offset = Math.max(0, Math.min(textOffset, child.text.length));
+    const before = child.text.slice(0, offset);
+    const after = child.text.slice(offset);
+    const children = [];
+    if (before) children.push({ ...child, text: before });
+    children.push(image);
+    if (after) children.push({ ...child, text: after });
+    paragraph.children.splice(index, 1, ...children);
+    return index + (before ? 1 : 0);
+  }
+  paragraph.children.splice(index, 0, image);
+  return index;
+}
+
+// src/editor.tsx
 import { renderToStaticMarkup } from "react-dom/server";
 import { useVirtualizer, useWindowVirtualizer } from "@tanstack/react-virtual";
 
@@ -899,11 +1164,11 @@ function safeParagraphContext(model, nodeIndex) {
     return { ok: false, reason: "unsupported" };
   }
   const paragraphRange = paragraphs[0];
-  for (const revision of [
+  for (const revision2 of [
     ...elementsNamed(scan, "w:ins"),
     ...elementsNamed(scan, "w:del")
   ]) {
-    if (revision.parentStart !== paragraphRange.start) {
+    if (revision2.parentStart !== paragraphRange.start) {
       return { ok: false, reason: "unsupported" };
     }
   }
@@ -940,9 +1205,9 @@ function hasNonWhitespaceOutsideChildren(xml, parent, children) {
   }
   return xml.slice(cursor, parent.closeStart).trim().length > 0;
 }
-function revisionRangeIsSafe(context, revision, kind) {
-  const runs = directChildElements(context.scan, revision);
-  if (runs.length === 0 || runs.some((run) => run.tagName !== "w:r") || hasNonWhitespaceOutsideChildren(context.sourceXml, revision, runs)) {
+function revisionRangeIsSafe(context, revision2, kind) {
+  const runs = directChildElements(context.scan, revision2);
+  if (runs.length === 0 || runs.some((run) => run.tagName !== "w:r") || hasNonWhitespaceOutsideChildren(context.sourceXml, revision2, runs)) {
     return false;
   }
   const expectedTextTag = kind === "insertion" ? "w:t" : "w:delText";
@@ -1701,12 +1966,10 @@ function updatedParagraphNodeText(source, text, options) {
   if (paragraphEditableText(source) === text) {
     return source;
   }
-  const paragraph = cloneParagraphNode(source);
-  paragraph.children = distributeTextAcrossParagraphChildren(
-    source,
-    text,
-    options
-  );
+  const paragraph = {
+    ...source,
+    children: distributeTextAcrossParagraphChildren(source, text, options)
+  };
   paragraph.sourceTextPatch = sourceTextPatchForUpdate(source, paragraph);
   if (!paragraph.sourceTextPatch) {
     paragraph.sourceXml = void 0;
@@ -1752,6 +2015,15 @@ function discardTableSourceXml(table) {
   table.sourceXml = void 0;
   table.sourceTextPatches = void 0;
 }
+function copyTableForCellTextEdit(table, rowIndex, cellIndex) {
+  const row = table.rows[rowIndex];
+  const cell = row.cells[cellIndex];
+  const rows = [...table.rows];
+  const cells = [...row.cells];
+  cells[cellIndex] = { ...cell, nodes: [...cell.nodes] };
+  rows[rowIndex] = { ...row, cells };
+  return { ...table, rows };
+}
 function directParagraphNodeIndex(nodes, paragraphIndex) {
   const target = Math.max(0, Math.round(paragraphIndex));
   let cursor = 0;
@@ -1934,9 +2206,7 @@ function distributeTextAcrossParagraphChildren(paragraph, text, options) {
     }
     textGroups.push(currentGroup);
     currentGroup = [];
-    anchors.push(
-      child.type === "form-field" ? cloneFormFieldRun(child) : cloneImageRun(child)
-    );
+    anchors.push(child);
   }
   textGroups.push(currentGroup);
   const allAnchorsAreImages = anchors.length > 0 && anchors.every((anchor) => anchor.type === "image");
@@ -2015,7 +2285,7 @@ function distributeTextAcrossParagraphChildren(paragraph, text, options) {
         });
       }
       if (index < anchors.length) {
-        nextChildren2.push(cloneParagraphChildRun(anchors[index]));
+        nextChildren2.push(anchors[index]);
       }
     }
     if (nextChildren2.length > 0) {
@@ -2059,7 +2329,7 @@ function distributeTextAcrossParagraphChildren(paragraph, text, options) {
       });
     }
     if (index < anchors.length) {
-      nextChildren.push(cloneParagraphChildRun(anchors[index]));
+      nextChildren.push(anchors[index]);
     }
   }
   if (nextChildren.length > 0) {
@@ -2380,7 +2650,7 @@ function updateTableCellText(model, tableIndex, rowIndex, cellIndex, text, optio
   )) {
     return model;
   }
-  const tableNode = cloneTableNode(sourceTable);
+  const tableNode = copyTableForCellTextEdit(sourceTable, rowIndex, cellIndex);
   const row = tableNode.rows[rowIndex];
   const cell = row?.cells[cellIndex];
   if (!cell) {
@@ -2444,7 +2714,7 @@ function updateTableCellParagraphText(model, tableIndex, rowIndex, cellIndex, pa
   const sourceCell = sourceTable.rows[rowIndex]?.cells[cellIndex];
   const sourceParagraphNodeIndex = sourceCell ? directParagraphNodeIndex(sourceCell.nodes, paragraphIndex) : void 0;
   const sourceParagraph = sourceParagraphNodeIndex === void 0 ? void 0 : sourceCell?.nodes[sourceParagraphNodeIndex];
-  if (!sourceCell || !sourceParagraph || sourceParagraph.type !== "paragraph") {
+  if (!sourceCell || !sourceParagraph || sourceParagraph.type !== "paragraph" || sourceParagraphNodeIndex === void 0) {
     return { ...model, nodes: [...model.nodes] };
   }
   if (paragraphTextEditIsFailClosed(sourceParagraph, text)) {
@@ -2453,17 +2723,15 @@ function updateTableCellParagraphText(model, tableIndex, rowIndex, cellIndex, pa
   if (paragraphEditableText(sourceParagraph) === text) {
     return model;
   }
-  const tableNode = cloneTableNode(sourceTable);
-  const row = tableNode.rows[rowIndex];
-  const cell = row?.cells[cellIndex];
-  const paragraphNodeIndex = cell ? directParagraphNodeIndex(cell.nodes, paragraphIndex) : void 0;
-  const paragraph = paragraphNodeIndex === void 0 ? void 0 : cell?.nodes[paragraphNodeIndex];
-  if (!cell || !paragraph || paragraph.type !== "paragraph" || paragraphNodeIndex === void 0) {
-    return { ...model, nodes: [...model.nodes] };
-  }
-  const updatedParagraph = updatedParagraphNodeText(paragraph, text, options);
-  cell.nodes[paragraphNodeIndex] = updatedParagraph;
-  if (!retainTableSourceTextPatch(tableNode, paragraph, updatedParagraph)) {
+  const tableNode = copyTableForCellTextEdit(sourceTable, rowIndex, cellIndex);
+  const cell = tableNode.rows[rowIndex].cells[cellIndex];
+  const updatedParagraph = updatedParagraphNodeText(
+    sourceParagraph,
+    text,
+    options
+  );
+  cell.nodes[sourceParagraphNodeIndex] = updatedParagraph;
+  if (!retainTableSourceTextPatch(tableNode, sourceParagraph, updatedParagraph)) {
     discardTableSourceXml(tableNode);
   }
   const nextNodes = [...model.nodes];
@@ -2477,7 +2745,7 @@ function updateTableCellParagraphTextRecursive(model, tableIndex, rowIndex, cell
   }
   const sourceCell = sourceTable.rows[rowIndex]?.cells[cellIndex];
   const sourceParagraph = sourceCell ? recursiveParagraphAtIndex(sourceCell.nodes, paragraphIndex) : void 0;
-  if (!sourceParagraph) {
+  if (!sourceCell || !sourceParagraph) {
     return { ...model, nodes: [...model.nodes] };
   }
   if (paragraphTextEditIsFailClosed(sourceParagraph, text)) {
@@ -2486,53 +2754,49 @@ function updateTableCellParagraphTextRecursive(model, tableIndex, rowIndex, cell
   if (paragraphEditableText(sourceParagraph) === text) {
     return model;
   }
-  const next = cloneDocModel(model);
-  const tableNode = next.nodes[tableIndex];
-  if (!tableNode || tableNode.type !== "table") {
-    return next;
-  }
-  const row = tableNode.rows[rowIndex];
-  const cell = row?.cells[cellIndex];
-  if (!cell) {
-    return next;
-  }
-  const targetParagraphIndex = Math.max(0, Math.round(paragraphIndex));
-  let paragraphCursor = 0;
-  const updateInNodes = (nodes, ancestorTables) => {
+  const updatedParagraph = updatedParagraphNodeText(
+    sourceParagraph,
+    text,
+    options
+  );
+  const retainSource = (table) => {
+    if (!retainTableSourceTextPatch(table, sourceParagraph, updatedParagraph)) {
+      discardTableSourceXml(table);
+    }
+  };
+  const updateInNodes = (nodes) => {
     for (let nodeIndex = 0; nodeIndex < nodes.length; nodeIndex += 1) {
       const node = nodes[nodeIndex];
-      if (!node) {
-        continue;
-      }
-      if (node.type === "paragraph") {
-        if (paragraphCursor !== targetParagraphIndex) {
-          paragraphCursor += 1;
-          continue;
-        }
-        const updatedParagraph = updatedParagraphNodeText(node, text, options);
-        nodes[nodeIndex] = updatedParagraph;
-        ancestorTables.forEach((ancestorTable) => {
-          if (!retainTableSourceTextPatch(ancestorTable, node, updatedParagraph)) {
-            discardTableSourceXml(ancestorTable);
-          }
-        });
-        return true;
-      }
-      ancestorTables.push(node);
-      for (const nestedRow of node.rows) {
-        for (const nestedCell of nestedRow.cells) {
-          if (updateInNodes(nestedCell.nodes, ancestorTables)) {
-            ancestorTables.pop();
-            return true;
-          }
+      if (node === sourceParagraph) {
+        const nextNodes2 = [...nodes];
+        nextNodes2[nodeIndex] = updatedParagraph;
+        return nextNodes2;
+      }
+      if (node.type !== "table") continue;
+      for (let rowIndex2 = 0; rowIndex2 < node.rows.length; rowIndex2 += 1) {
+        const row = node.rows[rowIndex2];
+        for (let cellIndex2 = 0; cellIndex2 < row.cells.length; cellIndex2 += 1) {
+          const updatedNodes2 = updateInNodes(row.cells[cellIndex2].nodes);
+          if (!updatedNodes2) continue;
+          const table = copyTableForCellTextEdit(node, rowIndex2, cellIndex2);
+          table.rows[rowIndex2].cells[cellIndex2].nodes = updatedNodes2;
+          retainSource(table);
+          const nextNodes2 = [...nodes];
+          nextNodes2[nodeIndex] = table;
+          return nextNodes2;
         }
       }
-      ancestorTables.pop();
     }
-    return false;
+    return void 0;
   };
-  updateInNodes(cell.nodes, [tableNode]);
-  return next;
+  const updatedNodes = updateInNodes(sourceCell.nodes);
+  if (!updatedNodes) return model;
+  const tableNode = copyTableForCellTextEdit(sourceTable, rowIndex, cellIndex);
+  tableNode.rows[rowIndex].cells[cellIndex].nodes = updatedNodes;
+  retainSource(tableNode);
+  const nextNodes = [...model.nodes];
+  nextNodes[tableIndex] = tableNode;
+  return { ...model, nodes: nextNodes };
 }
 function mutateParagraphTextRuns(model, transform) {
   for (const node of model.nodes) {
@@ -2805,13 +3069,51 @@ async function serializeDocModel(model, basePackage) {
     model,
     basePackage ? mapsToWasmPackage(basePackage) : void 0
   );
-  const { parseDocx: parseDocx2 } = await import("./src-JS3OX73I.js");
+  const { parseDocx: parseDocx2 } = await import("./src-DEWCGIL2.js");
   return parseDocx2(bytes);
 }
 async function serializeDocx(model, basePackage) {
   return wasmSerializeDocx(model, basePackage ? mapsToWasmPackage(basePackage) : void 0);
 }
 
+// src/font-metrics.ts
+var revision = 0;
+var observedFonts;
+var invalidators = /* @__PURE__ */ new Set();
+var listeners = /* @__PURE__ */ new Set();
+function invalidateFontMetrics() {
+  revision += 1;
+  invalidators.forEach((invalidate) => invalidate());
+  listeners.forEach((listener) => listener());
+}
+function observeFonts() {
+  const fonts = typeof document !== "undefined" ? document.fonts : void 0;
+  if (fonts === observedFonts || !fonts?.addEventListener) {
+    return;
+  }
+  observedFonts?.removeEventListener("loadingdone", invalidateFontMetrics);
+  observedFonts = fonts;
+  fonts.addEventListener("loadingdone", invalidateFontMetrics);
+}
+function registerFontMetricCache(invalidate) {
+  invalidators.add(invalidate);
+  observeFonts();
+}
+function subscribeFontMetrics(listener) {
+  observeFonts();
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function getFontMetricsRevision() {
+  observeFonts();
+  return revision;
+}
+function getServerFontMetricsRevision() {
+  return 0;
+}
+
 // src/editing-intents.ts
 function resolveEditingIntent(source) {
   const insertedText = source.data ?? source.dataTransferText ?? "";
@@ -3904,6 +4206,18 @@ function segmentTextByDocxScriptFont(text, style) {
   if (!text) {
     return [];
   }
+  if (/^[\x00-\x7f]+$/.test(text)) {
+    const script = classifyDocxFontScript(text[0], style) ?? "ascii";
+    return [
+      {
+        text,
+        startOffset: 0,
+        endOffset: text.length,
+        script,
+        fontFamily: resolveDocxScriptFontFamily(style, script)
+      }
+    ];
+  }
   const tokens = [];
   let offset = 0;
   for (const character of text) {
@@ -3937,15 +4251,24 @@ function segmentTextByDocxScriptFont(text, style) {
     previousScript = token.script;
   }
   const segments = [];
+  const families = /* @__PURE__ */ new Map();
+  let previousFamilyKey;
   for (const token of tokens) {
     const script = token.script ?? fallbackScript;
-    const fontFamily = resolveDocxScriptFontFamily(style, script);
+    let resolved = families.get(script);
+    if (!resolved) {
+      const family = resolveDocxScriptFontFamily(style, script);
+      resolved = { family, key: normalizedFamilyKey(family) };
+      families.set(script, resolved);
+    }
+    const fontFamily = resolved.family;
     const previous = segments[segments.length - 1];
-    if (previous && normalizedFamilyKey(previous.fontFamily) === normalizedFamilyKey(fontFamily)) {
+    if (previous && previousFamilyKey === resolved.key) {
       previous.text += token.text;
       previous.endOffset = token.endOffset;
       continue;
     }
+    previousFamilyKey = resolved.key;
     segments.push({
       text: token.text,
       startOffset: token.startOffset,
@@ -3957,9 +4280,15 @@ function segmentTextByDocxScriptFont(text, style) {
   return segments;
 }
 function resolveDocxTextFontFamily(text, style) {
-  return segmentTextByDocxScriptFont(text, style).find(
-    (segment) => segment.fontFamily
-  )?.fontFamily ?? normalizeFamily(style?.fontFamily);
+  let hasStrongScript = false;
+  for (const character of text) {
+    const script = classifyDocxFontScript(character, style);
+    if (!script) continue;
+    hasStrongScript = true;
+    const family = resolveDocxScriptFontFamily(style, script);
+    if (family) return family;
+  }
+  return (text && !hasStrongScript ? resolveDocxScriptFontFamily(style, neutralScript(style)) : void 0) ?? normalizeFamily(style?.fontFamily);
 }
 
 // src/editor-transaction-state.ts
@@ -4075,6 +4404,7 @@ function createTransactionalEditorStateReducer(adapter) {
 
 // src/pretext-layout.ts
 import {
+  clearCache,
   layoutNextLine,
   measureLineStats,
   prepareWithSegments
@@ -4087,6 +4417,13 @@ var layoutByKey = /* @__PURE__ */ new Map();
 var lineCountByKey = /* @__PURE__ */ new Map();
 var fragmentOffsetAdvancesByFragment = /* @__PURE__ */ new WeakMap();
 var graphemeOffsetsByText = /* @__PURE__ */ new Map();
+registerFontMetricCache(() => {
+  clearCache();
+  preparedTextByKey.clear();
+  layoutByKey.clear();
+  lineCountByKey.clear();
+  fragmentOffsetAdvancesByFragment = /* @__PURE__ */ new WeakMap();
+});
 var measureCanvas;
 var measureCanvasContext;
 var graphemeSegmenter;
@@ -5242,6 +5579,7 @@ var THUMBNAIL_DIRECT_TOKEN_REGEX = /(\r\n|\n|\t|[^\S\r\n\t]+|[^\s\r\n\t]+)/g;
 var THUMBNAIL_DIRECT_LEADING_WHITESPACE_REGEX = /^\s/;
 var THUMBNAIL_DIRECT_TEXT_MEASURE_CACHE_MAX_ENTRIES = 4096;
 var directThumbnailTextMeasureCache = /* @__PURE__ */ new Map();
+registerFontMetricCache(() => directThumbnailTextMeasureCache.clear());
 function measureDirectThumbnailToken(context, font, text) {
   if (!text) {
     return 0;
@@ -6112,6 +6450,15 @@ var estimatedTextAdvanceWidthByFontAndValue = /* @__PURE__ */ new Map();
 var pretextWordBreakModeByText = /* @__PURE__ */ new Map();
 var paragraphBaseFontSizePxByParagraph = /* @__PURE__ */ new WeakMap();
 var paragraphDominantFontFamilyByParagraph = /* @__PURE__ */ new WeakMap();
+registerFontMetricCache(() => {
+  paragraphEstimatedHeightBySourceXml.clear();
+  tableEstimatedHeightBySourceXml.clear();
+  textWidthByFontAndValue.clear();
+  estimatedTextAdvanceWidthByFontAndValue.clear();
+  tableEstimatedRowHeightsByNode = /* @__PURE__ */ new WeakMap();
+  wrappedLineCountByParagraph = /* @__PURE__ */ new WeakMap();
+  paragraphPretextLayoutSourceCache = /* @__PURE__ */ new WeakMap();
+});
 function setCacheEntry(cache, key, value) {
   if (!cache.has(key) && cache.size >= XML_CACHE_MAX_ENTRIES) {
     const oldestKey = cache.keys().next().value;
@@ -6685,7 +7032,7 @@ function selectionOffsetsWithinElementDom(element) {
   try {
     const textLengthWithoutNumberingLabels = (range) => {
       const fragment = range.cloneContents();
-      fragment.querySelectorAll("[data-docx-numbering-label='true']").forEach((label) => {
+      fragment.querySelectorAll("[data-docx-numbering-label='true'],[data-docx-image-location]").forEach((label) => {
         label.remove();
       });
       return fragment.textContent?.length ?? 0;
@@ -6713,7 +7060,7 @@ function staticRangeOffsetsWithinElementDom(element, staticRange) {
   try {
     const textLengthWithoutNumberingLabels = (range) => {
       const fragment = range.cloneContents();
-      fragment.querySelectorAll("[data-docx-numbering-label='true']").forEach((label) => {
+      fragment.querySelectorAll("[data-docx-numbering-label='true'],[data-docx-image-location]").forEach((label) => {
         label.remove();
       });
       return fragment.textContent?.length ?? 0;
@@ -6746,7 +7093,7 @@ function setSelectionWithinElementByTextOffsetsDom(element, startOffset, endOffs
     let currentTextNode = walker.nextNode();
     while (currentTextNode) {
       if (currentTextNode instanceof Text && currentTextNode.parentElement?.closest(
-        "[data-docx-numbering-label='true']"
+        "[data-docx-numbering-label='true'],[data-docx-image-location]"
       )) {
         currentTextNode = walker.nextNode();
         continue;
@@ -8043,7 +8390,7 @@ function tableSelectionCoversWholeTable(table, range) {
 }
 function textLengthFromRange(range) {
   const fragment = range.cloneContents();
-  fragment.querySelectorAll("[data-docx-numbering-label='true']").forEach((label) => {
+  fragment.querySelectorAll("[data-docx-numbering-label='true'],[data-docx-image-location]").forEach((label) => {
     label.remove();
   });
   return fragment.textContent?.length ?? 0;
@@ -8339,7 +8686,7 @@ function replaceTabLayoutMarkersWithTabText(root) {
 function editableTextFromElement(element) {
   const clone = element.cloneNode(true);
   replaceTabLayoutMarkersWithTabText(clone);
-  clone.querySelectorAll("[data-docx-numbering-label='true']").forEach((label) => {
+  clone.querySelectorAll("[data-docx-numbering-label='true'],[data-docx-image-location]").forEach((label) => {
     label.remove();
   });
   clone.querySelectorAll("br").forEach((lineBreak) => {
@@ -8717,9 +9064,15 @@ function paragraphHasOnlyWhitespaceText(paragraph) {
     if (child.type !== "text") {
       return false;
     }
-    return child.text.replace(/[\s\u00a0]+/g, "").length === 0;
+    return !/[^\s\u00a0]/.test(child.text);
   });
 }
+function paragraphHasActiveNumbering(paragraph) {
+  const numbering = paragraph.style?.numbering;
+  return Boolean(
+    numbering && Number.isFinite(numbering.numId) && Math.round(numbering.numId) > 0
+  );
+}
 function paragraphContainsSectionBreakProperties(paragraph) {
   return /<w:sectPr\b/i.test(paragraph.sourceXml ?? "");
 }
@@ -8910,7 +9263,8 @@ function resolveForeignWrapExclusionsForFlowRange(obstacles, sourceNodeIndex, pa
       left: obstacle.left,
       right: obstacle.right,
       top: Math.max(0, Math.round(obstacle.top - pageFlowTopPx)),
-      bottom: Math.max(0, Math.round(obstacle.bottom - pageFlowTopPx))
+      bottom: Math.max(0, Math.round(obstacle.bottom - pageFlowTopPx)),
+      ...obstacle.fromDragPreview ? { fromDragPreview: true } : void 0
     });
   }
   return foreignExclusions;
@@ -9052,6 +9406,7 @@ function precomputePageSegmentForeignWrapExclusions(segments, model, availableWi
   };
   const baseFlowHeightPxBySegmentIndex = segments.map((segment) => {
     const node = model.nodes[segment.nodeIndex];
+    if (segment.nodeIndex === interaction?.draggedTableIndex) return 0;
     return estimateRenderedPageSegmentHeightPx(
       node,
       segment,
@@ -9068,10 +9423,69 @@ function precomputePageSegmentForeignWrapExclusions(segments, model, availableWi
     );
   });
   const collectObstacles = (flowTopPxBySegmentIndex2, flowHeightPxBySegmentIndex2, previousObstacles) => {
-    const obstacles2 = [];
+    const obstacles2 = interaction?.dragObstacle ? [
+      {
+        ...interaction.dragObstacle,
+        sourceNodeIndex: -1,
+        appliesToSourceNode: true
+      }
+    ] : [];
     for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex += 1) {
       const segment = segments[segmentIndex];
-      const node = model.nodes[segment.nodeIndex];
+      let node = model.nodes[segment.nodeIndex];
+      if (segment.nodeIndex === interaction?.draggedTableIndex) continue;
+      if (node?.type === "paragraph" && interaction?.draggedImageKey?.startsWith(`p:${segment.nodeIndex}:`)) {
+        const childIndex = Number(interaction.draggedImageKey.split(":")[2]);
+        node = {
+          ...node,
+          children: node.children.map(
+            (child, index) => index === childIndex && child.type === "image" ? {
+              ...child,
+              floating: {
+                ...child.floating,
+                wrapType: "none",
+                behindDocument: true
+              }
+            } : child
+          )
+        };
+      }
+      const lineRange = segment.paragraphLineRange;
+      const sliceTop = (lineRange?.startLineIndex ?? 0) * (lineRange?.lineHeightPx ?? 0);
+      if (node?.type === "paragraph" && lineRange) {
+        const paragraph = node;
+        const source = buildParagraphPretextLayoutSource(paragraph);
+        const unwrapped = source ? layoutParagraphPretextSource(
+          paragraph,
+          source,
+          paragraphAvailableTextWidthPx(
+            paragraph,
+            segmentWidthPxAt(segment.nodeIndex),
+            numberingDefinitions
+          ),
+          lineRange.lineHeightPx,
+          []
+        ) : void 0;
+        node = {
+          ...paragraph,
+          children: paragraph.children.map((child, index) => {
+            if (child.type !== "image" || !child.floating || !unwrapped)
+              return child;
+            const anchorTop = resolveCaretRectAtOffset(
+              unwrapped,
+              paragraphChildAnchorOffset(paragraph, index) + 1
+            )?.top ?? 0;
+            return anchorTop >= sliceTop && anchorTop < lineRange.endLineIndex * lineRange.lineHeightPx ? child : {
+              ...child,
+              floating: {
+                ...child.floating,
+                wrapType: "none",
+                behindDocument: true
+              }
+            };
+          })
+        };
+      }
       if (node?.type === "table" && node.style?.floating && !segment.tableRowRange) {
         const tableContainerWidthPx = segmentWidthPxAt(segment.nodeIndex);
         const tableFlowTopPx = flowTopPxBySegmentIndex2[segmentIndex] ?? 0;
@@ -9172,7 +9586,9 @@ function precomputePageSegmentForeignWrapExclusions(segments, model, availableWi
           bottom: band.bottomPx + (floating.distBPx ?? 0)
         });
       });
-      const flowTopPx = measuredBandAt(`para:${segment.nodeIndex}`)?.topPx ?? flowTopPxBySegmentIndex2[segmentIndex] ?? 0;
+      const flowTopPx = (measuredBandAt(
+        `para:${segment.nodeIndex}:${lineRange?.startLineIndex ?? 0}`
+      )?.topPx ?? (!lineRange ? measuredBandAt(`para:${segment.nodeIndex}`)?.topPx : void 0) ?? flowTopPxBySegmentIndex2[segmentIndex] ?? 0) - sliceTop;
       obstacles2.push(
         ...collectPageFlowWrapObstaclesForParagraph(
           node,
@@ -9215,7 +9631,7 @@ function precomputePageSegmentForeignWrapExclusions(segments, model, availableWi
   let flowHeightPxBySegmentIndex = baseFlowHeightPxBySegmentIndex;
   let obstacles = firstPassObstacles;
   const hasInteractionPreview = Boolean(
-    interaction?.floatingMovePreview || interaction?.resizePreview
+    interaction?.floatingMovePreview || interaction?.resizePreview || interaction?.dragObstacle
   );
   const hasFloatingTableObstacle = segments.some((segment) => {
     const node = model.nodes[segment.nodeIndex];
@@ -9297,7 +9713,9 @@ function precomputePageSegmentForeignWrapExclusions(segments, model, availableWi
   const result = segments.map((segment, segmentIndex) => {
     const segmentLineRange = segment.paragraphLineRange;
     const segmentCoversWholeParagraph = !segmentLineRange || segmentLineRange.startLineIndex === 0 && segmentLineRange.endLineIndex >= segmentLineRange.totalLineCount;
-    const measuredParagraphBand = segmentCoversWholeParagraph ? measuredBandAt(`para:${segment.nodeIndex}`) : void 0;
+    const measuredParagraphBand = measuredBandAt(
+      `para:${segment.nodeIndex}:${segmentLineRange?.startLineIndex ?? 0}`
+    ) ?? (segmentCoversWholeParagraph ? measuredBandAt(`para:${segment.nodeIndex}`) : void 0);
     const flowTopPx = measuredParagraphBand?.topPx ?? flowTopPxBySegmentIndex[segmentIndex] ?? 0;
     const flowBottomPx = measuredParagraphBand?.bottomPx ?? flowTopPx + (flowHeightPxBySegmentIndex[segmentIndex] ?? 0);
     return resolveForeignWrapExclusionsForFlowRange(
@@ -10011,13 +10429,7 @@ function buildMeasureSegmentsPretextLayoutItems(segments, paragraphBaseFontPx, t
   }).filter((item) => item.endOffset > item.startOffset);
 }
 function layoutParagraphPretextSource(paragraph, source, containerWidthPx, lineHeightPx, exclusions) {
-  const fallbackFont = resolveMeasureFont(
-    firstRunStyle(paragraph),
-    paragraphBaseFontSizePx(paragraph),
-    source.text
-  );
   const wordBreak = pretextWordBreakModeForText(source.text);
-  const items = buildParagraphPretextLayoutItems(paragraph, source);
   const firstLineIndentPx = twipsToSignedPixels(
     paragraph.style?.indent?.firstLineTwips
   );
@@ -10033,6 +10445,23 @@ function layoutParagraphPretextSource(paragraph, source, containerWidthPx, lineH
       bottom: 1
     }
   ] : exclusions;
+  const uniformFont = resolveUniformPretextSourceFont(paragraph, source);
+  if (uniformFont) {
+    return layoutTextWithPretextAroundExclusions(
+      source.text,
+      uniformFont,
+      containerWidthPx,
+      lineHeightPx,
+      layoutExclusions,
+      { wordBreak }
+    );
+  }
+  const fallbackFont = resolveMeasureFont(
+    firstRunStyle(paragraph),
+    paragraphBaseFontSizePx(paragraph),
+    source.text
+  );
+  const items = buildParagraphPretextLayoutItems(paragraph, source);
   const richLayout = items.length > 0 ? layoutItemsWithPretextAroundExclusions(
     source.text,
     items,
@@ -10168,19 +10597,20 @@ function resolveDualWrappedFloatingImageGeometry(image, containerWidthPx, option
   const paragraphLocalBaseTopPx = !hasExplicitBaseTopPx && paragraphTopPx !== void 0 && (normalizedVerticalRelativeTo === "margin" || normalizedVerticalRelativeTo === "page") ? Math.round(
     (normalizedVerticalRelativeTo === "page" ? baseTopPx - pageMarginTopPx : baseTopPx) - paragraphTopPx
   ) : baseTopPx;
-  const imageLeftPx = clampNumber(
-    baseLeftPx + deltaX,
-    0,
-    Math.max(0, safeContainerWidthPx - imageWidthPx)
-  );
+  const imageLeftPx = baseLeftPx + deltaX;
   const rawImageTopPx = (hasExplicitBaseTopPx ? baseTopPx : paragraphLocalBaseTopPx + (isInlinePreview ? 0 : distTPx)) + deltaY;
   const modelAllowsNegativeTop = Number.isFinite(floating?.yPx) && floating?.yPx < 0;
   const imageTopPx = options?.allowNegativeImageTop || modelAllowsNegativeTop ? Math.round(rawImageTopPx) : Math.max(0, Math.round(rawImageTopPx));
   const horizontalAlignIsOperative = !hasExplicitBaseLeftPx && !Number.isFinite(floating?.xPx);
-  let exclusionLeftPx = Math.max(0, imageLeftPx - distLPx);
-  let exclusionRightPx = Math.min(
-    safeContainerWidthPx,
-    imageLeftPx + imageWidthPx + distRPx
+  let exclusionLeftPx = clampNumber(
+    imageLeftPx - distLPx,
+    0,
+    safeContainerWidthPx
+  );
+  let exclusionRightPx = clampNumber(
+    imageLeftPx + imageWidthPx + distRPx,
+    0,
+    safeContainerWidthPx
   );
   if (wrapType === "topAndBottom") {
     exclusionLeftPx = 0;
@@ -10196,11 +10626,10 @@ function resolveDualWrappedFloatingImageGeometry(image, containerWidthPx, option
       0,
       safeContainerWidthPx - exclusionRightPx
     );
-    const spansInteriorGap = exclusionLeftPx > 0 && exclusionRightPx < safeContainerWidthPx && leftBandWidthPx >= MIN_DUAL_WRAPPED_INTERIOR_BAND_PX && rightBandWidthPx >= MIN_DUAL_WRAPPED_INTERIOR_BAND_PX;
-    const spansSideFloat = exclusionLeftPx === 0 || exclusionRightPx === safeContainerWidthPx;
-    if (!spansInteriorGap && !spansSideFloat) {
-      return void 0;
-    }
+    if (leftBandWidthPx < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX)
+      exclusionLeftPx = 0;
+    if (rightBandWidthPx < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX)
+      exclusionRightPx = safeContainerWidthPx;
   }
   return {
     image,
@@ -10276,6 +10705,18 @@ function resolveParagraphDualWrappedTextLayout(paragraph, containerWidthPx, line
         }
       };
     }
+    if (unexcludedLayout && verticalRelativeTo === "line" && anchorOffset > 0 && !options?.movePreviewByImageIndex?.has(geometry.imageIndex)) {
+      const anchorTop = resolveCaretRectAtOffset(unexcludedLayout, anchorOffset + 1)?.top ?? 0;
+      return {
+        ...geometry,
+        imageTopPx: geometry.imageTopPx + anchorTop,
+        exclusion: {
+          ...geometry.exclusion,
+          top: geometry.exclusion.top + anchorTop,
+          bottom: geometry.exclusion.bottom + anchorTop
+        }
+      };
+    }
     if (!unexcludedLayout || wrapType === "topandbottom" || verticalRelativeTo !== "margin" && verticalRelativeTo !== "page") {
       return geometry;
     }
@@ -10303,7 +10744,7 @@ function resolveParagraphDualWrappedTextLayout(paragraph, containerWidthPx, line
   });
   const mergedExclusions = [
     ...options?.foreignExclusions ?? [],
-    ...anchorAdjustedGeometries.map((geometry) => geometry.exclusion)
+    ...anchorAdjustedGeometries.filter((geometry) => geometry.imageIndex !== options?.excludedImageIndex).map((geometry) => geometry.exclusion)
   ];
   const layout = resolveParagraphPretextExclusionLayout(
     paragraph,
@@ -10691,13 +11132,17 @@ function paragraphBookmarkNames(paragraph) {
   );
   return [...new Set(names)];
 }
+var paragraphNoteReferences = /* @__PURE__ */ new WeakMap();
 function paragraphReferencedNoteIds(paragraph, noteType) {
+  const cached = paragraphNoteReferences.get(paragraph);
+  if (cached?.[noteType]) return cached[noteType];
+  const references = [];
+  paragraphNoteReferences.set(paragraph, { ...cached, [noteType]: references });
   const sourceXml = paragraph.sourceXml ?? "";
   if (!sourceXml) {
-    return [];
+    return references;
   }
   const pattern = noteType === "footnote" ? new RegExp(FOOTNOTE_REFERENCE_XML_PATTERN.source, "gi") : new RegExp(ENDNOTE_REFERENCE_XML_PATTERN.source, "gi");
-  const references = [];
   for (const match of sourceXml.matchAll(pattern)) {
     const rawId = Number(match[1]);
     if (!Number.isFinite(rawId) || rawId < 0) {
@@ -10735,7 +11180,7 @@ function eventTargetIsInteractiveControl(target) {
     return false;
   }
   return Boolean(
-    target.closest("a[href],button,input,select,textarea,[role='checkbox']")
+    target.closest("a[href],button,input,select,textarea,[role='checkbox'],[data-docx-textbox-editor='true']")
   );
 }
 function eventTargetIsNestedTableParagraphEditor(target) {
@@ -12922,6 +13367,111 @@ function paragraphCanSplitAcrossPages(paragraph, lineCount, options) {
   }
   return true;
 }
+function createTextEditPaginationMemo() {
+  const entries = /* @__PURE__ */ new Map();
+  const containsFloatingObjects = /* @__PURE__ */ new WeakMap();
+  const hasFloatingObjects = (node) => {
+    const cached = containsFloatingObjects.get(node);
+    if (cached !== void 0) return cached;
+    const result = node.type === "paragraph" ? node.children.some(
+      (child) => child.type === "image" && child.floating
+    ) : Boolean(node.style?.floating) || node.rows.some(
+      (row) => row.cells.some((cell) => cell.nodes.some(hasFloatingObjects))
+    );
+    containsFloatingObjects.set(node, result);
+    return result;
+  };
+  return (model, height, width, numberingDefinitions, metrics, options) => {
+    if (model.nodes.some(hasFloatingObjects)) {
+      return buildDocumentPageNodeSegments(
+        model,
+        height,
+        width,
+        numberingDefinitions,
+        metrics,
+        options
+      );
+    }
+    const key = JSON.stringify([
+      height,
+      width,
+      metrics,
+      getFontMetricsRevision(),
+      {
+        ...options,
+        measuredParagraphOuterHeightsPxByNodeIndex: options?.measuredParagraphOuterHeightsPxByNodeIndex ? [...options.measuredParagraphOuterHeightsPxByNodeIndex] : void 0,
+        precomputedNumberingLabels: options?.precomputedNumberingLabels ? [...options.precomputedNumberingLabels] : void 0
+      }
+    ]);
+    const cached = entries.get(key);
+    const sameGeometry = cached && cached.model.metadata === model.metadata && cached.numberingDefinitions === numberingDefinitions && cached.model.nodes.length === model.nodes.length && model.nodes.every((node, index) => {
+      const previous = cached.model.nodes[index];
+      if (node === previous) return true;
+      if (node.type !== "paragraph" || previous?.type !== "paragraph" || node.sourceXml !== previous.sourceXml || JSON.stringify(node.style) !== JSON.stringify(previous.style) || ![node, previous].every(
+        (paragraph) => paragraph.children.every(
+          (child) => child.type === "text" && !child.noteReference && !/[\r\n\t\f\v\u2028\u2029]/.test(child.text)
+        )
+      ) || paragraphHasOnlyWhitespaceText(node) !== paragraphHasOnlyWhitespaceText(previous)) {
+        return false;
+      }
+      const source = buildParagraphPretextLayoutSource(node);
+      const previousSource = buildParagraphPretextLayoutSource(previous);
+      if (!source || !previousSource || !resolveUniformPretextSourceFont(node, source) || !resolveUniformPretextSourceFont(previous, previousSource))
+        return false;
+      const label = options?.precomputedNumberingLabels?.get(`p:${index}`);
+      if (!label && paragraphHasActiveNumbering(node)) return false;
+      const sectionIndex = resolvePaginationSectionMetricsIndexForNodeIndex(
+        metrics ?? [],
+        index,
+        0
+      );
+      const section = metrics?.[sectionIndex];
+      const contentWidth = section?.pageContentWidthPx ?? width;
+      const pitch = section?.docGridLinePitchPx;
+      return estimateParagraphLineHeightPx(node, pitch) === estimateParagraphLineHeightPx(previous, pitch) && paragraphLineCountWithinWidth(
+        node,
+        contentWidth,
+        numberingDefinitions,
+        label
+      ) === paragraphLineCountWithinWidth(
+        previous,
+        contentWidth,
+        numberingDefinitions,
+        label
+      ) && estimateParagraphHeightPx(
+        node,
+        contentWidth,
+        numberingDefinitions,
+        pitch,
+        false,
+        label
+      ) === estimateParagraphHeightPx(
+        previous,
+        contentWidth,
+        numberingDefinitions,
+        pitch,
+        false,
+        label
+      );
+    });
+    if (sameGeometry && cached) {
+      cached.model = model;
+      return cached.pages;
+    }
+    const pages = buildDocumentPageNodeSegments(
+      model,
+      height,
+      width,
+      numberingDefinitions,
+      metrics,
+      options
+    );
+    if (entries.size >= 8 && !entries.has(key))
+      entries.delete(entries.keys().next().value);
+    entries.set(key, { model, numberingDefinitions, pages });
+    return pages;
+  };
+}
 function paragraphSegmentHasPartialLineRange(paragraphLineRange) {
   if (!paragraphLineRange) {
     return false;
@@ -14331,6 +14881,30 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
   if (currentPageSegments.length > 0 || pages.length === 0) {
     pages.push(currentPageSegments);
   }
+  return keepTextAnchoredTablesWithFollowingParagraph(pages, model);
+}
+function keepTextAnchoredTablesWithFollowingParagraph(pages, model) {
+  for (let pageIndex = 0; pageIndex < pages.length - 1; pageIndex++) {
+    const current = pages[pageIndex];
+    const next = pages[pageIndex + 1];
+    const first = next[0];
+    const paragraph = first && model.nodes[first.nodeIndex];
+    if (paragraph?.type !== "paragraph" || (first.paragraphLineRange?.startLineIndex ?? 0) > 0 || model.metadata.sections?.some(
+      (section) => section.startNodeIndex === first.nodeIndex
+    ))
+      continue;
+    while (current.length) {
+      const last = current[current.length - 1];
+      const table = model.nodes[last.nodeIndex];
+      const anchor = table?.type === "table" ? table.style?.floating?.verticalAnchor : void 0;
+      if (anchor !== "text" || last.nodeIndex + 1 !== next[0].nodeIndex) break;
+      next.unshift(current.pop());
+    }
+    if (!current.length) {
+      pages.splice(pageIndex, 1);
+      pageIndex--;
+    }
+  }
   return pages;
 }
 function shouldRenderWrappedFloatingImage(image) {
@@ -14643,7 +15217,7 @@ function resolveWrappedFloatingImageDropPatch(image, hostWidth, movedLeft, moved
   );
   const previewUsesSideFloat = previewGeometry === void 0 || previewGeometry.exclusion.left <= 0 || previewGeometry.exclusion.right >= hostWidth;
   const explicitTopPx = Math.round(
-    movedTop - Math.round(baseFloating.distTPx ?? 0)
+    movedTop - Math.round(baseFloating.distTPx ?? 2)
   );
   return {
     wrapType,
@@ -14651,8 +15225,8 @@ function resolveWrappedFloatingImageDropPatch(image, hostWidth, movedLeft, moved
     horizontalAlign: preserveAlignedHorizontalPlacement ? baseFloating.horizontalAlign : previewUsesSideFloat ? side : wrapText === "bothSides" || wrapText === "largest" ? void 0 : side,
     xPx: preserveAlignedHorizontalPlacement ? void 0 : Math.round(movedLeft),
     yPx: explicitTopPx,
-    distLPx: Math.max(4, Math.round(baseFloating.distLPx ?? 8)),
-    distRPx: Math.max(4, Math.round(baseFloating.distRPx ?? 8)),
+    distLPx: Math.max(0, Math.round(baseFloating.distLPx ?? 8)),
+    distRPx: Math.max(0, Math.round(baseFloating.distRPx ?? 8)),
     distTPx: Math.max(0, Math.round(baseFloating.distTPx ?? 2)),
     distBPx: Math.max(0, Math.round(baseFloating.distBPx ?? 4)),
     horizontalRelativeTo: convertFixedPositionToMoveWithText ? "column" : baseFloating.horizontalRelativeTo ?? "column",
@@ -14694,13 +15268,6 @@ function resolveWrappedDropAnchorParagraphHost(wrapperElement, droppedTopScreenP
   }
   return best;
 }
-function wrappedDragCanReanchorToParagraph(floating) {
-  if (!floatingImageMovesWithText(floating)) {
-    return true;
-  }
-  const verticalRelativeTo = floating.verticalRelativeTo?.trim().toLowerCase() ?? "";
-  return verticalRelativeTo === "" || verticalRelativeTo === "paragraph" || verticalRelativeTo === "line";
-}
 function resolvePageSpanningAbsoluteFloatingDimensions(image, widthPx, heightPx, floatingPageOriginPx) {
   const floating = image.floating;
   const pageWidthPx = Number.isFinite(floatingPageOriginPx?.pageWidth) ? Math.max(1, Math.round(floatingPageOriginPx?.pageWidth)) : void 0;
@@ -16948,6 +17515,7 @@ function paragraphStyleRefFieldValueSequence(paragraph) {
 function normalizeStyleRefTarget(value) {
   return value.replace(/\s+/g, " ").trim().toLowerCase();
 }
+var styledRunTextByParagraph = /* @__PURE__ */ new WeakMap();
 function paragraphStyledRunText(paragraph, styleRefTarget) {
   const xml = paragraph.sourceXml ?? "";
   if (!xml) {
@@ -16957,6 +17525,12 @@ function paragraphStyledRunText(paragraph, styleRefTarget) {
   if (!normalizedTarget) {
     return void 0;
   }
+  let cached = styledRunTextByParagraph.get(paragraph);
+  if (cached?.has(normalizedTarget)) return cached.get(normalizedTarget);
+  if (!cached) {
+    cached = /* @__PURE__ */ new Map();
+    styledRunTextByParagraph.set(paragraph, cached);
+  }
   const textChunks = [];
   for (const runMatch of xml.matchAll(/<w:r\b[\s\S]*?<\/w:r>/gi)) {
     const runXml = runMatch[0] ?? "";
@@ -16981,7 +17555,9 @@ function paragraphStyledRunText(paragraph, styleRefTarget) {
     }
   }
   const joined = textChunks.join("").trim();
-  return joined.length > 0 ? joined : void 0;
+  const result = joined.length > 0 ? joined : void 0;
+  setCacheEntry(cached, normalizedTarget, result);
+  return result;
 }
 function tabLeaderStyle(leader, color) {
   const normalizedLeader = leader === "middleDot" ? "dot" : leader;
@@ -20550,45 +21126,6 @@ function imageLocationKey(location) {
 function dropTargetKey(target) {
   return `${paragraphLocationKey(target)}:${target.childIndex}`;
 }
-function parseImageDropTargetFromDataset(dataset) {
-  const kind = dataset.docxTargetKind;
-  const childIndex = Number.parseInt(dataset.docxChildIndex ?? "", 10);
-  if (!Number.isFinite(childIndex) || childIndex < 0) {
-    return void 0;
-  }
-  if (kind === "paragraph") {
-    const nodeIndex = Number.parseInt(dataset.docxNodeIndex ?? "", 10);
-    if (!Number.isFinite(nodeIndex) || nodeIndex < 0) {
-      return void 0;
-    }
-    return {
-      kind: "paragraph",
-      nodeIndex,
-      childIndex
-    };
-  }
-  if (kind === "table-cell") {
-    const tableIndex = Number.parseInt(dataset.docxTableIndex ?? "", 10);
-    const rowIndex = Number.parseInt(dataset.docxRowIndex ?? "", 10);
-    const cellIndex = Number.parseInt(dataset.docxCellIndex ?? "", 10);
-    const paragraphIndex = Number.parseInt(
-      dataset.docxParagraphIndex ?? "",
-      10
-    );
-    if (!Number.isFinite(tableIndex) || !Number.isFinite(rowIndex) || !Number.isFinite(cellIndex) || !Number.isFinite(paragraphIndex) || tableIndex < 0 || rowIndex < 0 || cellIndex < 0 || paragraphIndex < 0) {
-      return void 0;
-    }
-    return {
-      kind: "table-cell",
-      tableIndex,
-      rowIndex,
-      cellIndex,
-      paragraphIndex,
-      childIndex
-    };
-  }
-  return void 0;
-}
 function firstTableCellAnchorLocation(table, tableIndex) {
   for (let rowIndex = 0; rowIndex < table.rows.length; rowIndex += 1) {
     const row = table.rows[rowIndex];
@@ -22275,19 +22812,18 @@ function updateSectionImageFloatingAtLocation(model, location, patch) {
   return changed ? next : model;
 }
 function useDocxEditor(options = {}) {
-  const starterTemplateRef = React.useRef(
-    cloneDocModelWithBlockIds(options.starterModel ?? defaultStarterModel)
+  const [starterTemplate] = React.useState(
+    () => cloneDocModelWithBlockIds(options.starterModel ?? defaultStarterModel)
   );
-  const initialModelRef = React.useRef(
-    cloneDocModelWithBlockIds(
-      options.document?.model ?? starterTemplateRef.current
-    )
+  const starterTemplateRef = React.useRef(starterTemplate);
+  const [initialModel] = React.useState(
+    () => cloneDocModelWithBlockIds(options.document?.model ?? starterTemplate)
   );
   const [editorState, dispatchCanonicalEditorState] = React.useReducer(
     reduceDocxEditorState,
-    initialModelRef.current,
-    (initialModel) => ({
-      model: cloneDocModelWithBlockIds(initialModel),
+    initialModel,
+    (initialModel2) => ({
+      model: cloneDocModelWithBlockIds(initialModel2),
       selection: {
         kind: "paragraph",
         nodeIndex: 0
@@ -22489,8 +23025,10 @@ function useDocxEditor(options = {}) {
         window.clearTimeout(selectionSessionTimeoutRef.current);
       }
       selectionSessionTimeoutRef.current = null;
-      selectionSessionRef.current = "idle";
-      setSelectionSessionKind("idle");
+      if (selectionSessionRef.current !== "idle") {
+        selectionSessionRef.current = "idle";
+        setSelectionSessionKind("idle");
+      }
     },
     []
   );
@@ -22500,8 +23038,10 @@ function useDocxEditor(options = {}) {
         window.clearTimeout(selectionSessionTimeoutRef.current);
       }
       selectionSessionTimeoutRef.current = null;
-      selectionSessionRef.current = kind;
-      setSelectionSessionKind(kind);
+      if (selectionSessionRef.current !== kind) {
+        selectionSessionRef.current = kind;
+        setSelectionSessionKind(kind);
+      }
       if (Number.isFinite(options2?.settleAfterMs) && options2?.settleAfterMs > 0 && typeof window !== "undefined") {
         const expectedKind = kind;
         selectionSessionTimeoutRef.current = window.setTimeout(() => {
@@ -22750,6 +23290,9 @@ function useDocxEditor(options = {}) {
         }
       });
     }
+    if (loadedEmbeddedFontFacesRef.current.length > 0) {
+      invalidateFontMetrics();
+    }
     loadedEmbeddedFontFacesRef.current = [];
   }, []);
   const loadEmbeddedFontsFromPackage = React.useCallback(
@@ -22789,6 +23332,9 @@ function useDocxEditor(options = {}) {
         document.fonts.add(fontFace);
       });
       loadedEmbeddedFontFacesRef.current = loadedFontFaces;
+      if (loadedFontFaces.length > 0) {
+        invalidateFontMetrics();
+      }
       try {
         await document.fonts.ready;
       } catch {
@@ -22892,7 +23438,8 @@ function useDocxEditor(options = {}) {
         setHistoryRestoreRequest({
           nonce: nextNonce,
           selection: cloneEditorSelection(next.selection),
-          activeTextRange: cloneTextRange(next.activeTextRange)
+          activeTextRange: cloneTextRange(next.activeTextRange),
+          textInput: patch.textInput
         });
       }
       if (patch.clearSelectedFormField) {
@@ -23176,7 +23723,8 @@ function useDocxEditor(options = {}) {
         markDocxImportPerformance(workerStartMark);
         const importResult = await importDocxBuffer(buffer, {
           signal: importAbortController.signal,
-          transferBuffer: true
+          transferBuffer: true,
+          useWorker: "required"
         });
         markDocxImportPerformance(workerEndMark);
         measureDocxImportPerformance(
@@ -25249,7 +25797,16 @@ function useDocxEditor(options = {}) {
   const moveFloatingImage = React.useCallback(
     (location, patch, options2) => {
       applyModelChange((current) => {
-        const next = cloneDocModel(current);
+        const sourceLocation = imageLocationToParagraphLocation(location);
+        const next = copyModelForParagraphEdits(current, [
+          sourceLocation,
+          ...options2?.reparentToParagraphNodeIndex !== void 0 ? [
+            {
+              kind: "paragraph",
+              nodeIndex: options2.reparentToParagraphNodeIndex
+            }
+          ] : []
+        ]);
         const { paragraph, tableNode } = getParagraphAtLocation(
           next,
           imageLocationToParagraphLocation(location)
@@ -25257,22 +25814,32 @@ function useDocxEditor(options = {}) {
         if (!paragraph) {
           return current;
         }
-        const child = paragraph.children[location.childIndex];
-        if (!child || child.type !== "image") {
+        const sourceChild = paragraph.children[location.childIndex];
+        if (!sourceChild || sourceChild.type !== "image") {
           return current;
         }
-        child.floating = {
-          ...child.floating ?? {},
-          ...patch
+        const child = {
+          ...sourceChild,
+          floating: { ...sourceChild.floating, ...patch }
         };
+        paragraph.children[location.childIndex] = child;
         const reparentNodeIndex = options2?.reparentToParagraphNodeIndex;
         const reparentTarget = reparentNodeIndex !== void 0 ? next.nodes[reparentNodeIndex] : void 0;
-        if (reparentTarget && reparentTarget.type === "paragraph" && reparentTarget !== paragraph) {
+        if (reparentTarget?.type === "paragraph" && (reparentTarget !== paragraph || options2?.anchorTextOffset !== void 0)) {
           paragraph.children.splice(location.childIndex, 1);
-          if (paragraph.children.length === 0) {
+          const target = imageDropPositionAtTextOffset(
+            reparentTarget,
+            options2?.anchorTextOffset ?? 0,
+            { fieldText: formFieldDisplayValue2 }
+          );
+          insertImageAtDropPosition(
+            reparentTarget,
+            child,
+            target.childIndex,
+            target.textOffset
+          );
+          if (paragraph.children.length === 0)
             paragraph.children.push({ type: "text", text: "" });
-          }
-          reparentTarget.children.unshift(child);
           reparentTarget.sourceXml = void 0;
         }
         paragraph.sourceXml = void 0;
@@ -25406,11 +25973,14 @@ function useDocxEditor(options = {}) {
       if (sameParagraphLocation(
         sourceParagraphLocation,
         targetParagraphLocation
-      ) && (target.childIndex === source.childIndex || target.childIndex === source.childIndex + 1)) {
+      ) && target.textOffset === void 0 && (target.childIndex === source.childIndex || target.childIndex === source.childIndex + 1)) {
         return;
       }
       applyModelChange((current) => {
-        const next = cloneDocModel(current);
+        const next = copyModelForParagraphEdits(current, [
+          sourceParagraphLocation,
+          targetParagraphLocation
+        ]);
         const sourceLookup = getParagraphAtLocation(
           next,
           sourceParagraphLocation
@@ -25430,21 +26000,19 @@ function useDocxEditor(options = {}) {
         }
         const movedImage = {
           ...sourceChild,
-          data: sourceChild.data ? new Uint8Array(sourceChild.data) : void 0,
           floating: sourceChild.floating ? { ...sourceChild.floating } : void 0
         };
         sourceParagraph.children.splice(source.childIndex, 1);
-        let insertionIndex = Math.max(
-          0,
-          Math.min(target.childIndex, targetParagraph.children.length)
-        );
-        if (sameParagraphLocation(
+        const insertionIndex = target.childIndex - (sameParagraphLocation(
           sourceParagraphLocation,
           targetParagraphLocation
-        ) && source.childIndex < insertionIndex) {
-          insertionIndex -= 1;
-        }
-        targetParagraph.children.splice(insertionIndex, 0, movedImage);
+        ) && source.childIndex < target.childIndex ? 1 : 0);
+        insertImageAtDropPosition(
+          targetParagraph,
+          movedImage,
+          insertionIndex,
+          target.textOffset
+        );
         if (sourceParagraph.children.length === 0) {
           sourceParagraph.children.push({ type: "text", text: "" });
         }
@@ -25705,11 +26273,12 @@ function useDocxEditor(options = {}) {
         if (!tableNode || tableNode.type !== "table") {
           return current;
         }
-        const next = cloneDocModel(current);
-        const nextTable = next.nodes[tableIndex];
-        if (!nextTable || nextTable.type !== "table") {
-          return current;
-        }
+        const next = copyModelForParagraphEdits(
+          current,
+          options2?.moveToNodeIndex !== void 0 ? [{ kind: "paragraph", nodeIndex: options2.moveToNodeIndex }] : []
+        );
+        const nextTable = { ...tableNode };
+        next.nodes[tableIndex] = nextTable;
         nextTable.style = {
           ...nextTable.style ?? {},
           floating: {
@@ -25718,25 +26287,43 @@ function useDocxEditor(options = {}) {
           }
         };
         nextTable.sourceXml = void 0;
-        const moveToNodeIndex = options2?.moveToNodeIndex;
-        if (moveToNodeIndex !== void 0 && moveToNodeIndex !== tableIndex && moveToNodeIndex !== tableIndex + 1) {
-          const clampedTarget = clampNumber(
-            moveToNodeIndex,
+        let moveToNodeIndex = options2?.moveToNodeIndex;
+        const anchorParagraph = moveToNodeIndex !== void 0 ? next.nodes[moveToNodeIndex] : void 0;
+        if (anchorParagraph?.type === "paragraph" && options2?.anchorTextOffset !== void 0 && options2.anchorTextOffset > 0) {
+          const split = splitParagraphChildrenAtTextOffsets(
+            anchorParagraph,
+            paragraphText(anchorParagraph),
+            options2.anchorTextOffset,
+            options2.anchorTextOffset
+          );
+          const after = {
+            ...anchorParagraph,
+            blockId: allocateBlockId(),
+            children: split.afterChildren,
+            sourceXml: void 0,
+            style: {
+              ...anchorParagraph.style,
+              spacing: { ...anchorParagraph.style?.spacing, beforeTwips: 0 }
+            }
+          };
+          anchorParagraph.children = split.beforeChildren;
+          anchorParagraph.sourceXml = void 0;
+          anchorParagraph.style = {
+            ...anchorParagraph.style,
+            spacing: { ...anchorParagraph.style?.spacing, afterTwips: 0 }
+          };
+          moveToNodeIndex = moveToNodeIndex + 1;
+          next.nodes.splice(moveToNodeIndex, 0, after);
+        }
+        const sourceIndex = next.nodes.indexOf(nextTable);
+        if (moveToNodeIndex !== void 0 && moveToNodeIndex !== sourceIndex && moveToNodeIndex !== sourceIndex + 1) {
+          const target = clampNumber(moveToNodeIndex, 0, next.nodes.length);
+          next.nodes.splice(sourceIndex, 1);
+          next.nodes.splice(
+            target > sourceIndex ? target - 1 : target,
             0,
-            next.nodes.length
+            nextTable
           );
-          const extracted = next.nodes.splice(tableIndex, 1)[0];
-          if (extracted) {
-            next.nodes.splice(
-              clampNumber(
-                clampedTarget > tableIndex ? clampedTarget - 1 : clampedTarget,
-                0,
-                next.nodes.length
-              ),
-              0,
-              extracted
-            );
-          }
         }
         return next;
       }, "Moved table");
@@ -26232,7 +26819,8 @@ function useDocxEditor(options = {}) {
             }
           },
           pushHistory: !coalesce,
-          clearSelectedFormField: true
+          clearSelectedFormField: true,
+          textInput: true
         };
       });
     },
@@ -26284,7 +26872,8 @@ function useDocxEditor(options = {}) {
               offset: caret.end
             }
           },
-          clearSelectedFormField: true
+          clearSelectedFormField: true,
+          textInput: true
         };
       });
     },
@@ -27191,11 +27780,16 @@ function useDocxPageThumbnails(editor, options = {}) {
     () => ensureDocxViewerPageSurfaceRegistry(pageSurfaceRegistryEditor),
     [pageSurfaceRegistryEditor]
   );
+  const hasRequestedThumbnails = options.pageIndexes?.length !== 0;
   React.useEffect(
-    () => subscribeDocxViewerPageSurfaces(pageSurfaceRegistryEditor, () => {
+    () => {
+      if (!hasRequestedThumbnails) return;
       setPageSurfaceEpoch((current) => current + 1);
-    }),
-    [pageSurfaceRegistryEditor]
+      return subscribeDocxViewerPageSurfaces(pageSurfaceRegistryEditor, () => {
+        setPageSurfaceEpoch((current) => current + 1);
+      });
+    },
+    [hasRequestedThumbnails, pageSurfaceRegistryEditor]
   );
   const mountedPageElements = React.useMemo(
     () => new Map(pageSurfaceRegistry.pageElements),
@@ -28899,6 +29493,11 @@ function DocxEditorViewer({
   onFormFieldDoubleClick,
   mode = "edit"
 }) {
+  const fontMetricsRevision = React.useSyncExternalStore(
+    subscribeFontMetrics,
+    getFontMetricsRevision,
+    getServerFontMetricsRevision
+  );
   const pageSurfaceRegistryOwner = docxViewerPageSurfaceRegistryOwner(editor);
   const trackedChangesEnabled = showTrackedChanges ?? editor.showTrackedChanges;
   const hasTrackedChanges = editor.trackedChanges.length > 0;
@@ -28938,6 +29537,9 @@ function DocxEditorViewer({
   );
   const viewerRootRef = React.useRef(null);
   const tableCellDraftsRef = React.useRef(/* @__PURE__ */ new Map());
+  const plainParagraphHtmlCacheRef = React.useRef(
+    /* @__PURE__ */ new WeakMap()
+  );
   const editableParagraphHtmlPropsRef = React.useRef(/* @__PURE__ */ new Map());
   const editableTableCellHtmlPropsRef = React.useRef(/* @__PURE__ */ new Map());
   const tableCellParagraphDraftsRef = React.useRef(
@@ -29232,7 +29834,9 @@ function DocxEditorViewer({
   const suppressNextTableCellClickRef = React.useRef(false);
   const [tableCellSelectionRange, setTableCellSelectionRange] = React.useState();
   const [tableMoveDropPreview, setTableMoveDropPreview] = React.useState();
-  const [tableFloatingDragPreview, setTableFloatingDragPreview] = React.useState();
+  const [objectWrapDragPreview, setObjectWrapDragPreview] = React.useState();
+  const objectDragCleanupRef = React.useRef(void 0);
+  React.useEffect(() => () => objectDragCleanupRef.current?.(), [editor.documentLoadNonce, editor.model, isReadOnly]);
   const [tableContextMenuState, setTableContextMenuState] = React.useState();
   const [contextMenuState, setContextMenuState] = React.useState();
   const [activeHeaderFooterEdit, setActiveHeaderFooterEdit] = React.useState();
@@ -29277,7 +29881,6 @@ function DocxEditorViewer({
       if (typeof window === "undefined") {
         return;
       }
-      setPostImportPaginationUnlocked(true);
       const safeDelayMs = Math.max(
         48,
         Math.round(delayMs ?? PAGINATION_MEASUREMENT_INTERACTION_DEBOUNCE_MS)
@@ -29288,6 +29891,7 @@ function DocxEditorViewer({
       }
       paginationMeasurementResumeTimeoutRef.current = window.setTimeout(() => {
         paginationMeasurementResumeTimeoutRef.current = null;
+        setPostImportPaginationUnlocked(true);
         bumpPaginationMeasurementEpoch();
       }, safeDelayMs + 16);
     },
@@ -29367,7 +29971,6 @@ function DocxEditorViewer({
     setHoveredEmbeddedTableKey(void 0);
     setFocusedEmbeddedTableKey(void 0);
     setTableMoveDropPreview(void 0);
-    setTableFloatingDragPreview(void 0);
     tableMoveDragRef.current = void 0;
     setTableContextMenuState(void 0);
     setContextMenuState(void 0);
@@ -29488,10 +30091,26 @@ function DocxEditorViewer({
       Math.round(documentLayout.marginsPx.left),
       Math.round(documentLayout.marginsPx.right),
       trackedChangesEnabled ? "tc1" : "tc0",
+      fontMetricsRevision,
       docNodeContentSignature(paginationSectionMetrics)
     ].join("|"),
-    [documentLayout, paginationSectionMetrics, trackedChangesEnabled]
+    [
+      documentLayout,
+      fontMetricsRevision,
+      paginationSectionMetrics,
+      trackedChangesEnabled
+    ]
   );
+  React.useEffect(() => {
+    setMeasuredPageContentHeightByIndex((current) => current.length ? [] : current);
+    setMeasuredPageContentIdentityKeysByIndex(
+      (current) => current.length ? [] : current
+    );
+    setMeasuredPageContentValidationByIndex(
+      (current) => current.length ? [] : current
+    );
+    setHasMeasuredBodyFooterOverlap(false);
+  }, [fontMetricsRevision]);
   React.useEffect(() => {
     setMeasuredParagraphOuterHeightsPxByBlockId(
       (current) => current.size === 0 ? current : /* @__PURE__ */ new Map()
@@ -29550,7 +30169,7 @@ function DocxEditorViewer({
       pageContentWidthPxByNodeIndex: widthByNodeIndex,
       pageContentHeightPxByNodeIndex: heightByNodeIndex
     };
-  }, [editor.model.nodes, paginationSectionMetrics]);
+  }, [editor.model.nodes.length, paginationSectionMetrics]);
   const sectionColumnsBySectionIndex = React.useMemo(
     () => documentSections.map(
       (section) => parseSectionColumns(section.sectionPropertiesXml)
@@ -29561,6 +30180,23 @@ function DocxEditorViewer({
     () => buildParagraphNumberingLabels(editor.model),
     [editor.model]
   );
+  const noteMarkerIndexes = React.useMemo(
+    () => ({
+      footnote: new Map(
+        editor.model.metadata.footnotes?.map((note, index) => [
+          note.id,
+          index + 1
+        ])
+      ),
+      endnote: new Map(
+        editor.model.metadata.endnotes?.map((note, index) => [
+          note.id,
+          index + 1
+        ])
+      )
+    }),
+    [editor.model.metadata.footnotes, editor.model.metadata.endnotes]
+  );
   const bookmarkTargetNodeIndexByName = React.useMemo(() => {
     const targets = /* @__PURE__ */ new Map();
     editor.model.nodes.forEach((node, nodeIndex) => {
@@ -29617,6 +30253,9 @@ function DocxEditorViewer({
     tableDraftLayoutEpoch,
     tableMeasuredRowHeights
   ]);
+  const textEditPaginationMemo = React.useRef(null);
+  if (!textEditPaginationMemo.current)
+    textEditPaginationMemo.current = createTextEditPaginationMemo();
   const pageSegmentationPlan = React.useMemo(() => {
     const pageContentHeightPx = Math.max(
       120,
@@ -29637,7 +30276,7 @@ function DocxEditorViewer({
     const canUseMeasuredPageContentHeights = !disableMeasuredImportPagination && !floatingMovePreview && !dropCapMovePreview && (measuredPageContentHeightsPxForPagination?.length ?? 0) > 0;
     const buildEstimatedPagesForInputs = createEstimatedPagesBuildMemo(
       (measuredTableRowHeightsByNodeIndex, measuredPageContentHeightsPx, strictLastRenderedParagraphStartBreaks) => {
-        const buildPagesWithHeights = (resolvedPageContentHeights) => buildDocumentPageNodeSegments(
+        const buildPagesWithHeights = (resolvedPageContentHeights) => textEditPaginationMemo.current(
           editor.model,
           pageContentHeightPx,
           pageContentWidthPx,
@@ -30452,7 +31091,7 @@ function DocxEditorViewer({
     [explicitPageVirtualizationZoomScale]
   );
   React.useEffect(() => {
-    if (floatingMovePreview || resizePreview || tableFloatingDragPreview || tableMoveDragRef.current) {
+    if (floatingMovePreview || objectWrapDragPreview || resizePreview || tableMoveDragRef.current) {
       return;
     }
     const modelChanged = wrapBandReconcileModelRef.current !== editor.model;
@@ -30490,6 +31129,8 @@ function DocxEditorViewer({
         }
         pageHasFloatingObject = true;
         fresh.set(`tbl:${nodeIndex}`, toBand(element.getBoundingClientRect()));
+        const host = element.closest("[data-docx-floating-table-host]");
+        if (host) fresh.set(`tblanchor:${nodeIndex}`, toBand(host.getBoundingClientRect()));
       });
       bodyElement.querySelectorAll("[data-docx-image-location]").forEach((span) => {
         if (!(span instanceof HTMLElement)) {
@@ -30540,6 +31181,10 @@ function DocxEditorViewer({
         }
         fresh.set(`para:${nodeIndex}`, toBand(rect));
       });
+      bodyElement.querySelectorAll("[data-docx-paragraph-host='true'][data-docx-paragraph-kind='paragraph']").forEach((element) => {
+        const rect = element.getBoundingClientRect();
+        if (rect.height > 0) fresh.set(`para:${element.dataset.docxParagraphNodeIndex}:${element.dataset.docxParagraphStartLine ?? 0}`, toBand(rect));
+      });
     });
     const withinTolerance = (previous, candidate) => Math.abs(previous.topPx - candidate.topPx) <= WRAP_BAND_RECONCILE_TOLERANCE_PX && Math.abs(previous.bottomPx - candidate.bottomPx) <= WRAP_BAND_RECONCILE_TOLERANCE_PX && Math.abs(previous.leftPx - candidate.leftPx) <= WRAP_BAND_RECONCILE_TOLERANCE_PX && Math.abs(previous.rightPx - candidate.rightPx) <= WRAP_BAND_RECONCILE_TOLERANCE_PX;
     const next = /* @__PURE__ */ new Map();
@@ -30692,11 +31337,18 @@ function DocxEditorViewer({
     overscan: pageVirtualizationOverscan
   });
   const internalPageVirtualizer = internalVirtualScrollUsesWindow ? internalWindowPageVirtualizer : internalElementPageVirtualizer;
+  const virtualPageHeightSignature = pageSectionInfoByIndex.map(
+    ({ layout }) => Math.round(
+      (layout.pageHeightPx + DOC_PAGE_BREAK_GAP) * virtualizerMeasurementScale
+    )
+  ).join("|");
   React.useLayoutEffect(() => {
     internalElementPageVirtualizer.measure();
     internalWindowPageVirtualizer.measure();
   }, [
-    estimateVirtualPageSize,
+    virtualPageHeightSignature,
+    documentLayout.pageHeightPx,
+    virtualizerMeasurementScale,
     internalElementPageVirtualizer,
     internalWindowPageVirtualizer
   ]);
@@ -32357,16 +33009,126 @@ function DocxEditorViewer({
     },
     [editor.model.nodes.length]
   );
+  const objectWrapDragSignatureRef = React.useRef("");
+  const objectWrapDragLatestRef = React.useRef(void 0);
+  const updateObjectWrapDragPreview = React.useCallback(
+    (frame, source, distances) => {
+      const bandsByPage = /* @__PURE__ */ new Map();
+      let pageIndex = -1;
+      let closestDistance = Infinity;
+      let obstacle;
+      pageBodyElementsRef.current.forEach((body, index) => {
+        if (!body.isConnected) return;
+        const origin = body.getBoundingClientRect();
+        const scale = resolveViewerMeasurementZoomScale(body, 1);
+        const surface = body.closest("[data-docx-page-surface='true']")?.getBoundingClientRect() ?? origin;
+        if (surface.bottom < -frame.height || surface.top > window.innerHeight + frame.height)
+          return;
+        const distance = Math.max(surface.top - frame.top, frame.top - surface.bottom, 0) + Math.max(surface.left - frame.left, frame.left - surface.right, 0);
+        if (distance < closestDistance) {
+          closestDistance = distance;
+          pageIndex = index;
+          if (distances) {
+            const width = origin.width / scale;
+            let left = Math.max(
+              0,
+              (frame.left - origin.left) / scale - distances.left
+            );
+            let right = Math.min(
+              width,
+              (frame.left + frame.width - origin.left) / scale + distances.right
+            );
+            if (distances.fullWidth || left < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX)
+              left = 0;
+            if (distances.fullWidth || width - right < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX)
+              right = width;
+            obstacle = {
+              left,
+              right,
+              top: (frame.top - origin.top) / scale - distances.top,
+              bottom: (frame.top + frame.height - origin.top) / scale + distances.bottom,
+              fromDragPreview: true
+            };
+          }
+        }
+        const bands = /* @__PURE__ */ new Map();
+        const record = (key, element) => {
+          if (!element.isConnected || !body.contains(element)) return;
+          const rect = element.getBoundingClientRect();
+          bands.set(key, {
+            topPx: (rect.top - origin.top) / scale,
+            bottomPx: (rect.bottom - origin.top) / scale,
+            leftPx: (rect.left - origin.left) / scale,
+            rightPx: (rect.right - origin.left) / scale
+          });
+        };
+        paragraphElementsRef.current.forEach(
+          (element, nodeIndex) => record(`para:${nodeIndex}`, element)
+        );
+        body.querySelectorAll(
+          "[data-docx-paragraph-host='true'][data-docx-paragraph-kind='paragraph']"
+        ).forEach((element) => {
+          record(
+            `para:${element.dataset.docxParagraphNodeIndex}:${element.dataset.docxParagraphStartLine ?? 0}`,
+            element
+          );
+        });
+        tableElementsRef.current.forEach((element, nodeIndex) => {
+          record(`tbl:${nodeIndex}`, element);
+          const host = element.closest(
+            "[data-docx-floating-table-host]"
+          );
+          if (host) record(`tblanchor:${nodeIndex}`, host);
+        });
+        body.querySelectorAll("[data-docx-image-location]").forEach((element) => {
+          record(`img:${element.dataset.docxImageLocation}`, element);
+        });
+        bandsByPage.set(index, bands);
+      });
+      const preview = { ...source, pageIndex, obstacle, bandsByPage };
+      objectWrapDragLatestRef.current = preview;
+      const signature = JSON.stringify([
+        source,
+        pageIndex,
+        obstacle,
+        [...bandsByPage].map(([index, bands]) => [index, [...bands]])
+      ]);
+      if (objectWrapDragSignatureRef.current !== signature) {
+        objectWrapDragSignatureRef.current = signature;
+        setObjectWrapDragPreview(preview);
+      }
+    },
+    [resolveViewerMeasurementZoomScale]
+  );
+  const clearObjectDragPreview = React.useCallback(
+    (preserveMeasurements = false) => {
+      if (preserveMeasurements && objectWrapDragLatestRef.current) {
+        const next = new Map(measuredWrapBands);
+        objectWrapDragLatestRef.current.bandsByPage.forEach((bands) => {
+          bands.forEach((band, key) => {
+            if (!key.startsWith("img:")) next.set(key, band);
+          });
+        });
+        setMeasuredWrapBands(next);
+      }
+      objectWrapDragLatestRef.current = void 0;
+      objectWrapDragSignatureRef.current = "";
+      objectDragCleanupRef.current = void 0;
+      setObjectWrapDragPreview(void 0);
+      setFloatingMovePreview(void 0);
+      tableMoveDragRef.current = void 0;
+    },
+    [measuredWrapBands]
+  );
   const beginTableMoveDrag = React.useCallback(
     (event, tableIndex) => {
-      if (isReadOnly) {
-        return;
-      }
-      if (event.button !== 0 && event.button !== void 0) {
-        return;
-      }
+      if (isReadOnly || event.button !== 0) return;
+      const element = tableElementsRef.current.get(tableIndex);
+      const table = editor.model.nodes[tableIndex];
+      if (!element || table?.type !== "table") return;
       event.preventDefault();
       event.stopPropagation();
+      objectDragCleanupRef.current?.();
       selectWholeTable(tableIndex);
       setHoveredTableHandleTableIndex(tableIndex);
       tableMoveDragRef.current = {
@@ -32376,108 +33138,82 @@ function DocxEditorViewer({
         startY: event.clientY,
         hasMoved: false
       };
-      const zoomScale = resolveViewerMeasurementZoomScale(
-        viewerRootRef.current,
-        1
-      );
-      const tableElementAtStart = tableElementsRef.current.get(tableIndex);
-      const tableRectAtStart = tableElementAtStart?.getBoundingClientRect();
-      const floatingHostRectAtStart = tableElementAtStart?.closest("[data-docx-floating-table-host]")?.getBoundingClientRect();
-      const onPointerMove = (pointerMoveEvent) => {
-        const dragState = tableMoveDragRef.current;
-        if (!dragState || pointerMoveEvent.pointerId !== dragState.pointerId) {
-          return;
-        }
-        const movedX = pointerMoveEvent.clientX - dragState.startX;
-        const movedY = pointerMoveEvent.clientY - dragState.startY;
-        if (!dragState.hasMoved && Math.abs(movedX) + Math.abs(movedY) < TABLE_MOVE_DRAG_THRESHOLD_PX) {
-          return;
-        }
-        dragState.hasMoved = true;
-        setTableFloatingDragPreview({
-          tableIndex: dragState.tableIndex,
-          deltaX: normalizeFloatingDragDeltaForZoom(movedX, zoomScale),
-          deltaY: normalizeFloatingDragDeltaForZoom(movedY, zoomScale)
-        });
-        pointerMoveEvent.preventDefault();
-      };
-      const onPointerUp = (pointerUpEvent) => {
-        const dragState = tableMoveDragRef.current;
-        if (!dragState || pointerUpEvent.pointerId !== dragState.pointerId) {
-          return;
-        }
-        window.removeEventListener("pointermove", onPointerMove);
-        window.removeEventListener("pointerup", onPointerUp);
-        window.removeEventListener("pointercancel", onPointerUp);
-        tableMoveDragRef.current = void 0;
-        const pointerTarget = document.elementFromPoint(
-          pointerUpEvent.clientX,
-          pointerUpEvent.clientY
-        );
-        const tableElement = tableElementsRef.current.get(dragState.tableIndex);
-        const pointerStillOverTable = Boolean(
-          pointerTarget && tableElement?.contains(pointerTarget)
-        );
-        setHoveredTableHandleTableIndex(
-          pointerStillOverTable ? dragState.tableIndex : void 0
-        );
-        setTableFloatingDragPreview(void 0);
-        if (!dragState.hasMoved || !tableRectAtStart) {
-          return;
-        }
-        const deltaX = normalizeFloatingDragDeltaForZoom(
-          pointerUpEvent.clientX - dragState.startX,
-          zoomScale
-        );
-        const deltaY = normalizeFloatingDragDeltaForZoom(
-          pointerUpEvent.clientY - dragState.startY,
-          zoomScale
-        );
-        const tableNode = editor.model.nodes[dragState.tableIndex];
-        if (!tableNode || tableNode.type !== "table") {
-          return;
+      const zoom = resolveViewerMeasurementZoomScale(element, 1);
+      const floating = table.style?.floating;
+      objectDragCleanupRef.current = startObjectDrag({
+        event,
+        element,
+        zoom,
+        resolveElement: () => tableElementsRef.current.get(tableIndex),
+        onFrame: (frame) => {
+          if (tableMoveDragRef.current)
+            tableMoveDragRef.current.hasMoved = true;
+          updateObjectWrapDragPreview(
+            frame,
+            { tableIndex },
+            {
+              left: twipsToPixels(floating?.leftFromTextTwips) ?? 12,
+              right: twipsToPixels(floating?.rightFromTextTwips) ?? 12,
+              top: twipsToPixels(floating?.topFromTextTwips) ?? 0,
+              bottom: twipsToPixels(floating?.bottomFromTextTwips) ?? 0
+            }
+          );
+        },
+        onCancel: clearObjectDragPreview,
+        onDrop: (frame) => {
+          const anchor = resolveWrappedDropAnchorParagraphHost(
+            element,
+            frame.top,
+            frame.left
+          );
+          const body = anchor?.host.closest("[data-docx-page-surface='true']")?.querySelector("[data-docx-page-body]");
+          const host = tableElementsRef.current.get(tableIndex)?.closest("[data-docx-floating-table-host]");
+          const anchorRect = anchor?.rect ?? host?.getBoundingClientRect();
+          const bodyRect = body?.getBoundingClientRect();
+          const startLine = Number(
+            anchor?.host.dataset.docxParagraphStartLine ?? 0
+          );
+          const anchorParagraph = anchor ? editor.model.nodes[anchor.nodeIndex] : void 0;
+          const anchorSource = anchorParagraph?.type === "paragraph" ? buildParagraphPretextLayoutSource(anchorParagraph) : void 0;
+          const anchorLayout = anchorParagraph?.type === "paragraph" && anchorSource && anchorRect ? layoutParagraphPretextSource(
+            anchorParagraph,
+            anchorSource,
+            anchorRect.width / zoom,
+            Number(anchor?.host.dataset.docxParagraphLineHeight) || estimateParagraphLineHeightPx(anchorParagraph),
+            []
+          ) : void 0;
+          const anchorTextOffset = startLine > 0 ? anchorLayout?.lines[startLine]?.fragments[0]?.startOffset : void 0;
+          clearObjectDragPreview();
+          if (!anchorRect) return;
+          editor.setTableFloating(
+            tableIndex,
+            {
+              xTwips: pixelsToTwips(
+                (frame.left - (bodyRect?.left ?? anchorRect.left)) / zoom
+              ),
+              yTwips: pixelsToTwips((frame.top - anchorRect.top) / zoom),
+              horizontalAnchor: "margin",
+              verticalAnchor: "text",
+              horizontalAlign: void 0,
+              verticalAlign: void 0,
+              leftFromTextTwips: floating?.leftFromTextTwips ?? 180,
+              rightFromTextTwips: floating?.rightFromTextTwips ?? 180,
+              topFromTextTwips: floating?.topFromTextTwips ?? 0,
+              bottomFromTextTwips: floating?.bottomFromTextTwips ?? 0
+            },
+            anchor ? { moveToNodeIndex: anchor.nodeIndex, anchorTextOffset } : void 0
+          );
         }
-        const currentFloating = tableNode.style?.floating;
-        const baseLeftPx = floatingHostRectAtStart ? (tableRectAtStart.left - floatingHostRectAtStart.left) / zoomScale : twipsToSignedPixels(tableNode.style?.indentTwips) ?? 0;
-        const baseTopPx = floatingHostRectAtStart ? (tableRectAtStart.top - floatingHostRectAtStart.top) / zoomScale : 0;
-        const dropTarget = resolveTableMoveDropTarget(dragState.tableIndex, {
-          x: pointerUpEvent.clientX,
-          y: pointerUpEvent.clientY
-        });
-        const rootRect = viewerRootRef.current?.getBoundingClientRect();
-        const shouldReanchor = dropTarget !== void 0 && rootRect !== void 0 && dropTarget.targetNodeIndex !== dragState.tableIndex && dropTarget.targetNodeIndex !== dragState.tableIndex + 1;
-        let committedTopPx = baseTopPx + deltaY;
-        if (shouldReanchor && dropTarget && rootRect) {
-          let targetScreenTop = rootRect.top + dropTarget.preview.top;
-          if (!floatingHostRectAtStart && dropTarget.targetNodeIndex > dragState.tableIndex) {
-            targetScreenTop -= tableRectAtStart.height;
-          }
-          const droppedTopScreenPx = tableRectAtStart.top + (pointerUpEvent.clientY - dragState.startY);
-          committedTopPx = (droppedTopScreenPx - targetScreenTop) / zoomScale;
-        }
-        committedTopPx = Math.max(0, committedTopPx);
-        editor.setTableFloating(
-          dragState.tableIndex,
-          {
-            xTwips: pixelsToTwips(baseLeftPx + deltaX),
-            yTwips: pixelsToTwips(committedTopPx),
-            horizontalAnchor: "margin",
-            verticalAnchor: "text",
-            horizontalAlign: void 0,
-            verticalAlign: void 0,
-            leftFromTextTwips: currentFloating?.leftFromTextTwips ?? 187,
-            rightFromTextTwips: currentFloating?.rightFromTextTwips ?? 187,
-            topFromTextTwips: currentFloating?.topFromTextTwips ?? 0,
-            bottomFromTextTwips: currentFloating?.bottomFromTextTwips ?? 0
-          },
-          shouldReanchor && dropTarget ? { moveToNodeIndex: dropTarget.targetNodeIndex } : void 0
-        );
-      };
-      window.addEventListener("pointermove", onPointerMove);
-      window.addEventListener("pointerup", onPointerUp, { once: true });
-      window.addEventListener("pointercancel", onPointerUp, { once: true });
+      });
     },
-    [editor, isReadOnly, resolveTableMoveDropTarget, selectWholeTable]
+    [
+      editor,
+      isReadOnly,
+      selectWholeTable,
+      resolveViewerMeasurementZoomScale,
+      updateObjectWrapDragPreview,
+      clearObjectDragPreview
+    ]
   );
   const closeTableContextMenu = React.useCallback(() => {
     setTableContextMenuState(void 0);
@@ -32684,12 +33420,13 @@ function DocxEditorViewer({
         let range2;
         if (typeof documentWithCaret.caretPositionFromPoint === "function") {
           const position = documentWithCaret.caretPositionFromPoint(x, y);
-          if (position) {
+          if (position && position.offset >= 0 && position.offset <= (position.offsetNode.nodeType === Node.TEXT_NODE ? position.offsetNode.textContent?.length ?? 0 : position.offsetNode.childNodes.length)) {
             range2 = document.createRange();
             range2.setStart(position.offsetNode, position.offset);
             range2.collapse(true);
           }
-        } else if (typeof documentWithCaret.caretRangeFromPoint === "function") {
+        }
+        if (!range2 && typeof documentWithCaret.caretRangeFromPoint === "function") {
           const pointRange = documentWithCaret.caretRangeFromPoint(x, y);
           if (pointRange) {
             range2 = pointRange;
@@ -32706,7 +33443,7 @@ function DocxEditorViewer({
         let bestDistance = Number.POSITIVE_INFINITY;
         let node = walker.nextNode();
         while (node) {
-          if (node instanceof Text && node.parentElement?.closest("[data-docx-numbering-label='true']")) {
+          if (node instanceof Text && node.parentElement?.closest("[data-docx-numbering-label='true'],[data-docx-image-location]")) {
             node = walker.nextNode();
             continue;
           }
@@ -32868,7 +33605,7 @@ function DocxEditorViewer({
         let currentTextNode = walker.nextNode();
         while (currentTextNode) {
           if (currentTextNode instanceof Text && currentTextNode.parentElement?.closest(
-            "[data-docx-numbering-label='true']"
+            "[data-docx-numbering-label='true'],[data-docx-image-location]"
           )) {
             currentTextNode = walker.nextNode();
             continue;
@@ -32985,7 +33722,7 @@ function DocxEditorViewer({
       let currentTextNode = walker.nextNode();
       while (currentTextNode) {
         if (currentTextNode instanceof Text && currentTextNode.parentElement?.closest(
-          "[data-docx-numbering-label='true']"
+          "[data-docx-numbering-label='true'],[data-docx-image-location]"
         )) {
           currentTextNode = walker.nextNode();
           continue;
@@ -33276,8 +34013,8 @@ function DocxEditorViewer({
       const offset = clampNumber(
         resolveOffsetAtPoint(
           registeredSurface.layout,
-          point.x - surfaceRect.left,
-          point.y - surfaceRect.top
+          (point.x - surfaceRect.left) / resolveEffectiveZoomScale(registeredSurface.element),
+          (point.y - surfaceRect.top) / resolveEffectiveZoomScale(registeredSurface.element)
         ),
         0,
         registeredSurface.textLength
@@ -33330,6 +34067,7 @@ function DocxEditorViewer({
         return void 0;
       }
       const referenceElement = container instanceof Element ? container : container.parentElement;
+      if (referenceElement?.closest("[data-docx-textbox-editor='true']")) return void 0;
       const paragraphElement = referenceElement?.closest(
         "[data-docx-paragraph-kind]"
       );
@@ -33998,7 +34736,7 @@ function DocxEditorViewer({
       if (!textarea || !textarea.isConnected) {
         return;
       }
-      textarea.focus();
+      textarea.focus({ preventScroll: true });
       const pendingSelection = wrappedParagraphPendingSelectionRef.current;
       const session = activeWrappedParagraphSession;
       const selectionSource = pendingSelection && (!session || pendingSelection.locationKey === session.locationKey) ? pendingSelection : session ? {
@@ -34089,6 +34827,54 @@ function DocxEditorViewer({
       flushActiveRangeFromSelection();
     }, 80);
   }, [flushActiveRangeFromSelection]);
+  React.useLayoutEffect(() => {
+    const request = editor.historyRestoreRequest;
+    if (!request?.textInput || !request.activeTextRange || request.nonce === appliedHistoryRestoreNonceRef.current || compositionActiveRef.current) {
+      return;
+    }
+    const { start, end } = request.activeTextRange;
+    const host = resolveParagraphHostElement(start.location);
+    const startPosition = resolveDomPositionFromBoundary(start);
+    const endPosition = resolveDomPositionFromBoundary(end);
+    const selection = window.getSelection();
+    if (!host?.isContentEditable || !startPosition || !endPosition || !selection) {
+      return;
+    }
+    try {
+      beginSelectionIntent();
+      const focusedElement = document.activeElement;
+      if (!(focusedElement instanceof HTMLElement) || !focusedElement.isContentEditable || !focusedElement.contains(host)) {
+        const editableRoot = host.closest("[contenteditable='true']") ?? host;
+        editableRoot.focus({ preventScroll: true });
+      }
+      if (selection.anchorNode !== startPosition.node || selection.anchorOffset !== startPosition.offset || selection.focusNode !== endPosition.node || selection.focusOffset !== endPosition.offset) {
+        if (typeof selection.setBaseAndExtent === "function") {
+          selection.setBaseAndExtent(
+            startPosition.node,
+            startPosition.offset,
+            endPosition.node,
+            endPosition.offset
+          );
+        } else {
+          const range = document.createRange();
+          const forward = compareTextRangeBoundaries(start, end) <= 0;
+          const first = forward ? startPosition : endPosition;
+          const last = forward ? endPosition : startPosition;
+          range.setStart(first.node, first.offset);
+          range.setEnd(last.node, last.offset);
+          selection.removeAllRanges();
+          selection.addRange(range);
+        }
+      }
+      appliedHistoryRestoreNonceRef.current = request.nonce;
+    } catch {
+    }
+  }, [
+    beginSelectionIntent,
+    editor.historyRestoreRequest,
+    resolveDomPositionFromBoundary,
+    resolveParagraphHostElement
+  ]);
   React.useEffect(() => {
     const restoreRequest = editor.historyRestoreRequest;
     if (!restoreRequest) {
@@ -34594,6 +35380,33 @@ function DocxEditorViewer({
       tableContextMenuState
     ]
   );
+  const onViewerFormFieldDoubleClick = React.useCallback(
+    (event) => {
+      if (isReadOnly || !(event.target instanceof Element)) {
+        return;
+      }
+      const fieldElement = event.target.closest("[data-docx-form-field='true']");
+      const paragraphLocation = parseParagraphLocationFromElement(
+        fieldElement?.closest("[data-docx-paragraph-kind]") ?? null
+      );
+      const childIndex = parseDocumentIndexFromAttribute(
+        fieldElement?.getAttribute("data-docx-form-field-child-index") ?? null
+      );
+      if (!paragraphLocation || childIndex === void 0) {
+        return;
+      }
+      const field = getParagraphAtLocation(editor.model, paragraphLocation).paragraph?.children[childIndex];
+      if (field?.type !== "form-field") {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const location = { ...paragraphLocation, childIndex };
+      editor.selectFormField(location);
+      onFormFieldDoubleClick?.(location);
+    },
+    [editor.model, editor.selectFormField, isReadOnly, onFormFieldDoubleClick]
+  );
   const onViewerContextMenu = React.useCallback(
     (event) => {
       if (isReadOnly || event.defaultPrevented) {
@@ -35885,7 +36698,7 @@ function DocxEditorViewer({
       try {
         const textLengthWithoutNumberingLabels = (range) => {
           const fragment = range.cloneContents();
-          fragment.querySelectorAll("[data-docx-numbering-label='true']").forEach((label) => {
+          fragment.querySelectorAll("[data-docx-numbering-label='true'],[data-docx-image-location]").forEach((label) => {
             label.remove();
           });
           return fragment.textContent?.length ?? 0;
@@ -36419,7 +37232,7 @@ function DocxEditorViewer({
       if (!targetElement) {
         return;
       }
-      if (targetElement.closest("textarea, input") || targetElement.closest("[data-docx-header-footer-region]")) {
+      if (targetElement.closest("textarea, input, [data-docx-textbox-editor='true']") || targetElement.closest("[data-docx-header-footer-region]")) {
         return;
       }
       const intent = resolveEditingIntent({
@@ -37566,288 +38379,229 @@ function DocxEditorViewer({
   );
   const beginFloatingImageMove = React.useCallback(
     (event, location, image, isWrappedFloatingImage, isAbsoluteFloatingImage) => {
-      if (isReadOnly) {
-        return;
-      }
-      if (event.button !== 0) {
-        return;
-      }
-      if (event.target.closest(
+      if (isReadOnly || event.button !== 0 || event.target.closest(
         "[data-image-resize-handle='true']"
-      )) {
+      ))
         return;
-      }
-      const isInlineImage = !isWrappedFloatingImage && !isAbsoluteFloatingImage;
       event.preventDefault();
       event.stopPropagation();
+      objectDragCleanupRef.current?.();
       setSelectedImage(location);
+      const element = event.currentTarget;
       const imageKey = imageLocationKey(location);
-      const startX = event.clientX;
-      const startY = event.clientY;
-      const inlineDragActivationThresholdPx = 4;
-      const wrapperElement = event.currentTarget;
-      const wrapperRect = wrapperElement.getBoundingClientRect();
-      const pageSurface = wrapperElement.closest(
-        "[data-docx-page-surface='true']"
-      );
-      const pageSurfaceRect = pageSurface?.getBoundingClientRect();
-      const paragraphHost = wrapperElement.closest(
-        "[data-docx-paragraph-host='true']"
-      );
-      const paragraphRect = paragraphHost?.getBoundingClientRect();
-      const zoomScale = resolveViewerMeasurementZoomScale(wrapperElement, 1);
-      const baseFloating = image.floating ? { ...image.floating } : {};
-      const dragStartAnchor = isWrappedFloatingImage && location.kind === "paragraph" ? resolveWrappedDropAnchorParagraphHost(
-        wrapperElement,
-        wrapperRect.top,
-        wrapperRect.left
-      ) : void 0;
-      let latestDeltaX = 0;
-      let latestDeltaY = 0;
-      let frameId;
-      let inlineDragActivated = false;
-      let latestInlineDropTarget;
-      let latestInlineDropTargetKey;
-      const measuredBands = (() => {
-        if (!isWrappedFloatingImage || !pageSurface || !pageSurfaceRect) {
-          return void 0;
-        }
-        const hostByNodeIndex = {};
-        for (const host of Array.from(
-          pageSurface.querySelectorAll(
-            "[data-docx-paragraph-host='true'][data-docx-paragraph-kind='paragraph'][data-docx-paragraph-node-index]"
-          )
-        )) {
-          const nodeIndex = Number.parseInt(
-            host.getAttribute("data-docx-paragraph-node-index") ?? "",
-            10
-          );
-          if (!Number.isFinite(nodeIndex)) {
-            continue;
-          }
-          const rect = host.getBoundingClientRect();
-          if (rect.height <= 0) {
-            continue;
-          }
-          hostByNodeIndex[nodeIndex] = {
-            topPx: (rect.top - pageSurfaceRect.top) / zoomScale,
-            bottomPx: (rect.bottom - pageSurfaceRect.top) / zoomScale
-          };
-        }
-        return Object.keys(hostByNodeIndex).length > 0 ? { hostByNodeIndex } : void 0;
-      })();
-      const updatePreview = () => {
-        setFloatingMovePreview({
-          imageKey,
-          deltaX: latestDeltaX,
-          deltaY: latestDeltaY,
-          measuredBands,
-          ...paragraphRect ? {
-            baseLeftPx: Math.round(
-              (wrapperRect.left - paragraphRect.left) / zoomScale
-            ),
-            baseTopPx: Math.round(
-              (wrapperRect.top - paragraphRect.top) / zoomScale
-            )
-          } : void 0
-        });
-      };
-      const onPointerMove = (pointerEvent) => {
-        latestDeltaX = normalizeFloatingDragDeltaForZoom(
-          pointerEvent.clientX - startX,
-          zoomScale
+      const zoom = resolveViewerMeasurementZoomScale(element, 1);
+      const isInline = !isWrappedFloatingImage && !isAbsoluteFloatingImage;
+      const floating = image.floating;
+      let caret;
+      const resolveInlineTarget = (frame) => {
+        const point = { x: frame.clientX, y: frame.clientY };
+        const boundary = resolveBoundaryFromPoint(point);
+        if (!boundary) return void 0;
+        const paragraph = getParagraphAtLocation(
+          editor.model,
+          boundary.location
+        ).paragraph;
+        if (!paragraph) return void 0;
+        const wrapped = wrappedParagraphSurfaceRegistryRef.current.get(
+          paragraphLocationKey(boundary.location)
         );
-        latestDeltaY = normalizeFloatingDragDeltaForZoom(
-          pointerEvent.clientY - startY,
-          zoomScale
+        const layoutSource = wrapped ? buildParagraphPretextLayoutSource(paragraph) : void 0;
+        const run = layoutSource?.runs.find(
+          (candidate) => candidate.endOffset >= boundary.offset
         );
-        if (isInlineImage) {
-          if (!inlineDragActivated) {
-            const movementDistancePx = Math.abs(latestDeltaX) + Math.abs(latestDeltaY);
-            if (movementDistancePx < inlineDragActivationThresholdPx) {
-              return;
-            }
-            inlineDragActivated = true;
-            draggedImageRef.current = location;
-            setIsDraggingImage(true);
-            setActiveDropTarget(void 0);
-          }
-          const candidate = document.elementFromPoint(pointerEvent.clientX, pointerEvent.clientY)?.closest(
-            "[data-docx-image-drop-zone='true']"
+        const runIndex = run ? Number(/^run-(\d+)/.exec(run.key)?.[1]) : void 0;
+        const position = run && runIndex !== void 0 && Number.isFinite(runIndex) ? run.kind === "image" ? {
+          childIndex: runIndex + (boundary.offset > (run.startOffset + run.endOffset) / 2 ? 1 : 0)
+        } : {
+          childIndex: runIndex,
+          textOffset: Math.max(0, boundary.offset - run.startOffset)
+        } : imageDropPositionAtTextOffset(paragraph, boundary.offset, {
+          fieldText: formFieldDisplayValue2
+        });
+        const target = { ...boundary.location, ...position };
+        let rect;
+        if (wrapped) {
+          const local = resolveCaretRectAtOffset(
+            wrapped.layout,
+            boundary.offset
           );
-          const parsedTarget = candidate ? parseImageDropTargetFromDataset(candidate.dataset) : void 0;
-          const parsedTargetKey = parsedTarget ? dropTargetKey(parsedTarget) : void 0;
-          if (parsedTargetKey !== latestInlineDropTargetKey) {
-            latestInlineDropTarget = parsedTarget;
-            latestInlineDropTargetKey = parsedTargetKey;
-            setActiveDropTarget(parsedTarget);
-          }
-        }
-        if (frameId !== void 0) {
-          window.cancelAnimationFrame(frameId);
+          const origin = wrapped.element.getBoundingClientRect();
+          const scale = resolveViewerMeasurementZoomScale(wrapped.element, 1);
+          if (local)
+            rect = {
+              left: origin.left + local.left * scale,
+              top: origin.top + local.top * scale,
+              height: local.height * scale
+            };
+        } else {
+          const doc = document;
+          const range = doc.caretRangeFromPoint?.(point.x, point.y);
+          const candidate = range?.getBoundingClientRect();
+          if (candidate?.height) rect = candidate;
+        }
+        if (!caret) {
+          caret = document.createElement("div");
+          caret.setAttribute("data-docx-image-drop-caret", "true");
+          Object.assign(caret.style, {
+            position: "fixed",
+            pointerEvents: "none",
+            width: "2px",
+            background: "#2563eb",
+            zIndex: "2147483647"
+          });
+          document.body.appendChild(caret);
         }
-        frameId = window.requestAnimationFrame(updatePreview);
+        Object.assign(
+          caret.style,
+          rect ? {
+            display: "block",
+            left: `${rect.left}px`,
+            top: `${rect.top}px`,
+            height: `${rect.height}px`
+          } : { display: "none" }
+        );
+        return target;
       };
-      const onPointerUp = () => {
-        window.removeEventListener("pointermove", onPointerMove);
-        window.removeEventListener("pointerup", onPointerUp);
-        window.removeEventListener("pointercancel", onPointerUp);
-        if (frameId !== void 0) {
-          window.cancelAnimationFrame(frameId);
-        }
-        setFloatingMovePreview(void 0);
-        if (isInlineImage) {
-          if (inlineDragActivated) {
-            setIsDraggingImage(false);
-            draggedImageRef.current = null;
-            setActiveDropTarget(void 0);
-          }
-          if (Math.abs(latestDeltaX) < 1 && Math.abs(latestDeltaY) < 1) {
-            return;
-          }
-          if (!inlineDragActivated) {
+      const clear = (preserveMeasurements = false) => {
+        caret?.remove();
+        clearObjectDragPreview(preserveMeasurements);
+      };
+      objectDragCleanupRef.current = startObjectDrag({
+        event,
+        element,
+        zoom,
+        resolveElement: () => viewerRootRef.current?.querySelector(
+          `[data-docx-image-location="${imageKey}"]`
+        ) ?? void 0,
+        onFrame: (frame) => {
+          if (isInline) {
+            resolveInlineTarget(frame);
             return;
           }
-          if (!latestInlineDropTarget) {
+          updateObjectWrapDragPreview(
+            frame,
+            { imageKey },
+            floating?.wrapType && floating.wrapType !== "none" && !floating.behindDocument ? {
+              left: floating.distLPx ?? 0,
+              right: floating.distRPx ?? 0,
+              top: floating.distTPx ?? 0,
+              bottom: floating.distBPx ?? 0,
+              fullWidth: floating.wrapType === "topAndBottom"
+            } : void 0
+          );
+        },
+        onCancel: clear,
+        onDrop: (frame) => {
+          if (isInline) {
+            const target = resolveInlineTarget(frame);
+            clear();
+            if (!target) return;
+            editor.moveImage(location, target);
+            const sameParagraph = sameParagraphLocation(location, target);
+            setSelectedImage({
+              ...target,
+              childIndex: target.childIndex - (sameParagraph && location.childIndex < target.childIndex ? 1 : 0) + (target.textOffset ? 1 : 0)
+            });
             return;
           }
-          editor.moveImage(location, latestInlineDropTarget);
-          const sourceParagraphLocation = imageLocationToParagraphLocation(location);
-          const targetParagraphLocation = latestInlineDropTarget.kind === "paragraph" ? {
-            kind: "paragraph",
-            nodeIndex: latestInlineDropTarget.nodeIndex
-          } : {
-            kind: "table-cell",
-            tableIndex: latestInlineDropTarget.tableIndex,
-            rowIndex: latestInlineDropTarget.rowIndex,
-            cellIndex: latestInlineDropTarget.cellIndex,
-            paragraphIndex: latestInlineDropTarget.paragraphIndex
-          };
-          const nextChildIndex = sameParagraphLocation(
-            sourceParagraphLocation,
-            targetParagraphLocation
-          ) && location.childIndex < latestInlineDropTarget.childIndex ? latestInlineDropTarget.childIndex - 1 : latestInlineDropTarget.childIndex;
-          setSelectedImage({
-            ...latestInlineDropTarget,
-            childIndex: Math.max(0, nextChildIndex)
-          });
-          return;
-        }
-        if (Math.abs(latestDeltaX) < 1 && Math.abs(latestDeltaY) < 1) {
-          return;
-        }
-        if (isWrappedFloatingImage) {
-          const hostWidth = paragraphRect ? paragraphRect.width / zoomScale : DEFAULT_DOC_PAGE_WIDTH;
-          const imageWidth = image.widthPx ?? Math.max(24, Math.round(wrapperRect.width / zoomScale));
-          const imageHeight = image.heightPx ?? Math.max(24, Math.round(wrapperRect.height / zoomScale));
-          const baseGeometry = resolveDualWrappedFloatingImageGeometry(
-            image,
-            hostWidth,
-            {
-              widthPx: imageWidth,
-              heightPx: imageHeight,
-              ...paragraphRect ? {
-                baseLeftPx: Math.round(
-                  (wrapperRect.left - paragraphRect.left) / zoomScale
+          const anchor = location.kind === "paragraph" ? resolveWrappedDropAnchorParagraphHost(
+            element,
+            frame.top,
+            frame.left
+          ) : void 0;
+          const host = anchor?.host ?? element.closest("[data-docx-paragraph-host='true']");
+          const hostRect = host?.getBoundingClientRect();
+          clear(true);
+          if (!hostRect) return;
+          let selectedChildIndex = location.childIndex;
+          if (anchor && (location.kind !== "paragraph" || anchor.nodeIndex !== location.nodeIndex)) {
+            const targetParagraph = editor.model.nodes[anchor.nodeIndex];
+            if (targetParagraph.type === "paragraph")
+              selectedChildIndex = imageDropPositionAtTextOffset(
+                targetParagraph,
+                0
+              ).childIndex;
+          }
+          if (isWrappedFloatingImage) {
+            const startLine = Number(host?.dataset.docxParagraphStartLine ?? 0);
+            const anchorParagraph = anchor ? editor.model.nodes[anchor.nodeIndex] : void 0;
+            const anchorSource = anchorParagraph?.type === "paragraph" ? buildParagraphPretextLayoutSource(anchorParagraph) : void 0;
+            const anchorLayout = anchorParagraph?.type === "paragraph" && anchorSource ? layoutParagraphPretextSource(
+              anchorParagraph,
+              anchorSource,
+              hostRect.width / zoom,
+              Number(host?.dataset.docxParagraphLineHeight) || estimateParagraphLineHeightPx(anchorParagraph),
+              []
+            ) : void 0;
+            const anchorTextOffset = startLine > 0 ? anchorLayout?.lines[startLine]?.fragments[0]?.startOffset : void 0;
+            if (anchorParagraph?.type === "paragraph" && anchor && (location.kind !== "paragraph" || anchor.nodeIndex !== location.nodeIndex || anchorTextOffset !== void 0)) {
+              const position = imageDropPositionAtTextOffset(
+                anchorParagraph,
+                anchorTextOffset ?? 0,
+                { fieldText: formFieldDisplayValue2 }
+              );
+              selectedChildIndex = position.childIndex + (position.textOffset ? 1 : 0) - (location.kind === "paragraph" && anchor.nodeIndex === location.nodeIndex && location.childIndex < position.childIndex ? 1 : 0);
+            }
+            editor.moveFloatingImage(
+              location,
+              {
+                ...resolveWrappedFloatingImageDropPatch(
+                  image,
+                  hostRect.width / zoom,
+                  (frame.left - hostRect.left) / zoom,
+                  (frame.top - hostRect.top) / zoom
                 ),
-                baseTopPx: Math.round(
-                  (wrapperRect.top - paragraphRect.top) / zoomScale
-                )
+                horizontalAlign: void 0,
+                verticalAlign: void 0,
+                horizontalRelativeTo: "column",
+                verticalRelativeTo: anchorTextOffset !== void 0 ? "line" : "paragraph"
+              },
+              anchor ? {
+                reparentToParagraphNodeIndex: anchor.nodeIndex,
+                anchorTextOffset
               } : void 0
-            }
-          );
-          const movedLeft = clampNumber(
-            (baseGeometry?.imageLeftPx ?? 0) + latestDeltaX,
-            0,
-            Math.max(0, hostWidth - imageWidth)
-          );
-          const movedTop = Math.round(
-            (baseGeometry?.imageTopPx ?? 0) + latestDeltaY
-          );
-          const droppedTopScreenPx = wrapperRect.top + latestDeltaY * zoomScale;
-          const droppedLeftScreenPx = wrapperRect.left + latestDeltaX * zoomScale;
-          const dropAnchor = location.kind === "paragraph" && wrappedDragCanReanchorToParagraph(baseFloating) ? resolveWrappedDropAnchorParagraphHost(
-            wrapperElement,
-            droppedTopScreenPx,
-            droppedLeftScreenPx
-          ) : void 0;
-          if (dropAnchor && location.kind === "paragraph" && dropAnchor.nodeIndex !== location.nodeIndex && dropAnchor.nodeIndex !== dragStartAnchor?.nodeIndex) {
-            const targetHostWidth = dropAnchor.rect.width / zoomScale;
-            const targetMovedLeft = clampNumber(
-              Math.round(
-                (droppedLeftScreenPx - dropAnchor.rect.left) / zoomScale
-              ),
-              0,
-              Math.max(0, targetHostWidth - imageWidth)
-            );
-            const targetMovedTop = Math.round(
-              (droppedTopScreenPx - dropAnchor.rect.top) / zoomScale
             );
+          } else {
+            const surfaceRect = host?.closest("[data-docx-page-surface='true']")?.getBoundingClientRect();
             editor.moveFloatingImage(
               location,
-              resolveWrappedFloatingImageDropPatch(
-                image,
-                targetHostWidth,
-                targetMovedLeft,
-                targetMovedTop,
+              resolveAbsoluteFloatingImageDropPatch(
+                floating ?? {},
+                documentLayout,
                 {
-                  widthPx: imageWidth,
-                  heightPx: imageHeight
+                  wrapperRect: {
+                    left: frame.left / zoom,
+                    top: frame.top / zoom,
+                    width: frame.width / zoom,
+                    height: frame.height / zoom
+                  },
+                  pageSurfaceRect: surfaceRect ? normalizeFloatingDropRectForZoom(surfaceRect, zoom) : void 0,
+                  deltaX: 0,
+                  deltaY: 0
                 }
               ),
-              { reparentToParagraphNodeIndex: dropAnchor.nodeIndex }
+              anchor ? { reparentToParagraphNodeIndex: anchor.nodeIndex } : void 0
             );
+          }
+          if (anchor) {
             setSelectedImage({
               kind: "paragraph",
-              nodeIndex: dropAnchor.nodeIndex,
-              childIndex: 0
+              nodeIndex: anchor.nodeIndex,
+              childIndex: selectedChildIndex
             });
-            return;
           }
-          editor.moveFloatingImage(
-            location,
-            resolveWrappedFloatingImageDropPatch(
-              image,
-              hostWidth,
-              movedLeft,
-              movedTop,
-              {
-                widthPx: imageWidth,
-                heightPx: imageHeight
-              }
-            )
-          );
-          return;
-        }
-        if (isAbsoluteFloatingImage) {
-          const dropPageSurfaceRect = pageSurface && pageSurface.isConnected ? pageSurface.getBoundingClientRect() : pageSurfaceRect;
-          editor.moveFloatingImage(
-            location,
-            resolveAbsoluteFloatingImageDropPatch(
-              baseFloating,
-              documentLayout,
-              {
-                wrapperRect: normalizeFloatingDropRectForZoom(
-                  wrapperRect,
-                  zoomScale
-                ),
-                pageSurfaceRect: dropPageSurfaceRect ? normalizeFloatingDropRectForZoom(
-                  dropPageSurfaceRect,
-                  zoomScale
-                ) : void 0,
-                deltaX: latestDeltaX,
-                deltaY: latestDeltaY
-              }
-            )
-          );
-          return;
         }
-      };
-      window.addEventListener("pointermove", onPointerMove);
-      window.addEventListener("pointerup", onPointerUp, { once: true });
-      window.addEventListener("pointercancel", onPointerUp, { once: true });
+      });
     },
-    [documentLayout, editor, isReadOnly, resolveViewerMeasurementZoomScale]
+    [
+      documentLayout,
+      editor,
+      isReadOnly,
+      resolveViewerMeasurementZoomScale,
+      resolveBoundaryFromPoint,
+      updateObjectWrapDragPreview,
+      clearObjectDragPreview
+    ]
   );
   const beginDropCapMove = React.useCallback(
     (event, nodeIndex, dropCap) => {
@@ -38667,7 +39421,20 @@ function DocxEditorViewer({
               src: renderableImageSrc,
               alt: run.image.alt ?? "DOCX image",
               draggable: false,
+              "data-docx-image-location": imageLocationKey({ ...location, childIndex: Number(/^run-(\d+)/.exec(run.key)?.[1]) }),
+              onPointerDown: (event) => {
+                if (!isReadOnly && run.image) beginFloatingImageMove(
+                  event,
+                  { ...location, childIndex: Number(/^run-(\d+)/.exec(run.key)?.[1]) },
+                  run.image,
+                  false,
+                  false
+                );
+              },
               style: {
+                position: "relative",
+                zIndex: 3,
+                touchAction: "none",
                 width: run.image.widthPx ? `${run.image.widthPx}px` : void 0,
                 height: run.image.heightPx ? `${run.image.heightPx}px` : void 0,
                 verticalAlign: "middle",
@@ -39284,6 +40051,22 @@ function DocxEditorViewer({
   };
   const renderInteractiveParagraphRuns = React.useCallback(
     (paragraph, keyPrefix, location, options) => {
+      const lineRange = options?.paragraphLineRange;
+      const sliceTop = (lineRange?.startLineIndex ?? 0) * (lineRange?.lineHeightPx ?? 0);
+      const sliceEnd = (lineRange?.endLineIndex ?? Infinity) * (lineRange?.lineHeightPx ?? 1);
+      const imageIsInSlice = (childIndex) => {
+        if (!lineRange) return true;
+        const source = buildParagraphPretextLayoutSource(paragraph);
+        const unwrapped = source ? layoutParagraphPretextSource(
+          paragraph,
+          source,
+          paragraphAvailableTextWidthPx(paragraph, pageContentWidthPxByNodeIndex.get(nodeIndexFromParagraphLocation(location)) ?? documentContentWidthPx, editor.model.metadata.numberingDefinitions),
+          lineRange.lineHeightPx,
+          []
+        ) : void 0;
+        const anchorTop = unwrapped ? resolveCaretRectAtOffset(unwrapped, paragraphChildAnchorOffset(paragraph, childIndex) + 1)?.top ?? 0 : 0;
+        return anchorTop >= sliceTop && anchorTop < sliceEnd;
+      };
       const nodes = [];
       const checkboxChoiceRow = paragraphLooksLikeCheckboxChoiceRow(paragraph);
       const fallbackTabWidthPx = checkboxChoiceRow ? checkboxChoiceRowTabWidthPx(paragraph) : DEFAULT_TAB_STOP_PX;
@@ -39360,16 +40143,6 @@ function DocxEditorViewer({
           }
         });
       };
-      const noteMarkerIndexes = {
-        footnote: /* @__PURE__ */ new Map(),
-        endnote: /* @__PURE__ */ new Map()
-      };
-      editor.model.metadata.footnotes?.forEach((note, index) => {
-        noteMarkerIndexes.footnote.set(note.id, index + 1);
-      });
-      editor.model.metadata.endnotes?.forEach((note, index) => {
-        noteMarkerIndexes.endnote.set(note.id, index + 1);
-      });
       const numberingLabel = paragraphNumberingLabels.get(
         paragraphLocationKey(location)
       );
@@ -39481,17 +40254,18 @@ function DocxEditorViewer({
           }
         );
       }
-      const paragraphLineHeightPx = estimateParagraphLineHeightPx(paragraph);
+      const paragraphLineHeightPx = options?.paragraphLineRange?.lineHeightPx ?? estimateParagraphLineHeightPx(paragraph);
       const manualDualWrappedLayout = !numberingLabel ? resolveParagraphDualWrappedTextLayout(
         paragraph,
         paragraphRenderTextWidthPx,
         paragraphLineHeightPx,
         {
+          excludedImageIndex: objectWrapDragPreview?.imageKey?.startsWith(`${paragraphLocationKey(location)}:`) ? Number(objectWrapDragPreview.imageKey.split(":").at(-1)) : void 0,
           widthPxByImageIndex: resizedWidthPxByImageIndex,
           heightPxByImageIndex: resizedHeightPxByImageIndex,
           paragraphTopPx: paragraphPageFlowTopPx,
           pageMarginTopPx: paragraphPageLayout.marginsPx.top,
-          foreignExclusions: options?.pageFlowForeignExclusions,
+          foreignExclusions: options?.pageFlowForeignExclusions?.map((exclusion) => ({ ...exclusion, top: exclusion.top + sliceTop, bottom: exclusion.bottom + sliceTop })),
           movePreviewByImageIndex,
           allowNegativeImageTop: movePreviewByImageIndex.size > 0
         }
@@ -39500,7 +40274,7 @@ function DocxEditorViewer({
         paragraph,
         paragraphRenderTextWidthPx,
         paragraphLineHeightPx,
-        options?.pageFlowForeignExclusions ?? []
+        (options?.pageFlowForeignExclusions ?? []).map((exclusion) => ({ ...exclusion, top: exclusion.top + sliceTop, bottom: exclusion.bottom + sliceTop }))
       ) : void 0;
       const activeDualWrappedLayout = manualDualWrappedLayout ?? foreignOnlyWrappedLayout;
       if (activeDualWrappedLayout) {
@@ -39539,7 +40313,20 @@ function DocxEditorViewer({
                   src: renderableImageSrc,
                   alt: run.image.alt ?? "DOCX image",
                   draggable: false,
+                  "data-docx-image-location": imageLocationKey({ ...location, childIndex: Number(/^run-(\d+)/.exec(run.key)?.[1]) }),
+                  onPointerDown: (event) => {
+                    if (!isReadOnly && run.image) beginFloatingImageMove(
+                      event,
+                      { ...location, childIndex: Number(/^run-(\d+)/.exec(run.key)?.[1]) },
+                      run.image,
+                      false,
+                      false
+                    );
+                  },
                   style: {
+                    position: "relative",
+                    zIndex: 3,
+                    touchAction: "none",
                     width: run.image.widthPx ? `${run.image.widthPx}px` : void 0,
                     height: run.image.heightPx ? `${run.image.heightPx}px` : void 0,
                     verticalAlign: "middle",
@@ -39629,7 +40416,7 @@ function DocxEditorViewer({
         };
         const renderManualImage = (geometry) => {
           const manualImage = previewParagraph.children[geometry.imageIndex];
-          if (manualImage?.type !== "image") {
+          if (manualImage?.type !== "image" || !imageIsInSlice(geometry.imageIndex)) {
             return null;
           }
           const manualImageLocation = {
@@ -39658,7 +40445,7 @@ function DocxEditorViewer({
                 display: "inline-block",
                 position: "absolute",
                 left: geometry.imageLeftPx,
-                top: geometry.imageTopPx,
+                top: geometry.imageTopPx - sliceTop,
                 width: widthPx ? `${widthPx}px` : void 0,
                 height: heightPx ? `${heightPx}px` : void 0,
                 zIndex: 3
@@ -40319,17 +41106,15 @@ function DocxEditorViewer({
             return child?.type === "image" && isPageOrMarginAnchoredWrappedFloatingImage(child);
           }).map((geometry) => geometry.imageIndex)
         );
-        const activeWrappedSource = activeSession ? buildSyntheticPretextLayoutSource(
+        const activeWrappedSource = activeSession && activeSession.text !== activeDualWrappedLayout.source.text ? buildSyntheticPretextLayoutSource(
           activeSession.text,
           firstRunStyle(previewParagraph)
         ) : activeDualWrappedLayout.source;
         const activeWrappedExclusions = [
           ...options?.pageFlowForeignExclusions ?? [],
-          ...activeDualWrappedLayout.geometries.map(
-            (geometry) => geometry.exclusion
-          )
+          ...activeDualWrappedLayout.geometries.map((geometry) => geometry.exclusion)
         ];
-        const activeWrappedLayout = activeSession ? layoutParagraphPretextSource(
+        const activeWrappedLayout = activeWrappedSource !== activeDualWrappedLayout.source ? layoutParagraphPretextSource(
           previewParagraph,
           activeWrappedSource,
           paragraphRenderTextWidthPx,
@@ -40340,9 +41125,13 @@ function DocxEditorViewer({
           location,
           keyPrefix: `${keyPrefix}-dual-wrap-manual`,
           source: activeWrappedSource,
-          layout: activeWrappedLayout,
+          layout: lineRange ? sliceLayoutToLineRange(
+            activeWrappedLayout,
+            lineRange.startLineIndex,
+            lineRange.endLineIndex >= lineRange.totalLineCount ? activeWrappedLayout.lineCount : lineRange.endLineIndex
+          ) : activeWrappedLayout,
           lineHeightPx: activeDualWrappedLayout.lineHeightPx,
-          blockHeightPx: resolveDragPreviewAwareWrapBlockHeightPx(
+          blockHeightPx: lineRange ? void 0 : resolveDragPreviewAwareWrapBlockHeightPx(
             activeWrappedLayout,
             activeDualWrappedLayout.geometries,
             options?.pageFlowForeignExclusions
@@ -40629,6 +41418,12 @@ function DocxEditorViewer({
                       contentEditable: !isReadOnly,
                       suppressContentEditableWarning: true,
                       spellCheck: false,
+                      onInput: (event) => event.stopPropagation(),
+                      onKeyDown: (event) => event.stopPropagation(),
+                      onKeyUp: (event) => event.stopPropagation(),
+                      onPaste: (event) => event.stopPropagation(),
+                      onCompositionStart: (event) => event.stopPropagation(),
+                      onCompositionEnd: (event) => event.stopPropagation(),
                       onFocus: (event) => {
                         event.stopPropagation();
                         if (!isReadOnly) {
@@ -41008,6 +41803,7 @@ function DocxEditorViewer({
                 {
                   contentEditable: false,
                   "data-docx-form-field": "true",
+                  "data-docx-form-field-child-index": childIndex,
                   "data-docx-form-field-type": "checkbox",
                   role: "checkbox",
                   "aria-checked": Boolean(child.checked),
@@ -41086,6 +41882,7 @@ function DocxEditorViewer({
                 {
                   contentEditable: false,
                   "data-docx-form-field": "true",
+                  "data-docx-form-field-child-index": childIndex,
                   "data-docx-form-field-type": "dropdown",
                   value: selectedValue,
                   onClick: (event) => {
@@ -41142,6 +41939,7 @@ function DocxEditorViewer({
                   {
                     contentEditable: false,
                     "data-docx-form-field": "true",
+                    "data-docx-form-field-child-index": childIndex,
                     "data-docx-form-field-type": "date",
                     type: compactFieldLayout ? "text" : "date",
                     value: normalizedDate,
@@ -41186,6 +41984,7 @@ function DocxEditorViewer({
                   {
                     contentEditable: false,
                     "data-docx-form-field": "true",
+                    "data-docx-form-field-child-index": childIndex,
                     "data-docx-form-field-type": "date",
                     type: "text",
                     value: child.value ?? "",
@@ -41232,6 +42031,7 @@ function DocxEditorViewer({
                 {
                   contentEditable: false,
                   "data-docx-form-field": "true",
+                  "data-docx-form-field-child-index": childIndex,
                   "data-docx-form-field-type": "text",
                   type: "text",
                   value: child.value ?? "",
@@ -41426,6 +42226,7 @@ function DocxEditorViewer({
       beginImageResize,
       clearTableCellSelection,
       floatingMovePreview,
+      objectWrapDragPreview,
       isDraggingImage,
       openContextMenu,
       onImageDragEnd,
@@ -41444,6 +42245,7 @@ function DocxEditorViewer({
       onFormFieldDoubleClick,
       isReadOnly,
       paragraphNumberingLabels,
+      noteMarkerIndexes,
       scrollToBookmark,
       documentLayout,
       tocLinkColorByLevel,
@@ -42248,7 +43050,10 @@ function DocxEditorViewer({
       const resolvedAfterSpacingPx = Number.isFinite(
         options?.overrideAfterSpacingPx
       ) ? Math.max(0, Math.round(options?.overrideAfterSpacingPx)) : void 0;
-      const editable = !hasImage && !isReadOnly && options?.forceReadOnly !== true && (!hasPartialLineRange || paragraphSegmentIsActiveEditable) && !isManualPageBreakParagraph;
+      const hasOnlyAbsoluteImages = hasImage && node.children.every(
+        (child) => child.type !== "image" || shouldRenderAbsoluteFloatingImage(child)
+      );
+      const editable = (!hasImage || hasOnlyAbsoluteImages) && !isReadOnly && options?.forceReadOnly !== true && (!hasPartialLineRange || paragraphSegmentIsActiveEditable) && !isManualPageBreakParagraph;
       const resolvedPageLayout = options?.pageLayout ?? documentLayout;
       const paragraphContainsLikelyFullPageCoverImage = node.children.some(
         (child) => child.type === "image" && shouldRenderAbsoluteFloatingImage(child) && likelyFullPageCoverImageRelativeToContentBox(
@@ -42371,6 +43176,7 @@ function DocxEditorViewer({
               nodeIndex
             },
             {
+              paragraphLineRange: hasPartialLineRange ? paragraphLineRange : void 0,
               pageFlowTopPx: paragraphPageFlowTopPx,
               pageFlowForeignExclusions: options?.pageFlowForeignExclusions,
               pageLayout: resolvedPageLayout,
@@ -42380,7 +43186,26 @@ function DocxEditorViewer({
         }
         return fallbackParagraphRuns;
       };
-      const renderedInteractiveParagraphContent = shouldRenderParagraphSegmentWithPretext ? /* @__PURE__ */ jsx(
+      const canReusePlainParagraphHtml = editable && !hasPartialLineRange && !hasImage && !hasDualWrappedFloatingImage && !isDraggingImage && !paragraphHasFormField2(node) && !node.children.some(
+        (child) => child.type === "text" && child.noteReference
+      ) && (options?.pageFlowForeignExclusions?.length ?? 0) === 0;
+      const plainParagraphHtmlContext = canReusePlainParagraphHtml ? [
+        nodeIndex,
+        fontMetricsRevision,
+        documentContentTheme,
+        editor.model.metadata.numberingDefinitions,
+        numberingLabel?.text,
+        numberingLabel?.imageSrc,
+        paragraphRenderTextWidthPx,
+        commentsEnabled,
+        editor.model.metadata.comments,
+        JSON.stringify(tocLinkColorByLevel)
+      ] : void 0;
+      const cachedPlainParagraph = canReusePlainParagraphHtml ? plainParagraphHtmlCacheRef.current.get(node) : void 0;
+      const reusablePlainParagraph = cachedPlainParagraph && plainParagraphHtmlContext?.every(
+        (value, index) => Object.is(value, cachedPlainParagraph.context[index])
+      ) ? cachedPlainParagraph : void 0;
+      const renderedInteractiveParagraphContent = reusablePlainParagraph ? null : shouldRenderParagraphSegmentWithPretext && hasDualWrappedFloatingImage ? getFallbackParagraphRuns() : shouldRenderParagraphSegmentWithPretext ? /* @__PURE__ */ jsx(
         "div",
         {
           style: {
@@ -42425,20 +43250,25 @@ function DocxEditorViewer({
           )
         }
       ) : getFallbackParagraphRuns();
-      const renderedEditableParagraphHtml = renderStaticHtml(
-        renderedInteractiveParagraphContent
-      );
+      const renderedEditableParagraphHtml = reusablePlainParagraph?.html ?? (editable && !hasImage ? renderStaticHtml(renderedInteractiveParagraphContent) : "");
+      if (plainParagraphHtmlContext && !reusablePlainParagraph) {
+        plainParagraphHtmlCacheRef.current.set(node, {
+          context: plainParagraphHtmlContext,
+          html: renderedEditableParagraphHtml
+        });
+      }
       return /* @__PURE__ */ jsx(
         "div",
         {
           "data-docx-paragraph-host": "true",
           "data-docx-paragraph-kind": "paragraph",
           "data-docx-paragraph-node-index": nodeIndex,
+          "data-docx-paragraph-line-height": paragraphSegmentLineHeightPx,
           "data-docx-paragraph-start-line": paragraphSegmentStartLine,
           "data-docx-paragraph-end-line": paragraphSegmentEndLine,
           "data-docx-paragraph-partial-line-range": hasPartialLineRange ? "true" : void 0,
           style: paragraphStyle,
-          dangerouslySetInnerHTML: editable ? stableInnerHtmlProp(
+          dangerouslySetInnerHTML: editable && !hasImage ? stableInnerHtmlProp(
             editableParagraphHtmlPropsRef.current,
             nodeIndex,
             renderedEditableParagraphHtml
@@ -43012,7 +43842,7 @@ ${currentText.slice(end)}`;
               }
             }
           },
-          children: !editable ? renderedInteractiveParagraphContent : null
+          children: !editable || hasImage ? renderedInteractiveParagraphContent : null
         },
         paragraphLineRange ? `epoch-${paragraphStructureEpoch}-node-${nodeIndex}-lines-${paragraphSegmentStartLine}-${paragraphSegmentEndLine}${options?.syntheticKeySuffix ? `-${options.syntheticKeySuffix}` : ""}` : `epoch-${paragraphStructureEpoch}-node-${nodeIndex}${options?.syntheticKeySuffix ? `-${options.syntheticKeySuffix}` : ""}`
       );
@@ -43021,7 +43851,7 @@ ${currentText.slice(end)}`;
     const tableRowSliceTopBleedPxForWrapper = tableRowSlice && tableRowSliceOffsetPxForWrapper > 0 ? TABLE_ROW_SLICE_VISUAL_BLEED_PX : 0;
     const tableRowSliceBottomBleedPxForWrapper = tableRowSlice ? TABLE_ROW_SLICE_VISUAL_BLEED_PX : 0;
     const floatingTablePageLayout = options?.pageLayout ?? documentLayout;
-    const floatingTableGeometry = node.style?.floating && !tableRowRange && !tableRowSlice ? resolveFloatingTableGeometry(node, nodeContentWidthPx, {
+    const floatingTableGeometry = (node.style?.floating || objectWrapDragPreview?.tableIndex === nodeIndex) && !tableRowRange && !tableRowSlice ? resolveFloatingTableGeometry(node.style?.floating ? node : { ...node, style: { ...node.style, floating: {} } }, nodeContentWidthPx, {
       tableWidthPx: estimateFloatingTableWidthPx(
         node,
         nodeContentWidthPx
@@ -43042,6 +43872,16 @@ ${currentText.slice(end)}`;
           }
           if (element) {
             tableElementsRef.current.set(nodeIndex, element);
+            if (floatingTableGeometry) element.style.top = `${floatingTableGeometry.topPx}px`;
+            const anchor = node.style?.floating?.verticalAnchor;
+            const yPx = twipsToSignedPixels(node.style?.floating?.yTwips);
+            const surface = element.closest("[data-docx-page-surface='true']");
+            if (floatingTableGeometry && surface && element.parentElement && yPx !== void 0 && (anchor === "page" || anchor === "margin")) {
+              const scale = resolveViewerMeasurementZoomScale(element, 1);
+              const origin = surface.getBoundingClientRect().top;
+              const hostTop = element.parentElement.getBoundingClientRect().top;
+              element.style.top = `${(origin - hostTop) / scale + yPx + (anchor === "margin" ? floatingTablePageLayout.marginsPx.top : 0)}px`;
+            }
           } else {
             tableElementsRef.current.delete(nodeIndex);
           }
@@ -43057,11 +43897,6 @@ ${currentText.slice(end)}`;
             node,
             twipsToSignedPixels(node.style?.indentTwips) ?? 0
           ),
-          ...tableFloatingDragPreview?.tableIndex === nodeIndex ? {
-            transform: `translate(${tableFloatingDragPreview.deltaX}px, ${tableFloatingDragPreview.deltaY}px)`,
-            zIndex: 30,
-            opacity: 0.9
-          } : void 0,
           ...tableRowSlice ? {
             height: Math.max(
               MIN_PARAGRAPH_LINE_HEIGHT_PX,
@@ -43719,7 +44554,10 @@ ${currentText.slice(end)}`;
                                   if (!cellEditorElement || !cellEditorElement.isConnected) {
                                     return;
                                   }
-                                  cellEditorElement.focus();
+                                  if (document.activeElement === cellEditorElement) {
+                                    return;
+                                  }
+                                  cellEditorElement.focus({ preventScroll: true });
                                   const paragraphSelector2 = `[data-docx-paragraph-kind='table-cell'][data-docx-table-index='${nodeIndex}'][data-docx-row-index='${rowIndex}'][data-docx-cell-index='${cellIndex}'][data-docx-table-paragraph-index]`;
                                   const paragraphElements2 = Array.from(
                                     cellEditorElement.querySelectorAll(
@@ -44008,12 +44846,12 @@ ${currentText.slice(end)}`;
                                           return;
                                         }
                                       }
-                                      window.requestAnimationFrame(() => {
+                                      const applyPendingFocus = () => {
                                         const latestPendingFocus = pendingTableCellFocusRef.current;
                                         if (!latestPendingFocus || latestPendingFocus.cellElementKey !== cellElementKey || !element.isConnected) {
                                           return;
                                         }
-                                        element.focus();
+                                        element.focus({ preventScroll: true });
                                         const boundary = latestPendingFocus.boundary;
                                         const boundaryInCurrentCell = Boolean(
                                           boundary && boundary.location.kind === "table-cell" && boundary.location.tableIndex === nodeIndex && boundary.location.rowIndex === rowIndex && boundary.location.cellIndex === cellIndex
@@ -44075,7 +44913,8 @@ ${currentText.slice(end)}`;
                                           cellIndex
                                         );
                                         pendingTableCellFocusRef.current = void 0;
-                                      });
+                                      };
+                                      applyPendingFocus();
                                     }
                                   },
                                   onInput: (event) => {
@@ -45001,11 +45840,28 @@ ${currentText.slice(end)}`;
     }
     return renderedTableBlock;
   };
+  const objectDragPageRenderCacheRef = React.useRef(
+    /* @__PURE__ */ new Map()
+  );
+  if (!objectWrapDragPreview) objectDragPageRenderCacheRef.current.clear();
   const renderNodeSegments = React.useCallback(
     (nodeSegments, options) => {
+      const dragSourceIndex = objectWrapDragPreview?.tableIndex ?? (objectWrapDragPreview?.imageKey?.startsWith("p:") ? Number(objectWrapDragPreview.imageKey.split(":")[1]) : -1);
+      const dragPagePreview = objectWrapDragPreview?.bandsByPage.has(
+        options?.pageIndex ?? -1
+      ) ? objectWrapDragPreview : objectWrapDragPreview && nodeSegments.some((segment) => segment.nodeIndex === dragSourceIndex) ? "source" : void 0;
+      const cacheKey = JSON.stringify([
+        options?.pageIndex,
+        nodeSegments,
+        options?.pageLayout
+      ]);
+      const cached = objectDragPageRenderCacheRef.current.get(cacheKey);
+      if (objectWrapDragPreview && cached?.model === editor.model && cached.fontRevision === fontMetricsRevision && cached.theme === documentContentTheme && cached.preview === dragPagePreview)
+        return cached.rendered;
       const rendered = [];
       let pageFlowTopPx = 0;
       const resolvedPageLayout = options?.pageLayout ?? documentLayout;
+      const liveWrapBands = objectWrapDragPreview?.bandsByPage.get(options?.pageIndex ?? -1) ?? measuredWrapBands;
       const foreignWrapExclusionsBySegmentIndex = precomputePageSegmentForeignWrapExclusions(
         nodeSegments,
         editor.model,
@@ -45017,7 +45873,10 @@ ${currentText.slice(end)}`;
         {
           floatingMovePreview,
           resizePreview,
-          measuredWrapBands
+          measuredWrapBands: liveWrapBands,
+          draggedImageKey: objectWrapDragPreview?.imageKey,
+          draggedTableIndex: objectWrapDragPreview?.tableIndex,
+          dragObstacle: objectWrapDragPreview?.pageIndex === options?.pageIndex ? objectWrapDragPreview?.obstacle : void 0
         }
       );
       for (let offset = 0; offset < nodeSegments.length; offset += 1) {
@@ -45671,7 +46530,7 @@ ${currentText.slice(end)}`;
           }
         }
         const segmentParagraphLineRange = segment.paragraphLineRange;
-        const measuredSegmentFlowTopPx = node.type === "paragraph" && (!segmentParagraphLineRange || segmentParagraphLineRange.startLineIndex === 0 && segmentParagraphLineRange.endLineIndex >= segmentParagraphLineRange.totalLineCount) ? measuredWrapBands.get(`para:${nodeIndex}`)?.topPx : void 0;
+        const measuredSegmentFlowTopPx = node.type === "table" && node.style?.floating ? liveWrapBands.get(`tblanchor:${nodeIndex}`)?.topPx : node.type === "paragraph" && (!segmentParagraphLineRange || segmentParagraphLineRange.startLineIndex === 0 && segmentParagraphLineRange.endLineIndex >= segmentParagraphLineRange.totalLineCount) ? liveWrapBands.get(`para:${nodeIndex}`)?.topPx : void 0;
         rendered.push(
           renderDocumentNode(
             node,
@@ -45696,10 +46555,19 @@ ${currentText.slice(end)}`;
           docGridLinePitchPxByNodeIndex.get(nodeIndex)
         );
       }
+      objectDragPageRenderCacheRef.current.set(cacheKey, {
+        model: editor.model,
+        fontRevision: fontMetricsRevision,
+        theme: documentContentTheme,
+        preview: dragPagePreview,
+        rendered
+      });
       return rendered;
     },
     [
       activeEditableParagraphSegment,
+      fontMetricsRevision,
+      documentContentTheme,
       beginDropCapMove,
       beginDropCapResize,
       clearObjectSelectionForParagraphEntry,
@@ -45710,6 +46578,7 @@ ${currentText.slice(end)}`;
       dropCapResizePreview,
       editor,
       floatingMovePreview,
+      objectWrapDragPreview,
       focusDropCapWrappedParagraph,
       hoveredDropCapNodeIndex,
       isReadOnly,
@@ -45922,6 +46791,7 @@ ${currentText.slice(end)}`;
       onDragOver: onCanvasDragOver,
       onDragLeave: onCanvasDragLeave,
       onDrop: (event) => void onCanvasDrop(event),
+      onDoubleClickCapture: onViewerFormFieldDoubleClick,
       onPointerDownCapture: onViewerPointerDown,
       onPointerMoveCapture: onViewerPointerMove,
       onPointerLeave: onViewerPointerLeave,
@@ -46434,6 +47304,7 @@ ${currentText.slice(end)}`;
                           ref: (element) => {
                             if (element) {
                               pageBodyElementsRef.current.set(pageIndex, element);
+                              element.dataset.docxPageBody = "true";
                             } else {
                               pageBodyElementsRef.current.delete(pageIndex);
                             }
@@ -46610,6 +47481,7 @@ ${currentText.slice(end)}`;
                                     React.Fragment,
                                     {
                                       children: renderNodeSegments(group.segments, {
+                                        pageIndex,
                                         pageLayout,
                                         suppressLikelyFullPageCoverImageKeys: suppressedLikelyFullPageCoverImageKeys
                                       })
@@ -48139,7 +49011,7 @@ async function parseDocxForViewer(source, options = {}) {
   const readFinishedAt = now();
   const importResult = await importDocxBuffer(buffer, {
     signal: options.signal,
-    transferBuffer: options.transferBuffer,
+    transferBuffer: options.transferBuffer ?? !(source instanceof ArrayBuffer),
     useWorker: options.useWorker
   });
   const importFinishedAt = now();
@@ -48156,6 +49028,9 @@ async function parseDocxForViewer(source, options = {}) {
         }
       });
     }
+    if (faces.length > 0) {
+      invalidateFontMetrics();
+    }
     faces = [];
   };
   const loadEmbeddedFonts = () => {
@@ -48189,6 +49064,9 @@ async function parseDocxForViewer(source, options = {}) {
         )
       )).filter((face) => Boolean(face));
       loaded.forEach((face) => document.fonts.add(face));
+      if (loaded.length > 0) {
+        invalidateFontMetrics();
+      }
       faces = loaded;
       try {
         await document.fonts.ready;
@@ -49774,7 +50652,8 @@ function useDocxModel(file) {
       try {
         const { model } = await importDocxBuffer(docxFile, {
           signal: abortController.signal,
-          transferBuffer: false
+          transferBuffer: false,
+          useWorker: "required"
         });
         if (!isCurrent) {
           return;