pptx-react-viewer 4.49.0 → 4.50.0

package/dist/{chunk-ME5QRTVS.js → chunk-D5NXYXPP.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkJAI42EXQ_js = require('./chunk-JAI42EXQ.js');
+var chunkJWNBTFZZ_js = require('./chunk-JWNBTFZZ.js');
 var pptx = require('ooxml-ui/pptx');
 var React17 = require('react');
 var jsxRuntime = require('react/jsx-runtime');
@@ -80,240 +80,59 @@ function useVirtualizedSlides({
     scrollToIndex
   };
 }
+function useController(controller) {
+  return React17.useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+}
+
+// src/viewer/hooks/collaboration/collaboration-modules.ts
+var collabModules = {
+  loadYjs: () => import('yjs'),
+  loadWebsocket: () => import('./y-websocket-EDOMWMAD.js'),
+  loadWebrtc: () => import('./y-webrtc-QVVT5PCK.js')
+};
+
+// src/viewer/hooks/collaboration/useYjsProvider.ts
 function useYjsProvider({ config: inputConfig }) {
   const config = inputConfig?.externalSession ? void 0 : inputConfig;
-  const [status, setStatus] = React17.useState("disconnected");
-  const [awareness, setAwareness] = React17.useState(null);
-  const [doc, setDoc] = React17.useState(null);
-  const [clientId, setClientId] = React17.useState(null);
-  const [synced, setSynced] = React17.useState(false);
-  const cleanupRef = React17.useRef(null);
-  const generationRef = React17.useRef(0);
-  const timeoutRef = React17.useRef(null);
-  const departureRef = React17.useRef(null);
-  const gateRef = React17.useRef(null);
-  if (!gateRef.current) {
-    gateRef.current = pptx.createSyncGate(() => setSynced(true));
-  }
-  const teardown = React17.useCallback(() => {
-    generationRef.current += 1;
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-      timeoutRef.current = null;
-    }
-    gateRef.current?.reset();
-    setSynced(false);
-    cleanupRef.current?.();
-    cleanupRef.current = null;
-  }, []);
-  const announceDeparture = React17.useCallback(() => {
-    departureRef.current?.announce();
-    departureRef.current?.dispose();
-    departureRef.current = null;
-  }, []);
-  const buildCleanup = React17.useCallback(
-    (provider, yDoc) => () => {
-      announceDeparture();
-      pptx.clearLocalAwareness(provider.awareness);
-      provider.destroy();
-      yDoc.destroy();
-      setDoc(null);
-      setAwareness(null);
-      setClientId(null);
-      setStatus("disconnected");
-    },
-    [announceDeparture]
+  const [controller] = React17.useState(
+    () => pptx.createCollaborationSessionController({ modules: collabModules, registerTeardown: false })
   );
-  const initWebrtc = React17.useCallback(async () => {
-    const generation = generationRef.current;
-    if (!config) {
-      return;
-    }
-    setStatus("connecting");
-    try {
-      const [Y, { WebrtcProvider }] = await Promise.all([import('yjs'), import('./y-webrtc-DVPQNFLL.js')]);
-      if (generation !== generationRef.current) {
-        return;
-      }
-      const yDoc = new Y.Doc();
-      const opts = {};
-      if (config.signaling && config.signaling.length > 0) {
-        opts.signaling = config.signaling;
-      }
-      if (config.authToken) {
-        opts.password = config.authToken;
-      }
-      const roomId = pptx.validateRoomId(config.roomId);
-      const provider = new WebrtcProvider(roomId, yDoc, opts);
-      departureRef.current = pptx.createDepartureChannel(roomId, provider.awareness);
-      setDoc(yDoc);
-      setAwareness(provider.awareness);
-      setClientId(provider.awareness.clientID);
-      setStatus("connected");
-      const handleSynced = (event) => {
-        if (event?.synced !== false) {
-          gateRef.current?.open();
-        }
-      };
-      provider.on("synced", handleSynced);
-      gateRef.current?.arm();
-      const handleStatus = (event) => {
-        if (event.connected === false) {
-          setStatus("disconnected");
-          gateRef.current?.reset();
-          setSynced(false);
-          gateRef.current?.arm();
-        } else if (event.connected) {
-          setStatus("connected");
-        }
-      };
-      provider.on("status", handleStatus);
-      const baseCleanup = buildCleanup(provider, yDoc);
-      cleanupRef.current = () => {
-        provider.off("synced", handleSynced);
-        provider.off("status", handleStatus);
-        baseCleanup();
-      };
-    } catch (err) {
-      if (generation !== generationRef.current) {
-        return;
-      }
-      console.warn(
-        "[pptx-viewer] WebRTC collaboration packages not available:",
-        err instanceof Error ? err.message : err
-      );
-      setStatus("error");
-    }
-  }, [config?.roomId, config?.authToken, config?.signaling, buildCleanup]);
-  const init = React17.useCallback(async () => {
-    teardown();
-    const generation = generationRef.current;
+  const state = useController(controller);
+  const signalingKey = config?.signaling?.join("\n");
+  React17.useEffect(() => {
     if (!config) {
+      controller.stop();
       return;
     }
-    const roomId = pptx.validateRoomId(config.roomId);
-    const transport = config.transport ?? pptx.resolveTransportForServerUrl(config.serverUrl);
-    if (transport === "webrtc") {
-      await initWebrtc();
-      return;
-    }
-    if (pptx.isMixedContentBlocked(config.serverUrl)) {
-      console.warn(
-        `[pptx-viewer] Refusing to connect: insecure ws:// server "${config.serverUrl}" is blocked from a secure (https) page. Use a wss:// URL.`
-      );
-      setStatus("error");
-      return;
-    }
-    setStatus("connecting");
-    try {
-      const [Y, { WebsocketProvider }] = await Promise.all([import('yjs'), import('./y-websocket-TN4OKPXQ.js')]);
-      if (generation !== generationRef.current) {
-        return;
-      }
-      const yDoc = new Y.Doc();
-      const provider = new WebsocketProvider(config.serverUrl, roomId, yDoc, {
-        params: config.authToken ? { token: config.authToken } : void 0
-      });
-      departureRef.current = pptx.createDepartureChannel(roomId, provider.awareness);
-      let connected = false;
-      const handleStatus = (event) => {
-        if (event.status === "connected") {
-          connected = true;
-          if (timeoutRef.current) {
-            clearTimeout(timeoutRef.current);
-            timeoutRef.current = null;
-          }
-          setStatus("connected");
-          gateRef.current?.arm();
-        } else if (event.status === "disconnected") {
-          setStatus("disconnected");
-          gateRef.current?.reset();
-          setSynced(false);
-          gateRef.current?.arm();
-        }
-      };
-      const handleSynced = (isSynced) => {
-        if (isSynced) {
-          gateRef.current?.open();
-        }
-      };
-      provider.on("status", handleStatus);
-      provider.on("sync", handleSynced);
-      if (provider.wsconnected) {
-        connected = true;
-        setStatus("connected");
-        gateRef.current?.arm();
-      }
-      if (provider.synced) {
-        gateRef.current?.open();
-      }
-      if (!connected) {
-        timeoutRef.current = setTimeout(() => {
-          timeoutRef.current = null;
-          if (!connected) {
-            provider.off("status", handleStatus);
-            provider.off("sync", handleSynced);
-            announceDeparture();
-            pptx.clearLocalAwareness(provider.awareness);
-            provider.destroy();
-            yDoc.destroy();
-            setDoc(null);
-            setAwareness(null);
-            setClientId(null);
-            cleanupRef.current = null;
-            setStatus("error");
-          }
-        }, pptx.CONNECTION_TIMEOUT_MS);
-      }
-      setDoc(yDoc);
-      setAwareness(provider.awareness);
-      setClientId(provider.awareness.clientID);
-      cleanupRef.current = () => {
-        provider.off("status", handleStatus);
-        provider.off("sync", handleSynced);
-        announceDeparture();
-        pptx.clearLocalAwareness(provider.awareness);
-        provider.destroy();
-        yDoc.destroy();
-        setDoc(null);
-        setAwareness(null);
-        setClientId(null);
-        setStatus("disconnected");
-      };
-    } catch (err) {
-      if (generation !== generationRef.current) {
-        return;
-      }
-      console.warn(
-        "[pptx-viewer] Collaboration packages not available:",
-        err instanceof Error ? err.message : err
-      );
-      setStatus("error");
-    }
+    void controller.start(config);
+    const disposeTeardown = pptx.registerCollaborationTeardown({
+      leave: () => controller.stop(),
+      rejoin: () => void controller.retry()
+    });
+    return () => {
+      disposeTeardown();
+      controller.stop();
+    };
   }, [
+    controller,
     config?.roomId,
     config?.serverUrl,
     config?.authToken,
     config?.transport,
-    announceDeparture,
-    initWebrtc,
-    teardown
+    signalingKey,
+    Boolean(config)
   ]);
-  React17.useEffect(() => {
-    init();
-    const disposeTeardown = pptx.registerCollaborationTeardown({
-      leave: teardown,
-      rejoin: init
-    });
-    return () => {
-      disposeTeardown();
-      teardown();
-    };
-  }, [init, teardown]);
-  const retry = React17.useCallback(() => {
-    init();
-  }, [init]);
-  return { status, awareness, doc, clientId, synced, retry };
+  const session = state.active ? controller.getSession() : null;
+  return {
+    status: state.status,
+    awareness: session?.awareness ?? null,
+    doc: session?.doc ?? null,
+    clientId: state.clientId,
+    synced: state.synced,
+    retry: () => {
+      void controller.retry();
+    }
+  };
 }
 function usePresenceTracking({
   awareness,
@@ -762,15 +581,11 @@ function serializeHistoryDocument(snapshot) {
     )
   });
 }
-function recordExplicitSlideUpdate(past, future, previous, before, label, maxDepth) {
+function recordExplicitSlideUpdate(history, previous, before, label) {
   if (previous && serializeHistoryDocument(previous) !== serializeHistoryDocument(before)) {
-    past.push(chunkJAI42EXQ_js.cloneHistorySnapshot(previous));
-  }
-  past.push({ ...chunkJAI42EXQ_js.cloneHistorySnapshot(before), actionLabel: label });
-  while (past.length > Math.max(1, maxDepth)) {
-    past.shift();
+    history.record(chunkJWNBTFZZ_js.cloneHistorySnapshot(previous), previous.actionLabel);
   }
-  future.length = 0;
+  history.record({ ...chunkJWNBTFZZ_js.cloneHistorySnapshot(before), actionLabel: label }, label);
 }
 var POLL_INTERVAL_MS = 16;
 function usePointerReleaseWakeup(hasActivePointerInteraction) {
@@ -806,7 +621,6 @@ function usePointerReleaseWakeup(hasActivePointerInteraction) {
 }
 
 // src/viewer/hooks/useEditorHistory.ts
-var DEFAULT_MAX_HISTORY_ENTRIES = 120;
 function useEditorHistory(input) {
   const {
     slides,
@@ -815,7 +629,7 @@ function useEditorHistory(input) {
     templateElementsBySlideId,
     loading,
     error,
-    maxHistoryEntries = DEFAULT_MAX_HISTORY_ENTRIES,
+    maxHistoryEntries,
     hasActivePointerInteraction,
     pointerCommitNonce,
     onDirty,
@@ -826,38 +640,31 @@ function useEditorHistory(input) {
     setSelectedElementId,
     setSelectedElementIds
   } = input;
-  const historyPastRef = React17.useRef([]);
-  const historyFutureRef = React17.useRef([]);
+  const [history] = React17.useState(() => pptx.createEditorHistoryController());
+  const historyState = useController(history);
   const lastHistorySnapshotRef = React17.useRef(null);
   const lastHistorySerializedRef = React17.useRef("");
   const lastCheapHashRef = React17.useRef("");
   const isApplyingHistoryRef = React17.useRef(false);
   const trackingHeldRef = React17.useRef(false);
   const unlockHistoryTimerRef = React17.useRef(null);
-  const [canUndo, setCanUndo] = React17.useState(false);
-  const [canRedo, setCanRedo] = React17.useState(false);
-  const [undoLabel, setUndoLabel] = React17.useState(void 0);
-  const [redoLabel, setRedoLabel] = React17.useState(void 0);
   const [editCommitNonce, setEditCommitNonce] = React17.useState(0);
   const { pointerReleaseNonce, deferUntilPointerReleased } = usePointerReleaseWakeup(
     hasActivePointerInteraction
   );
-  const updateHistoryAvailability = React17.useCallback(() => {
-    setCanUndo(historyPastRef.current.length > 0);
-    setCanRedo(historyFutureRef.current.length > 0);
-    const pastTop = historyPastRef.current[historyPastRef.current.length - 1];
-    setUndoLabel(pastTop?.actionLabel);
-    const futureTop = historyFutureRef.current[historyFutureRef.current.length - 1];
-    setRedoLabel(futureTop?.actionLabel);
-  }, []);
+  React17.useEffect(() => {
+    if (maxHistoryEntries !== void 0) {
+      history.setMaxDepth(maxHistoryEntries);
+    }
+  }, [history, maxHistoryEntries]);
   const buildHistorySnapshot = React17.useCallback(
     (actionLabel) => {
       return {
         width: canvasSize.width,
         height: canvasSize.height,
         activeSlideIndex,
-        slides: slides.map(chunkJAI42EXQ_js.cloneSlide),
-        templateElementsBySlideId: chunkJAI42EXQ_js.cloneTemplateElementsBySlideId(templateElementsBySlideId),
+        slides: slides.map(chunkJWNBTFZZ_js.cloneSlide),
+        templateElementsBySlideId: chunkJWNBTFZZ_js.cloneTemplateElementsBySlideId(templateElementsBySlideId),
         ...actionLabel ? { actionLabel } : {}
       };
     },
@@ -870,9 +677,9 @@ function useEditorHistory(input) {
         width: snapshot.width,
         height: snapshot.height
       });
-      setSlides(snapshot.slides.map(chunkJAI42EXQ_js.cloneSlide));
+      setSlides(snapshot.slides.map(chunkJWNBTFZZ_js.cloneSlide));
       setTemplateElementsBySlideId(
-        chunkJAI42EXQ_js.cloneTemplateElementsBySlideId(snapshot.templateElementsBySlideId)
+        chunkJWNBTFZZ_js.cloneTemplateElementsBySlideId(snapshot.templateElementsBySlideId)
       );
       setActiveSlideIndex(Math.min(snapshot.activeSlideIndex, maxSlideIndex));
       setSelectedElementIds([]);
@@ -904,64 +711,50 @@ function useEditorHistory(input) {
     onDirtyRef.current?.();
   }, []);
   const handleUndo = React17.useCallback(() => {
-    const previousSnapshot = historyPastRef.current.pop();
-    if (!previousSnapshot) {
+    if (!history.getSnapshot().canUndo) {
+      return;
+    }
+    const result = history.undo(buildHistorySnapshot());
+    if (!result) {
       return;
     }
-    const currentSnapshot = buildHistorySnapshot(previousSnapshot.actionLabel);
-    historyFutureRef.current.push(currentSnapshot);
     isApplyingHistoryRef.current = true;
-    const nextSnapshot = chunkJAI42EXQ_js.cloneHistorySnapshot(previousSnapshot);
-    lastHistorySnapshotRef.current = chunkJAI42EXQ_js.cloneHistorySnapshot(nextSnapshot);
+    const nextSnapshot = chunkJWNBTFZZ_js.cloneHistorySnapshot(result.snapshot);
+    lastHistorySnapshotRef.current = chunkJWNBTFZZ_js.cloneHistorySnapshot(nextSnapshot);
     lastHistorySerializedRef.current = serializeHistoryDocument(nextSnapshot);
     applyHistorySnapshot(nextSnapshot);
-    updateHistoryAvailability();
     unlockHistoryTracking();
     markDirty();
-  }, [
-    applyHistorySnapshot,
-    buildHistorySnapshot,
-    markDirty,
-    unlockHistoryTracking,
-    updateHistoryAvailability
-  ]);
+  }, [applyHistorySnapshot, buildHistorySnapshot, history, markDirty, unlockHistoryTracking]);
   const handleRedo = React17.useCallback(() => {
-    const nextSnapshot = historyFutureRef.current.pop();
-    if (!nextSnapshot) {
+    if (!history.getSnapshot().canRedo) {
+      return;
+    }
+    const result = history.redo(buildHistorySnapshot());
+    if (!result) {
       return;
     }
-    const currentSnapshot = buildHistorySnapshot(nextSnapshot.actionLabel);
-    historyPastRef.current.push(currentSnapshot);
     isApplyingHistoryRef.current = true;
-    const targetSnapshot = chunkJAI42EXQ_js.cloneHistorySnapshot(nextSnapshot);
-    lastHistorySnapshotRef.current = chunkJAI42EXQ_js.cloneHistorySnapshot(targetSnapshot);
+    const targetSnapshot = chunkJWNBTFZZ_js.cloneHistorySnapshot(result.snapshot);
+    lastHistorySnapshotRef.current = chunkJWNBTFZZ_js.cloneHistorySnapshot(targetSnapshot);
     lastHistorySerializedRef.current = serializeHistoryDocument(targetSnapshot);
     applyHistorySnapshot(targetSnapshot);
-    updateHistoryAvailability();
     unlockHistoryTracking();
     markDirty();
-  }, [
-    applyHistorySnapshot,
-    buildHistorySnapshot,
-    markDirty,
-    unlockHistoryTracking,
-    updateHistoryAvailability
-  ]);
+  }, [applyHistorySnapshot, buildHistorySnapshot, history, markDirty, unlockHistoryTracking]);
   const resetHistory = React17.useCallback(
     (initialSnapshot) => {
-      historyPastRef.current = [];
-      historyFutureRef.current = [];
+      history.clear();
       if (initialSnapshot) {
-        const clonedInitial = chunkJAI42EXQ_js.cloneHistorySnapshot(initialSnapshot);
+        const clonedInitial = chunkJWNBTFZZ_js.cloneHistorySnapshot(initialSnapshot);
         lastHistorySnapshotRef.current = clonedInitial;
         lastHistorySerializedRef.current = serializeHistoryDocument(clonedInitial);
       } else {
         lastHistorySnapshotRef.current = null;
         lastHistorySerializedRef.current = "";
       }
-      updateHistoryAvailability();
     },
-    [updateHistoryAvailability]
+    [history]
   );
   React17.useEffect(() => {
     return () => {
@@ -1004,19 +797,13 @@ function useEditorHistory(input) {
       lastHistorySnapshotRef.current = snapshot;
       lastHistorySerializedRef.current = serialized;
       lastCheapHashRef.current = cheapHash;
-      updateHistoryAvailability();
       return;
     }
     onDirtyRef.current?.();
-    historyPastRef.current.push(previousSnapshot);
-    while (historyPastRef.current.length > Math.max(1, maxHistoryEntries)) {
-      historyPastRef.current.shift();
-    }
-    historyFutureRef.current = [];
+    history.record(previousSnapshot, previousSnapshot.actionLabel);
     lastHistorySnapshotRef.current = snapshot;
     lastHistorySerializedRef.current = serialized;
     lastCheapHashRef.current = cheapHash;
-    updateHistoryAvailability();
   }, [
     activeSlideIndex,
     buildHistorySnapshot,
@@ -1026,30 +813,21 @@ function useEditorHistory(input) {
     editCommitNonce,
     error,
     hasActivePointerInteraction,
+    history,
     loading,
-    maxHistoryEntries,
     pointerCommitNonce,
     pointerReleaseNonce,
-    slides,
-    updateHistoryAvailability
+    slides
   ]);
   const commitSlides = (nextSlides, label, beforeSlides = slides) => {
-    const before = { ...buildHistorySnapshot(), slides: beforeSlides.map(chunkJAI42EXQ_js.cloneSlide) };
-    const after = { ...before, slides: nextSlides.map(chunkJAI42EXQ_js.cloneSlide) };
-    recordExplicitSlideUpdate(
-      historyPastRef.current,
-      historyFutureRef.current,
-      lastHistorySnapshotRef.current,
-      before,
-      label,
-      maxHistoryEntries
-    );
-    lastHistorySnapshotRef.current = chunkJAI42EXQ_js.cloneHistorySnapshot(after);
+    const before = { ...buildHistorySnapshot(), slides: beforeSlides.map(chunkJWNBTFZZ_js.cloneSlide) };
+    const after = { ...before, slides: nextSlides.map(chunkJWNBTFZZ_js.cloneSlide) };
+    recordExplicitSlideUpdate(history, lastHistorySnapshotRef.current, before, label);
+    lastHistorySnapshotRef.current = chunkJWNBTFZZ_js.cloneHistorySnapshot(after);
     lastHistorySerializedRef.current = serializeHistoryDocument(after);
     isApplyingHistoryRef.current = false;
     setSlides(nextSlides);
     onDirtyRef.current?.();
-    updateHistoryAvailability();
   };
   const holdTracking = React17.useCallback((held) => {
     trackingHeldRef.current = held;
@@ -1057,10 +835,10 @@ function useEditorHistory(input) {
   return {
     commitSlides,
     holdTracking,
-    canUndo,
-    canRedo,
-    undoLabel,
-    redoLabel,
+    canUndo: historyState.canUndo,
+    canRedo: historyState.canRedo,
+    undoLabel: historyState.undoLabel,
+    redoLabel: historyState.redoLabel,
     handleUndo,
     handleRedo,
     resetHistory,
@@ -1230,22 +1008,22 @@ function useZoomViewport({
     selectedElements.forEach((element) => {
       minX = Math.min(minX, element.x);
       minY = Math.min(minY, element.y);
-      maxX = Math.max(maxX, element.x + Math.max(element.width, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE));
-      maxY = Math.max(maxY, element.y + Math.max(element.height, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE));
+      maxX = Math.max(maxX, element.x + Math.max(element.width, chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE));
+      maxY = Math.max(maxY, element.y + Math.max(element.height, chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE));
     });
     if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(maxX) || !Number.isFinite(maxY)) {
       return;
     }
     const selectionBounds = { minX, minY, maxX, maxY };
-    const boundsWidth = Math.max(selectionBounds.maxX - selectionBounds.minX, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE);
-    const boundsHeight = Math.max(selectionBounds.maxY - selectionBounds.minY, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE);
+    const boundsWidth = Math.max(selectionBounds.maxX - selectionBounds.minX, chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE);
+    const boundsHeight = Math.max(selectionBounds.maxY - selectionBounds.minY, chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE);
     const availableWidth = Math.max(
-      effectiveEditorDimensions.width - chunkJAI42EXQ_js.ZOOM_TO_SELECTION_PADDING,
-      chunkJAI42EXQ_js.MIN_ELEMENT_SIZE
+      effectiveEditorDimensions.width - chunkJWNBTFZZ_js.ZOOM_TO_SELECTION_PADDING,
+      chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE
     );
     const availableHeight = Math.max(
-      effectiveEditorDimensions.height - chunkJAI42EXQ_js.ZOOM_TO_SELECTION_PADDING,
-      chunkJAI42EXQ_js.MIN_ELEMENT_SIZE
+      effectiveEditorDimensions.height - chunkJWNBTFZZ_js.ZOOM_TO_SELECTION_PADDING,
+      chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE
     );
     const targetEditorScale = Math.min(
       availableWidth / boundsWidth,
@@ -2203,9 +1981,6 @@ function executeSlideTransition(nextSlideIndex, deps) {
 }
 
 // src/viewer/hooks/presentation-mode/useSlideNavigation.ts
-function isClickAdvanceBlocked(slide, direction, trigger) {
-  return trigger === "click" && direction === 1 && slide?.transition?.advanceOnClick === false;
-}
 function useSlideNavigation(input) {
   const {
     slides,
@@ -2255,50 +2030,71 @@ function useSlideNavigation(input) {
   );
   const movePresentationSlide = React17.useCallback(
     (direction, trigger = "explicit") => {
-      if (direction === 1 && playNextAnimationGroup()) {
-        return;
-      }
-      if (isClickAdvanceBlocked(slides[presentationSlideIndex], direction, trigger)) {
+      const showOrder = visibleSlideIndexes.length > 0 ? visibleSlideIndexes : slides.map((_slide, slideIndex) => slideIndex);
+      const current = presentationSlideIndex;
+      const transitionTo = (index, options = {}) => executeSlideTransition(index, {
+        slides,
+        currentSlideIndex: current,
+        onPlayActionSound,
+        onStopActionSound,
+        setPresentationSlideVisible,
+        clearPresentationTimers,
+        setPresentationSlideIndex,
+        onSetActiveSlideIndex,
+        seedSlideAnimations,
+        startSlideAnimations,
+        scheduleAutoAdvanceForSlide: rehearsing ? void 0 : scheduleAutoAdvanceForSlide,
+        presentationTimersRef,
+        setTransitionOverlay,
+        // PowerPoint plays a slide's transition only when advancing into it,
+        // and replays the LEAVING slide's transition in reverse when stepping
+        // back (a morph glides its shapes back to where they came from).
+        playTransition: true,
+        ...options
+      });
+      if (direction === -1) {
+        const step2 = pptx.resolveShowBackward({
+          currentIndex: current,
+          showOrder,
+          endOfShow: false,
+          seededCompleted: false
+        });
+        if (step2.kind === "go") {
+          transitionTo(step2.index, { reverse: true, seedCompleted: true });
+        }
         return;
       }
-      if (direction === 1) {
-        const consumedExcursion = zoomExcursionRef.current;
-        const step = pptx.resolveForwardSlideWithZoomReturn(
-          presentationSlideIndex,
-          void 0,
-          consumedExcursion
-        );
-        if (step.returnedToZoom && step.nextSlideIndex !== void 0) {
-          zoomExcursionRef.current = step.excursion;
-          executeSlideTransition(step.nextSlideIndex, {
-            slides,
-            currentSlideIndex: presentationSlideIndex,
-            onPlayActionSound,
-            onStopActionSound,
-            setPresentationSlideVisible,
-            clearPresentationTimers,
-            setPresentationSlideIndex,
-            onSetActiveSlideIndex,
-            seedSlideAnimations,
-            startSlideAnimations,
+      const step = pptx.resolveShowForward({
+        currentIndex: current,
+        currentSlide: slides[current],
+        showOrder,
+        endOfShow: false,
+        fromClick: trigger === "click",
+        loop: Boolean(loopContinuously) && !rehearsing,
+        endWithBlackSlide: true,
+        zoomExcursion: zoomExcursionRef.current,
+        advanceBuild: playNextAnimationGroup
+      });
+      if (step.kind === "go") {
+        if (step.zoomReturn) {
+          zoomExcursionRef.current = step.zoomReturn.excursion;
+          transitionTo(step.index, {
             scheduleAutoAdvanceForSlide,
-            presentationTimersRef,
-            setTransitionOverlay,
-            playTransition: true,
-            transitionOverride: pptx.buildZoomTransitionOverride(
-              consumedExcursion?.transitionDurationMs
-            )
+            transitionOverride: step.zoomReturn.transitionOverride
           });
           return;
         }
+        if (rehearsing) {
+          recordCurrentSlideTime(current);
+        }
+        transitionTo(step.index);
+        return;
       }
-      const availableSlideIndexes = visibleSlideIndexes.length > 0 ? visibleSlideIndexes : slides.map((_slide, slideIndex) => slideIndex);
-      if (availableSlideIndexes.length === 0) {
+      if (step.kind !== "end-screen" && step.kind !== "exit") {
         return;
       }
-      const pastLastSlide = direction === 1 && !pptx.hasShowSlideAfter(presentationSlideIndex, availableSlideIndexes);
-      if (rehearsing && pastLastSlide) {
-        recordCurrentSlideTime(presentationSlideIndex);
+      if (rehearsing) {
+        recordCurrentSlideTime(current);
         try {
           if (document.fullscreenElement) {
             void document.exitFullscreen().catch(() => {
@@ -2310,41 +2106,7 @@ function useSlideNavigation(input) {
         setShowRehearsalSummary(true);
         return;
       }
-      if (!loopContinuously && !rehearsing && pastLastSlide && onAdvancePastLastSlide) {
-        onAdvancePastLastSlide();
-        return;
-      }
-      const nextSlideIndex = direction === 1 ? pptx.nextShowSlideIndex(presentationSlideIndex, availableSlideIndexes, {
-        loop: Boolean(loopContinuously) && !rehearsing
-      }) : pptx.previousShowSlideIndex(presentationSlideIndex, availableSlideIndexes);
-      if (nextSlideIndex === void 0 || nextSlideIndex === presentationSlideIndex) {
-        return;
-      }
-      if (rehearsing && direction === 1) {
-        recordCurrentSlideTime(presentationSlideIndex);
-      }
-      executeSlideTransition(nextSlideIndex, {
-        slides,
-        currentSlideIndex: presentationSlideIndex,
-        onPlayActionSound,
-        onStopActionSound,
-        setPresentationSlideVisible,
-        clearPresentationTimers,
-        setPresentationSlideIndex,
-        onSetActiveSlideIndex,
-        seedSlideAnimations,
-        startSlideAnimations,
-        scheduleAutoAdvanceForSlide: rehearsing ? void 0 : scheduleAutoAdvanceForSlide,
-        presentationTimersRef,
-        setTransitionOverlay,
-        // PowerPoint plays a slide's transition only when advancing into it,
-        // and replays the LEAVING slide's transition in reverse when stepping
-        // back (a morph glides its shapes back to where they came from).
-        playTransition: true,
-        reverse: direction === -1,
-        // Stepping back onto a slide shows it with its builds already played.
-        seedCompleted: direction === -1
-      });
+      onAdvancePastLastSlide?.();
     },
     [
       clearPresentationTimers,
@@ -4204,6 +3966,7 @@ function useViewerCoreState(_input) {
   const marqueeStateRef = React17.useRef(null);
   const isDrawingRef = React17.useRef(false);
   const justInteractedRef = React17.useRef(false);
+  const gestureControllerRef = React17.useRef(null);
   const livePatcher = React17.useMemo(() => pptx.createCollaborationLivePatcher(), []);
   React17.useEffect(() => () => livePatcher.dispose(), [livePatcher]);
   const [mode, setMode] = React17.useState("edit");
@@ -4212,18 +3975,19 @@ function useViewerCoreState(_input) {
   const { slides, setSlides, slidesRef } = useSlideState();
   const [templateElementsBySlideId, setTemplateElementsBySlideId] = React17.useState({});
   const [canvasSize, setCanvasSize] = React17.useState({
-    width: chunkJAI42EXQ_js.DEFAULT_CANVAS_WIDTH,
-    height: chunkJAI42EXQ_js.DEFAULT_CANVAS_HEIGHT
+    width: chunkJWNBTFZZ_js.DEFAULT_CANVAS_WIDTH,
+    height: chunkJWNBTFZZ_js.DEFAULT_CANVAS_HEIGHT
   });
   const [slideSizeEmu, setSlideSizeEmu] = React17.useState();
   const [activeSlideIndex, setActiveSlideIndex] = React17.useState(0);
   const [selectedElementId, setSelectedElementId] = React17.useState(null);
   const [selectedElementIds, setSelectedElementIds] = React17.useState([]);
   const [isDirty, setIsDirty] = React17.useState(false);
+  const autosaveDraftSinkRef = React17.useRef(null);
   const publishInlineText = React17.useCallback(
     (elementId, text) => {
-      pptx.publishLiveInlineText(
-        livePatcher,
+      pptx.reportInlineTextDraft(
+        { livePatcher, autosave: autosaveDraftSinkRef.current },
         slidesRef.current[activeSlideIndexRef.current],
         elementId,
         text
@@ -4289,6 +4053,7 @@ function useViewerCoreState(_input) {
     imageInputRef,
     mediaInputRef,
     activeSlideIndexRef,
+    autosaveDraftSinkRef,
     ...inlineEditing,
     ...editPointsMode,
     dragStateRef,
@@ -4297,6 +4062,7 @@ function useViewerCoreState(_input) {
     marqueeStateRef,
     isDrawingRef,
     justInteractedRef,
+    gestureControllerRef,
     livePatcher,
     mode,
     setMode,
@@ -4686,12 +4452,12 @@ function useLoadContent({
         }
         resources.commit();
         handlerRef.current = handler;
-        const partition = chunkJAI42EXQ_js.partitionTemplateElements(nextSlides);
+        const partition = chunkJWNBTFZZ_js.partitionTemplateElements(nextSlides);
         setSlides(partition.slides);
         setTemplateElementsBySlideId(partition.templateElementsBySlideId);
         setCanvasSize({
-          width: parsed.width ?? chunkJAI42EXQ_js.DEFAULT_CANVAS_WIDTH,
-          height: parsed.height ?? chunkJAI42EXQ_js.DEFAULT_CANVAS_HEIGHT
+          width: parsed.width ?? chunkJWNBTFZZ_js.DEFAULT_CANVAS_WIDTH,
+          height: parsed.height ?? chunkJWNBTFZZ_js.DEFAULT_CANVAS_HEIGHT
         });
         setSlideSizeEmu(
           typeof parsed.widthEmu === "number" && typeof parsed.heightEmu === "number" && parsed.widthEmu > 0 && parsed.heightEmu > 0 ? {
@@ -4783,96 +4549,43 @@ function useLoadContent({
   return { handlerRef };
 }
 function useAutosave(input) {
-  const { isDirty, filePath, serializeSlides, enabled = true, getChangeSources } = input;
+  const { isDirty, filePath, enabled = true } = input;
   const intervalMs = pptx.resolveAutosaveIntervalMs({
     hostIntervalMs: input.intervalMs,
     optionsIntervalSeconds: input.intervalSeconds
   });
-  const [autosaveStatus, setAutosaveStatus] = React17.useState({
-    state: "idle"
-  });
-  const isDirtyRef = React17.useRef(isDirty);
-  const filePathRef = React17.useRef(filePath);
-  const serializeRef = React17.useRef(serializeSlides);
-  const storageRef = React17.useRef(input.storage);
-  storageRef.current = input.storage;
-  const isSavingRef = React17.useRef(false);
-  const changeSourcesRef = React17.useRef(getChangeSources);
-  const lastSnapshotRef = React17.useRef(void 0);
-  const onSavedRef = React17.useRef(input.onSaved);
-  React17.useEffect(() => {
-    onSavedRef.current = input.onSaved;
-  }, [input.onSaved]);
-  React17.useEffect(() => {
-    isDirtyRef.current = isDirty;
-  }, [isDirty]);
-  React17.useEffect(() => {
-    filePathRef.current = filePath;
-  }, [filePath]);
-  React17.useEffect(() => {
-    serializeRef.current = serializeSlides;
-  }, [serializeSlides]);
+  const live = React17.useRef(input);
+  live.current = input;
+  const [controller] = React17.useState(
+    () => pptx.createAutosaveController({
+      getActivation: () => ({ active: live.current.enabled ?? true }),
+      getFilePath: () => live.current.filePath,
+      getIntervalMs: () => pptx.resolveAutosaveIntervalMs({
+        hostIntervalMs: live.current.intervalMs,
+        optionsIntervalSeconds: live.current.intervalSeconds
+      }),
+      serialize: () => live.current.serializeSlides(),
+      getStorage: () => live.current.storage,
+      onSaved: (data) => live.current.onSaved?.(data),
+      writeSnapshot: pptx.saveAutosaveSnapshot,
+      // serializeSlides already overlays the live inline draft from its refs.
+      getInlineEditingId: () => live.current.getInlineEditingId?.()
+    })
+  );
+  if (input.inlineDraftSinkRef) {
+    input.inlineDraftSinkRef.current = controller;
+  }
+  const { status } = useController(controller);
   React17.useEffect(() => {
-    changeSourcesRef.current = getChangeSources;
-  }, [getChangeSources]);
-  const doAutosave = React17.useCallback(async (options) => {
-    const path = filePathRef.current;
-    if (!path) {
-      return;
-    }
-    const sources = changeSourcesRef.current?.() ?? [];
-    if (!pptx.shouldWriteAutosaveSnapshot({
-      filePath: path,
-      isDirty: isDirtyRef.current,
-      saving: isSavingRef.current,
-      sources: options?.polled === true ? sources : [],
-      lastSnapshot: lastSnapshotRef.current
-    })) {
-      return;
-    }
-    isSavingRef.current = true;
-    setAutosaveStatus({ state: "saving" });
-    try {
-      const data = await serializeRef.current();
-      if (!data) {
-        setAutosaveStatus({ state: "idle" });
-        isSavingRef.current = false;
-        return;
-      }
-      await pptx.saveAutosaveSnapshot(path, data, storageRef.current);
-      lastSnapshotRef.current = pptx.autosaveSnapshotMark(path, sources);
-      setAutosaveStatus({ state: "saved", timestamp: Date.now() });
-      onSavedRef.current?.(data);
-    } catch (err) {
-      setAutosaveStatus({
-        state: "error",
-        message: err instanceof Error ? err.message : "Autosave failed"
-      });
-    } finally {
-      isSavingRef.current = false;
-    }
-  }, []);
+    controller.refresh();
+  }, [controller, enabled, filePath, intervalMs]);
   React17.useEffect(() => {
-    if (!enabled) {
-      setAutosaveStatus({ state: "disabled", reason: "autosave_toggle_off" });
-      return;
-    }
-    if (!filePath) {
-      setAutosaveStatus({
-        state: "disabled",
-        reason: "no_file_path"
-      });
-      return;
-    }
-    setAutosaveStatus((prev) => prev.state === "disabled" ? { state: "idle" } : prev);
-    const id = setInterval(() => {
-      void doAutosave({ polled: true });
-    }, intervalMs);
-    return () => clearInterval(id);
-  }, [enabled, filePath, intervalMs, doAutosave]);
+    controller.observe(isDirty, live.current.getChangeSources?.() ?? []);
+  });
+  React17.useEffect(() => () => controller.markClean(), [controller]);
   return {
-    autosaveStatus,
-    triggerAutosave: () => doAutosave()
+    autosaveStatus: status,
+    triggerAutosave: () => controller.saveNow()
   };
 }
 
@@ -5150,7 +4863,7 @@ function useElementOperations(input) {
         );
         return;
       }
-      if (chunkJAI42EXQ_js.isTemplateElementId(elementId)) {
+      if (chunkJWNBTFZZ_js.isTemplateElementId(elementId)) {
         const slideId = activeSlide?.id;
         if (slideId) {
           setTemplateElementsBySlideId((prev) => ({
@@ -5387,45 +5100,238 @@ function syncSelectionHandleOverlay(elementNode, elementId, geometry) {
   }
 }
 
-// src/viewer/hooks/pointer-move-handlers.ts
-function computeResizeGeometry(handle, startX, startY, startWidth, startHeight, dx, dy, snapToGrid, gridSpacingPx, lockAspect = false) {
-  const startBox = { x: startX, y: startY, width: startWidth, height: startHeight };
-  let resized = pptx.applyResize(startBox, handle, dx, dy, 1, { minSize: chunkJAI42EXQ_js.MIN_ELEMENT_SIZE });
-  if (lockAspect) {
-    resized = pptx.lockResizeAspect(resized, startBox, handle, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE);
+// src/viewer/hooks/canvas-gestures.ts
+var animationFrames = {
+  request: (callback) => requestAnimationFrame(callback),
+  cancel: (handle) => cancelAnimationFrame(handle)
+};
+function createCanvasGestures(getInput, frames = animationFrames) {
+  let armed = null;
+  let pending = null;
+  let frameHandle = 0;
+  let lastSnapLinesKey = "";
+  const liveTarget = () => {
+    const { livePatcher, editTemplateMode, activeSlide } = getInput();
+    return livePatcher && !editTemplateMode && livePatcher.isActive() ? { patcher: livePatcher, slideId: activeSlide?.id } : void 0;
+  };
+  function showSnapLines(lines) {
+    const next = lines.map((line) => ({
+      axis: line.axis === "v" ? "x" : "y",
+      position: line.position
+    }));
+    const key = JSON.stringify(next);
+    if (key !== lastSnapLinesKey) {
+      lastSnapLinesKey = key;
+      getInput().setSnapLines(next);
+    }
   }
-  const box = { x: resized.x, y: resized.y, width: resized.width, height: resized.height };
-  if (!snapToGrid) {
-    return box;
+  function paintMove(drag, transform) {
+    const start = drag.startPositionsById[transform.id];
+    if (!start) {
+      return;
+    }
+    drag.lastDx = transform.x - start.x;
+    drag.lastDy = transform.y - start.y;
+    const live = liveTarget();
+    for (const [id, from] of Object.entries(drag.startPositionsById)) {
+      const x = from.x + drag.lastDx;
+      const y = from.y + drag.lastDy;
+      const domEl = drag.domEls.get(id);
+      if (domEl) {
+        domEl.style.left = `${x}px`;
+        domEl.style.top = `${y}px`;
+        syncSelectionHandleOverlay(domEl, id, { x, y });
+      }
+      if (live) {
+        pptx.publishLiveGeometry(live.patcher, live.slideId, id, { x, y });
+      }
+    }
+  }
+  function paintResize(resize, transform) {
+    const { x, y } = transform;
+    const width = Math.max(transform.width, chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE);
+    const height = Math.max(transform.height, chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE);
+    resize.lastX = x;
+    resize.lastY = y;
+    resize.lastWidth = transform.width;
+    resize.lastHeight = transform.height;
+    if (resize.domEl) {
+      Object.assign(resize.domEl.style, {
+        left: `${x}px`,
+        top: `${y}px`,
+        width: `${width}px`,
+        height: `${height}px`
+      });
+      syncSelectionHandleOverlay(resize.domEl, resize.elementId, { x, y, width, height });
+    }
+    const live = liveTarget();
+    if (live) {
+      pptx.publishLiveGeometry(live.patcher, live.slideId, resize.elementId, { x, y, width, height });
+    }
   }
-  return pptx.snapBoxToGrid(box, handle, gridSpacingPx, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE);
+  function paintPending() {
+    const frame = pending;
+    pending = null;
+    frameHandle = 0;
+    if (!frame || !armed) {
+      return;
+    }
+    if (armed.kind === "move") {
+      armed.drag.moved = true;
+      showSnapLines(frame.lines);
+      paintMove(armed.drag, frame.transform);
+    } else {
+      armed.resize.moved = true;
+      paintResize(armed.resize, frame.transform);
+    }
+  }
+  function flushFrame() {
+    if (frameHandle !== 0) {
+      frames.cancel(frameHandle);
+    }
+    paintPending();
+  }
+  const controller = pptx.createGestureController({
+    getScale: () => getInput().editorScale,
+    // Axis-aligned, as the canvas has always moved and resized (no rotation).
+    getElementBox: (id) => {
+      const el = getInput().elementLookup.get(id);
+      return el ? { x: el.x, y: el.y, width: el.width, height: el.height } : void 0;
+    },
+    getSiblings: () => {
+      const { editTemplateMode, templateElements, activeSlide } = getInput();
+      const source = editTemplateMode ? templateElements : activeSlide?.elements ?? [];
+      return source.map(({ id, x, y, width, height }) => ({ id, x, y, width, height }));
+    },
+    getSnapToGrid: () => getInput().snapToGrid,
+    getGridSize: () => getInput().gridSpacingPx,
+    getSnapToShape: () => getInput().snapToShape,
+    getGuides: () => getInput().guides.map(({ axis, position }) => ({ axis, position })),
+    getMinSize: () => chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE,
+    getSnapExcludeIds: () => armed?.kind === "move" ? Object.keys(armed.drag.startPositionsById) : [],
+    getStageOrigin: () => {
+      const rect = getInput().canvasStageRef.current?.getBoundingClientRect();
+      return { left: rect?.left ?? 0, top: rect?.top ?? 0 };
+    },
+    onStart: () => void 0,
+    onPreview: (transform, lines) => {
+      pending = { transform, lines };
+      if (frameHandle === 0) {
+        frameHandle = frames.request(paintPending);
+      }
+    },
+    onEnd: (transform, moved) => {
+      flushFrame();
+      const ended = armed;
+      armed = null;
+      if (ended) {
+        finishGesture(ended, moved ? transform : null);
+      }
+    }
+  });
+  function finishGesture(ended, transform) {
+    const input = getInput();
+    if (transform) {
+      if (ended.kind === "move") {
+        commitMove(input, ended.drag);
+      } else {
+        commitResize(input, ended.resize);
+      }
+      input.justInteractedRef.current = true;
+      input.livePatcher?.flush();
+    }
+    input.dragStateRef.current = null;
+    input.resizeStateRef.current = null;
+    lastSnapLinesKey = "";
+    input.setSnapLines([]);
+    if (transform) {
+      input.markDirty();
+    }
+    input.setPointerCommitNonce((n) => n + 1);
+  }
+  return {
+    begin(kind, id, pointer) {
+      if (controller.isActive()) {
+        return;
+      }
+      const input = getInput();
+      const drag = input.dragStateRef.current;
+      const resize = input.resizeStateRef.current;
+      armed = kind === "move" && drag ? { kind, drag } : kind === "resize" && resize ? { kind, resize } : null;
+      if (!armed) {
+        return;
+      }
+      lastSnapLinesKey = "";
+      const handle = armed.kind === "resize" ? armed.resize.handle : void 0;
+      controller.begin(kind, id, pointer, handle);
+      if (!controller.isActive()) {
+        armed = null;
+      }
+    },
+    isActive: () => controller.isActive(),
+    dispose: () => {
+      if (frameHandle !== 0) {
+        frames.cancel(frameHandle);
+        frameHandle = 0;
+      }
+      pending = null;
+      armed = null;
+      controller.dispose();
+    }
+  };
 }
-function resolveLiveTarget(input) {
-  const { livePatcher, editTemplateMode, activeSlide } = input;
-  if (!livePatcher || editTemplateMode || !livePatcher.isActive()) {
-    return void 0;
+function commitMove(input, drag) {
+  const { lastDx: dx, lastDy: dy } = drag;
+  const movedIds = new Set(Object.keys(drag.startPositionsById));
+  const moveElements = (elements) => {
+    const moved = elements.map((el) => {
+      const start = drag.startPositionsById[el.id];
+      return start ? { ...el, x: start.x + dx, y: start.y + dy } : el;
+    });
+    return chunkJWNBTFZZ_js.applyReroutedConnectors(moved, chunkJWNBTFZZ_js.rerouteConnectorsForMovedElements(moved, movedIds));
+  };
+  if (input.editTemplateMode) {
+    const slideId = input.activeSlide?.id;
+    if (slideId) {
+      input.setTemplateElementsBySlideId((prev) => ({
+        ...prev,
+        [slideId]: moveElements(prev[slideId] ?? [])
+      }));
+    }
+    return;
   }
-  return { patcher: livePatcher, slideId: activeSlide?.id };
+  input.updateSlides(
+    (prev) => prev.map(
+      (s, i) => i !== input.activeSlideIndex ? s : { ...s, elements: moveElements(s.elements) }
+    )
+  );
 }
-function processPointerMove(e, input, tracker) {
+function commitResize(input, resize) {
+  input.updateElementById(resize.elementId, {
+    x: resize.lastX,
+    y: resize.lastY,
+    width: resize.lastWidth,
+    height: resize.lastHeight
+  });
+  const movedIds = /* @__PURE__ */ new Set([resize.elementId]);
+  input.updateSlides(
+    (prev) => prev.map((s, i) => {
+      if (i !== input.activeSlideIndex) {
+        return s;
+      }
+      const rerouted = chunkJWNBTFZZ_js.rerouteConnectorsForMovedElements(s.elements, movedIds);
+      return rerouted.length === 0 ? s : { ...s, elements: chunkJWNBTFZZ_js.applyReroutedConnectors(s.elements, rerouted) };
+    })
+  );
+}
+function processPointerMove(e, input) {
   const {
     editorScale,
     canvasStageRef,
     canvasSize,
-    snapToGrid,
-    snapToShape,
-    gridSpacingPx,
-    editTemplateMode,
-    templateElements,
-    activeSlide,
-    guides,
-    elementLookup,
     marqueeStateRef,
-    dragStateRef,
-    resizeStateRef,
     shapeAdjustmentDragStateRef,
     setMarqueeSelectionState,
-    setSnapLines,
     updateElementById
   } = input;
   const marquee = marqueeStateRef.current;
@@ -5440,31 +5346,6 @@ function processPointerMove(e, input, tracker) {
     );
     return;
   }
-  const drag = dragStateRef.current;
-  if (drag) {
-    processDragMove(
-      e,
-      drag,
-      editorScale,
-      snapToGrid,
-      snapToShape,
-      gridSpacingPx,
-      editTemplateMode,
-      templateElements,
-      activeSlide,
-      guides,
-      elementLookup,
-      tracker,
-      setSnapLines,
-      resolveLiveTarget(input)
-    );
-    return;
-  }
-  const rs = resizeStateRef.current;
-  if (rs) {
-    processResizeMove(e, rs, editorScale, snapToGrid, gridSpacingPx, resolveLiveTarget(input));
-    return;
-  }
   const adj = shapeAdjustmentDragStateRef.current;
   if (adj) {
     processAdjustmentMove(e, adj, editorScale, updateElementById);
@@ -5480,129 +5361,6 @@ function processMarqueeMove(e, marquee, canvasStageRef, canvasSize, editorScale,
   marquee.currentY = Math.max(0, Math.min(canvasSize.height, (e.clientY - rect.top) / editorScale));
   setMarqueeSelectionState({ ...marquee });
 }
-function processDragMove(e, drag, editorScale, snapToGrid, snapToShape, gridSpacingPx, editTemplateMode, templateElements, activeSlide, guides, elementLookup, tracker, setSnapLines, live) {
-  const dx = (e.clientX - drag.startClientX) / editorScale;
-  const dy = (e.clientY - drag.startClientY) / editorScale;
-  if (!drag.moved && (Math.abs(dx) > 2 || Math.abs(dy) > 2)) {
-    drag.moved = true;
-  }
-  if (!drag.moved) {
-    return;
-  }
-  let appliedDx = dx;
-  let appliedDy = dy;
-  const draggedIds = Object.keys(drag.startPositionsById);
-  const primaryId = draggedIds[0];
-  const primaryStart = primaryId ? drag.startPositionsById[primaryId] : void 0;
-  const primaryEl = primaryId ? elementLookup.get(primaryId) : void 0;
-  if (primaryStart && primaryEl) {
-    let targetX = primaryStart.x + appliedDx;
-    let targetY = primaryStart.y + appliedDy;
-    if (snapToGrid) {
-      targetX = Math.round(targetX / gridSpacingPx) * gridSpacingPx;
-      targetY = Math.round(targetY / gridSpacingPx) * gridSpacingPx;
-    }
-    if (snapToShape) {
-      const siblingSource = editTemplateMode ? templateElements : activeSlide?.elements ?? [];
-      const siblings = siblingSource.map((el) => ({
-        id: el.id,
-        x: el.x,
-        y: el.y,
-        width: el.width,
-        height: el.height
-      }));
-      const snapResult = chunkJAI42EXQ_js.computeSnapToShape(
-        targetX,
-        targetY,
-        primaryEl.width,
-        primaryEl.height,
-        siblings,
-        new Set(draggedIds),
-        guides.map((g) => ({ axis: g.axis, position: g.position }))
-      );
-      targetX = snapResult.x;
-      targetY = snapResult.y;
-      const newSnapLines = snapResult.lines.map((line) => ({
-        axis: line.axis === "v" ? "x" : "y",
-        position: line.position
-      }));
-      const newKey = JSON.stringify(newSnapLines);
-      if (newKey !== tracker.lastSnapLinesKey) {
-        tracker.lastSnapLinesKey = newKey;
-        setSnapLines(newSnapLines);
-      }
-    } else if (tracker.lastSnapLinesKey !== "[]") {
-      tracker.lastSnapLinesKey = "[]";
-      setSnapLines([]);
-    }
-    appliedDx = targetX - primaryStart.x;
-    appliedDy = targetY - primaryStart.y;
-  }
-  drag.lastDx = appliedDx;
-  drag.lastDy = appliedDy;
-  for (const [id, domEl] of drag.domEls) {
-    const start = drag.startPositionsById[id];
-    if (start) {
-      const x = start.x + appliedDx;
-      const y = start.y + appliedDy;
-      domEl.style.left = `${x}px`;
-      domEl.style.top = `${y}px`;
-      syncSelectionHandleOverlay(domEl, id, { x, y });
-    }
-  }
-  if (live) {
-    for (const id of Object.keys(drag.startPositionsById)) {
-      const start = drag.startPositionsById[id];
-      pptx.publishLiveGeometry(live.patcher, live.slideId, id, {
-        x: start.x + appliedDx,
-        y: start.y + appliedDy
-      });
-    }
-  }
-}
-function processResizeMove(e, rs, editorScale, snapToGrid, gridSpacingPx, live) {
-  const dx = (e.clientX - rs.startClientX) / editorScale;
-  const dy = (e.clientY - rs.startClientY) / editorScale;
-  if (!rs.moved && (Math.abs(dx) > 2 || Math.abs(dy) > 2)) {
-    rs.moved = true;
-  }
-  if (!rs.moved) {
-    return;
-  }
-  const geo = computeResizeGeometry(
-    rs.handle,
-    rs.startX,
-    rs.startY,
-    rs.startWidth,
-    rs.startHeight,
-    dx,
-    dy,
-    snapToGrid,
-    gridSpacingPx,
-    e.shiftKey
-  );
-  rs.lastX = geo.x;
-  rs.lastY = geo.y;
-  rs.lastWidth = geo.width;
-  rs.lastHeight = geo.height;
-  const width = Math.max(geo.width, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE);
-  const height = Math.max(geo.height, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE);
-  if (rs.domEl) {
-    rs.domEl.style.left = `${geo.x}px`;
-    rs.domEl.style.top = `${geo.y}px`;
-    rs.domEl.style.width = `${width}px`;
-    rs.domEl.style.height = `${height}px`;
-    syncSelectionHandleOverlay(rs.domEl, rs.elementId, { x: geo.x, y: geo.y, width, height });
-  }
-  if (live) {
-    pptx.publishLiveGeometry(live.patcher, live.slideId, rs.elementId, {
-      x: geo.x,
-      y: geo.y,
-      width,
-      height
-    });
-  }
-}
 function processAdjustmentMove(e, adj, editorScale, updateElementById) {
   const dx = (e.clientX - adj.startClientX) / editorScale;
   const dy = (e.clientY - adj.startClientY) / editorScale;
@@ -5621,26 +5379,20 @@ function processPointerUp(input) {
     editTemplateMode,
     templateElements,
     activeSlide,
-    activeSlideIndex,
     marqueeStateRef,
     dragStateRef,
     resizeStateRef,
     shapeAdjustmentDragStateRef,
     justInteractedRef,
+    gestureRef,
     setMarqueeSelectionState,
-    setSnapLines,
-    setTemplateElementsBySlideId,
     setPointerCommitNonce,
     applySelection,
     clearSelection,
-    updateSlides,
-    updateElementById,
     markDirty,
     livePatcher
   } = input;
   const marquee = marqueeStateRef.current;
-  const drag = dragStateRef.current;
-  const rs = resizeStateRef.current;
   const adj = shapeAdjustmentDragStateRef.current;
   if (marquee) {
     commitMarquee(
@@ -5651,62 +5403,22 @@ function processPointerUp(input) {
       applySelection,
       clearSelection
     );
-    marqueeStateRef.current = null;
-    setMarqueeSelectionState(null);
   }
-  if (drag?.moved) {
-    commitDrag(
-      drag,
-      editTemplateMode,
-      activeSlide,
-      activeSlideIndex,
-      setTemplateElementsBySlideId,
-      updateSlides
-    );
+  if (!gestureRef?.current?.isActive()) {
+    dragStateRef.current = null;
+    resizeStateRef.current = null;
   }
-  if (rs?.moved) {
-    const resizedId = rs.elementId;
-    const resizeUpdates = {
-      x: rs.lastX,
-      y: rs.lastY,
-      width: rs.lastWidth,
-      height: rs.lastHeight
-    };
-    updateElementById(resizedId, resizeUpdates);
-    const movedIds = /* @__PURE__ */ new Set([resizedId]);
-    updateSlides(
-      (prev) => prev.map((s, i) => {
-        if (i !== activeSlideIndex) {
-          return s;
-        }
-        const rerouted = chunkJAI42EXQ_js.rerouteConnectorsForMovedElements(s.elements, movedIds);
-        if (rerouted.length === 0) {
-          return s;
-        }
-        return {
-          ...s,
-          elements: chunkJAI42EXQ_js.applyReroutedConnectors(s.elements, rerouted)
-        };
-      })
-    );
-  }
-  const wasMoved = drag?.moved || rs?.moved || adj?.moved;
-  if (wasMoved) {
+  if (adj?.moved) {
     justInteractedRef.current = true;
-  }
-  if (wasMoved) {
     livePatcher?.flush();
   }
   marqueeStateRef.current = null;
-  dragStateRef.current = null;
-  resizeStateRef.current = null;
   shapeAdjustmentDragStateRef.current = null;
   setMarqueeSelectionState(null);
-  setSnapLines([]);
-  if (wasMoved) {
+  if (adj?.moved) {
     markDirty();
   }
-  if (drag || rs || adj || marquee) {
+  if (adj || marquee) {
     setPointerCommitNonce((n) => n + 1);
   }
 }
@@ -5726,35 +5438,6 @@ function commitMarquee(marquee, editTemplateMode, templateElements, activeSlide,
     clearSelection();
   }
 }
-function commitDrag(drag, editTemplateMode, activeSlide, activeSlideIndex, setTemplateElementsBySlideId, updateSlides) {
-  const dx = drag.lastDx, dy = drag.lastDy;
-  const movedIds = new Set(Object.keys(drag.startPositionsById));
-  const moveElements = (elements) => {
-    const movedElements = elements.map((el) => {
-      const start = drag.startPositionsById[el.id];
-      if (!start) {
-        return el;
-      }
-      return { ...el, x: start.x + dx, y: start.y + dy };
-    });
-    const rerouted = chunkJAI42EXQ_js.rerouteConnectorsForMovedElements(movedElements, movedIds);
-    return chunkJAI42EXQ_js.applyReroutedConnectors(movedElements, rerouted);
-  };
-  if (editTemplateMode) {
-    const slideId = activeSlide?.id;
-    if (!slideId) {
-      return;
-    }
-    setTemplateElementsBySlideId((prev) => ({
-      ...prev,
-      [slideId]: moveElements(prev[slideId] ?? [])
-    }));
-    return;
-  }
-  updateSlides(
-    (prev) => prev.map((s, i) => i !== activeSlideIndex ? s : { ...s, elements: moveElements(s.elements) })
-  );
-}
 
 // src/viewer/hooks/usePointerHandlers.ts
 function usePointerHandlers(input) {
@@ -5764,41 +5447,42 @@ function usePointerHandlers(input) {
     canvasSize,
     activeSlide,
     activeSlideIndex,
-    gridSpacingPx,
-    dragStateRef,
-    resizeStateRef,
     shapeAdjustmentDragStateRef,
     marqueeStateRef,
     editTemplateMode,
-    snapToGrid,
-    snapToShape,
-    guides,
     templateElements,
-    elementLookup,
     setMarqueeSelectionState,
-    setSnapLines,
-    setTemplateElementsBySlideId,
     setPointerCommitNonce,
     applySelection,
     clearSelection,
-    updateSlides,
     updateElementById,
     markDirty,
-    livePatcher
+    livePatcher,
+    gestureRef
   } = input;
+  const inputRef = React17.useRef(input);
+  inputRef.current = input;
+  const gestures = React17.useMemo(() => createCanvasGestures(() => inputRef.current), []);
   React17.useEffect(() => {
-    const tracker = {
-      rafId: 0,
-      pendingMoveEvent: null,
-      lastSnapLinesKey: ""
+    if (gestureRef) {
+      gestureRef.current = gestures;
+    }
+    return () => {
+      gestures.dispose();
+      if (gestureRef?.current === gestures) {
+        gestureRef.current = null;
+      }
     };
+  }, [gestures, gestureRef]);
+  React17.useEffect(() => {
+    const tracker = { rafId: 0, pendingMoveEvent: null };
     const handlePointerMove = (e) => {
       tracker.pendingMoveEvent = e;
       if (tracker.rafId === 0) {
         tracker.rafId = requestAnimationFrame(() => {
           tracker.rafId = 0;
           if (tracker.pendingMoveEvent) {
-            processPointerMove(tracker.pendingMoveEvent, input, tracker);
+            processPointerMove(tracker.pendingMoveEvent, input);
             tracker.pendingMoveEvent = null;
           }
         });
@@ -5826,31 +5510,22 @@ function usePointerHandlers(input) {
   }, [
     editorScale,
     canvasStageRef,
-    dragStateRef,
-    resizeStateRef,
     shapeAdjustmentDragStateRef,
     marqueeStateRef,
     editTemplateMode,
-    snapToGrid,
-    snapToShape,
-    guides,
     templateElements,
     setMarqueeSelectionState,
-    setSnapLines,
-    elementLookup,
-    setTemplateElementsBySlideId,
     setPointerCommitNonce,
     activeSlide,
     activeSlideIndex,
     canvasSize.width,
     canvasSize.height,
-    gridSpacingPx,
     applySelection,
     clearSelection,
-    updateSlides,
     updateElementById,
     markDirty,
-    livePatcher
+    livePatcher,
+    gestureRef
   ]);
 }
 function mouseDownStartsSelectionDrag(event) {
@@ -5876,6 +5551,7 @@ function useCanvasInteractions(input) {
     shapeAdjustmentDragStateRef,
     marqueeStateRef,
     justInteractedRef,
+    gestureRef,
     setInlineEditingElementId,
     setInlineEditingText,
     setContextMenuState,
@@ -5901,25 +5577,7 @@ function useCanvasInteractions(input) {
     const scale = editorScale || 1;
     return rect ? { x: (e.clientX - rect.left) / scale, y: (e.clientY - rect.top) / scale } : null;
   };
-  const drillChain = (elementId, e) => {
-    if (!slideElements) {
-      return null;
-    }
-    const top = slideElements.find((el) => el.id === elementId);
-    const point = slidePoint(e);
-    if (!top || !point || !pptx.isEnterableGroup(top)) {
-      return null;
-    }
-    return pptx.memberChainAtPoint(slideElements, elementId, point);
-  };
-  const resolvePressTarget = (elementId, e) => {
-    const chain = drillChain(elementId, e);
-    if (!chain || !slideElements) {
-      return elementId;
-    }
-    const selectedPath = selectedElementId ? pptx.findElementPath(slideElements, selectedElementId) : null;
-    return pptx.drillSelectionForClick(chain, selectedPath) ?? elementId;
-  };
+  const resolvePressTarget = (elementId, e) => slideElements ? pptx.resolveGroupPressTarget(slideElements, elementId, slidePoint(e), effectiveSelectedIds) : elementId;
   const handleInlineEditCommit = () => {
     const editId = inlineEditingElementId;
     if (!editId) {
@@ -6019,9 +5677,7 @@ function useCanvasInteractions(input) {
     }
   };
   const handleElementDoubleClick = (pressedId, e) => {
-    const chain = mode === "present" ? null : drillChain(pressedId, e);
-    const innermost = chain ? pptx.drillSelectionForDoubleClick(chain) : null;
-    const elementId = innermost && pptx.canInteractWithElement(elementLookup.get(innermost), "select") ? innermost : pressedId;
+    const elementId = mode === "present" || !slideElements ? pressedId : pptx.resolveGroupDoubleClickTarget(slideElements, pressedId, slidePoint(e));
     if (elementId !== pressedId) {
       ops.applySelection(elementId);
     }
@@ -6084,6 +5740,7 @@ function useCanvasInteractions(input) {
       lastDy: 0
     };
     setSnapLines([]);
+    gestureRef?.current?.begin("move", movableIds[0], e);
   };
   const handleElementContextMenu = (elementId, e) => {
     if (mode === "present") {
@@ -6156,6 +5813,7 @@ function useCanvasInteractions(input) {
       lastWidth: el.width,
       lastHeight: el.height
     };
+    gestureRef?.current?.begin("resize", elementId, e);
   };
   const handleRotate = (elementId, rotationDeg) => {
     const el = elementLookup.get(elementId);
@@ -6497,7 +6155,7 @@ function createStructuredElementHandlers(deps) {
       return;
     }
     const resolved = resolveHyperlinkEditResult(data);
-    if (resolved.url && !chunkJAI42EXQ_js.isUrlSafe(resolved.url)) {
+    if (resolved.url && !chunkJWNBTFZZ_js.isUrlSafe(resolved.url)) {
       return;
     }
     const actionClick = {
@@ -6543,7 +6201,7 @@ function createStructuredElementHandlers(deps) {
     if (!activeSlide) {
       return;
     }
-    const preset = chunkJAI42EXQ_js.ACTION_BUTTON_PRESETS.find((p) => p.shapeType === shapeType);
+    const preset = chunkJWNBTFZZ_js.ACTION_BUTTON_PRESETS.find((p) => p.shapeType === shapeType);
     if (!preset) {
       return;
     }
@@ -6630,7 +6288,7 @@ function useInsertElements(input) {
       width: 300,
       height: 60,
       text: "",
-      textStyle: { fontSize: chunkJAI42EXQ_js.DEFAULT_TEXT_FONT_SIZE }
+      textStyle: { fontSize: chunkJWNBTFZZ_js.DEFAULT_TEXT_FONT_SIZE }
     });
   };
   const handleAddShape = () => {
@@ -6652,7 +6310,7 @@ function useInsertElements(input) {
       }
     });
   };
-  const handleAddTable = (rows = chunkJAI42EXQ_js.DEFAULT_TABLE_ROWS, columns = chunkJAI42EXQ_js.DEFAULT_TABLE_COLUMNS) => {
+  const handleAddTable = (rows = chunkJWNBTFZZ_js.DEFAULT_TABLE_ROWS, columns = chunkJWNBTFZZ_js.DEFAULT_TABLE_COLUMNS) => {
     if (!activeSlide) {
       return;
     }
@@ -6661,11 +6319,11 @@ function useInsertElements(input) {
       id: pptx.generateElementId()
     });
   };
-  const handleAddChart = (chartKind) => {
+  const handleAddChart = (chartKind, options) => {
     if (!activeSlide) {
       return;
     }
-    addElement(pptx.createDefaultChartElement(chartKind));
+    addElement(pptx.createDefaultChartElement(chartKind, void 0, options));
   };
   const structured = createStructuredElementHandlers({
     activeSlide,
@@ -6826,7 +6484,7 @@ function useGroupAlignLayerHandlers(input) {
     history
   } = input;
   const updateElementsOwning = (elementId, updater) => {
-    if (editTemplateMode && !chunkJAI42EXQ_js.isTemplateElementId(elementId)) {
+    if (editTemplateMode && !chunkJWNBTFZZ_js.isTemplateElementId(elementId)) {
       ops.updateSlides(
         (prev) => prev.map(
           (slide, index) => index === activeSlideIndex ? { ...slide, elements: updater(slide.elements) } : slide
@@ -6860,9 +6518,9 @@ function useGroupAlignLayerHandlers(input) {
       return;
     }
     const group = selectedElement;
-    const intoTemplate = chunkJAI42EXQ_js.isTemplateElementId(group.id);
+    const intoTemplate = chunkJWNBTFZZ_js.isTemplateElementId(group.id);
     const childIds = group.children.map(
-      (child) => intoTemplate ? chunkJAI42EXQ_js.makeCloneId(true, child.id || group.id) : child.id || pptx.generateElementId()
+      (child) => intoTemplate ? chunkJWNBTFZZ_js.makeCloneId(true, child.id || group.id) : child.id || pptx.generateElementId()
     );
     const { elements, childIds: usedIds } = pptx.ungroupElements(
       ops.activeElements,
@@ -7298,7 +6956,7 @@ function createTableMergeHandlers(input) {
     if (!nextCell || nextCell.hMerge || nextCell.vMerge) {
       return;
     }
-    const newTableData = chunkJAI42EXQ_js.mergeCells(
+    const newTableData = chunkJWNBTFZZ_js.mergeCells(
       [
         { row: rowIndex, col: columnIndex },
         { row: rowIndex, col: nextColIdx }
@@ -7306,7 +6964,7 @@ function createTableMergeHandlers(input) {
       td
     );
     const updates = { tableData: newTableData };
-    const newRawXml = chunkJAI42EXQ_js.updateMergeAttrsInRawXml(selectedElement, newTableData);
+    const newRawXml = chunkJWNBTFZZ_js.updateMergeAttrsInRawXml(selectedElement, newTableData);
     if (newRawXml) {
       updates.rawXml = newRawXml;
     }
@@ -7332,7 +6990,7 @@ function createTableMergeHandlers(input) {
     if (!targetNextCell || targetNextCell.hMerge || targetNextCell.vMerge) {
       return;
     }
-    const newTableData = chunkJAI42EXQ_js.mergeCells(
+    const newTableData = chunkJWNBTFZZ_js.mergeCells(
       [
         { row: rowIndex, col: columnIndex },
         { row: targetNextRowIdx, col: columnIndex }
@@ -7340,7 +6998,7 @@ function createTableMergeHandlers(input) {
       td
     );
     const updates = { tableData: newTableData };
-    const newRawXml = chunkJAI42EXQ_js.updateMergeAttrsInRawXml(selectedElement, newTableData);
+    const newRawXml = chunkJWNBTFZZ_js.updateMergeAttrsInRawXml(selectedElement, newTableData);
     if (newRawXml) {
       updates.rawXml = newRawXml;
     }
@@ -7355,9 +7013,9 @@ function createTableMergeHandlers(input) {
       return;
     }
     const td = selectedElement.tableData;
-    const newTableData = chunkJAI42EXQ_js.mergeCells(ts.selectedCells, td);
+    const newTableData = chunkJWNBTFZZ_js.mergeCells(ts.selectedCells, td);
     const updates = { tableData: newTableData };
-    const newRawXml = chunkJAI42EXQ_js.updateMergeAttrsInRawXml(selectedElement, newTableData);
+    const newRawXml = chunkJWNBTFZZ_js.updateMergeAttrsInRawXml(selectedElement, newTableData);
     if (newRawXml) {
       updates.rawXml = newRawXml;
     }
@@ -7374,9 +7032,9 @@ function createTableMergeHandlers(input) {
     }
     const { rowIndex, columnIndex } = ts;
     const td = selectedElement.tableData;
-    const newTableData = chunkJAI42EXQ_js.splitCell(rowIndex, columnIndex, td);
+    const newTableData = chunkJWNBTFZZ_js.splitCell(rowIndex, columnIndex, td);
     const updates = { tableData: newTableData };
-    const newRawXml = chunkJAI42EXQ_js.updateMergeAttrsInRawXml(selectedElement, newTableData);
+    const newRawXml = chunkJWNBTFZZ_js.updateMergeAttrsInRawXml(selectedElement, newTableData);
     if (newRawXml) {
       updates.rawXml = newRawXml;
     }
@@ -7411,7 +7069,7 @@ function createTableStructHandlers(input) {
       updates.tableData = pptx.setCellText(el, rowIndex, colIndex, text).tableData;
     }
     if (el.rawXml) {
-      const newRawXml = chunkJAI42EXQ_js.updateCellTextInRawXml(el, rowIndex, colIndex, text);
+      const newRawXml = chunkJWNBTFZZ_js.updateCellTextInRawXml(el, rowIndex, colIndex, text);
       if (newRawXml) {
         updates.rawXml = newRawXml;
       }
@@ -7435,7 +7093,7 @@ function createTableStructHandlers(input) {
     const { rowIndex, columnIndex: colIndex } = ts;
     const updates = {};
     if (selectedElement.rawXml) {
-      const newRawXml = chunkJAI42EXQ_js.updateCellTextStyleInRawXml(
+      const newRawXml = chunkJWNBTFZZ_js.updateCellTextStyleInRawXml(
         selectedElement,
         rowIndex,
         colIndex,
@@ -7613,7 +7271,7 @@ function useExportSaveAs(input) {
     const sourceName = filePath ? filePath.replace(/\\/gu, "/").split("/").pop() : void 0;
     const slideSize = pptx.resolveSlideSizeSelection({ current: slideSizeEmu, canvas: canvasSize }).size;
     const data = {
-      slides: chunkJAI42EXQ_js.buildSaveSlides(slides, templateElementsBySlideId),
+      slides: chunkJWNBTFZZ_js.buildSaveSlides(slides, templateElementsBySlideId),
       width: canvasSize.width,
       height: canvasSize.height,
       widthEmu: slideSize.widthEmu,
@@ -7775,7 +7433,7 @@ async function captureAllSlidesAsPngDataUrls(slideStageRef, totalSlides, setActi
 }
 function tilesToPdfPage(tilesResult) {
   return tilesResult.tiles.map((tile) => ({
-    image: chunkJAI42EXQ_js.canvasToJpegData(tile.canvas),
+    image: chunkJWNBTFZZ_js.canvasToJpegData(tile.canvas),
     placement: pptx.placeTileOnPage(
       tile,
       tilesResult.fullWidth,
@@ -7808,7 +7466,7 @@ async function exportAllSlidesAsPdf(slideStageRef, totalSlides, setActiveSlide,
   if (pages.length === 0) {
     throw new Error(i18n.translationsEn["pptx.export.errorNoSlidesPdf"]);
   }
-  const pdfBlobUrl = chunkJAI42EXQ_js.buildPdfFromTiledImageData(pages);
+  const pdfBlobUrl = chunkJWNBTFZZ_js.buildPdfFromTiledImageData(pages);
   pptx.downloadDataUrl(pdfBlobUrl, filename);
 }
 async function exportAllSlidesAsNotesPdf(slideStageRef, totalSlides, setActiveSlide, currentSlideIndex, slideNotes, filename = "presentation-notes.pdf", options = {}) {
@@ -7838,7 +7496,7 @@ async function exportAllSlidesAsNotesPdf(slideStageRef, totalSlides, setActiveSl
   if (pages.length === 0) {
     throw new Error(i18n.translationsEn["pptx.export.errorNoSlidesNotesPdf"]);
   }
-  const pdfDataUrl = chunkJAI42EXQ_js.buildNotesPdf(pages);
+  const pdfDataUrl = chunkJWNBTFZZ_js.buildNotesPdf(pages);
   pptx.downloadDataUrl(pdfDataUrl, filename);
 }
 async function exportAllSlidesAsVideo(slideStageRef, totalSlides, setActiveSlide, currentSlideIndex, options = {}) {
@@ -8941,7 +8599,7 @@ function usePropertyHandlers(input) {
           width: canvasSize.width,
           height: canvasSize.height
         };
-        setCompareResult(chunkJAI42EXQ_js.comparePresentation(cur, other));
+        setCompareResult(chunkJWNBTFZZ_js.comparePresentation(cur, other));
         setIsComparePanelOpen(true);
       } catch (err) {
         console.warn("Compare failed:", err);
@@ -9110,6 +8768,7 @@ function useViewerDialogs(input) {
     embeddedFontFamilies
   } = input;
   const [isSmartArtDialogOpen, setIsSmartArtDialogOpen] = React17.useState(false);
+  const [isChartDialogOpen, setIsChartDialogOpen] = React17.useState(false);
   const [isEquationDialogOpen, setIsEquationDialogOpen] = React17.useState(false);
   const [isHyperlinkDialogOpen, setIsHyperlinkDialogOpen] = React17.useState(false);
   const [isPasswordDialogOpen, setIsPasswordDialogOpen] = React17.useState(false);
@@ -9254,6 +8913,8 @@ function useViewerDialogs(input) {
   return {
     isSmartArtDialogOpen,
     setIsSmartArtDialogOpen,
+    isChartDialogOpen,
+    setIsChartDialogOpen,
     isEquationDialogOpen,
     setIsEquationDialogOpen,
     isHyperlinkDialogOpen,
@@ -9294,7 +8955,7 @@ function useViewerDialogs(input) {
   };
 }
 function computeGridSpacingPx(documentGridSpacing) {
-  return pptx.computeGridSpacingPx(documentGridSpacing, chunkJAI42EXQ_js.GRID_SIZE);
+  return pptx.computeGridSpacingPx(documentGridSpacing, chunkJWNBTFZZ_js.GRID_SIZE);
 }
 function computeVisibleSlideIndexes(slides, activeCustomShowId, customShows, presentationProperties) {
   const activeShow = activeCustomShowId ? customShows.find((show) => show.id === activeCustomShowId) : void 0;
@@ -9303,7 +8964,7 @@ function computeVisibleSlideIndexes(slides, activeCustomShowId, customShows, pre
 }
 function computeSlideSectionGroups(slides, sections) {
   return pptx.groupSlidesBySection(sections, slides).map((group) => ({
-    id: group.section?.id ?? (sections.length > 0 ? chunkJAI42EXQ_js.UNGROUPED_SECTION_ID : chunkJAI42EXQ_js.DEFAULT_SECTION_GROUP_ID),
+    id: group.section?.id ?? (sections.length > 0 ? chunkJWNBTFZZ_js.UNGROUPED_SECTION_ID : chunkJWNBTFZZ_js.DEFAULT_SECTION_GROUP_ID),
     label: group.section?.name ?? (sections.length > 0 ? "Ungrouped Slides" : "Slides"),
     slideIndexes: group.slideIndexes,
     ...group.section?.color !== void 0 ? { color: group.section.color } : {},
@@ -9348,10 +9009,10 @@ function useDerivedSlideState(input) {
   );
   const slideSectionGroups = React17.useMemo(
     () => computeSlideSectionGroups(slides, sections).map((group) => {
-      if (group.id === chunkJAI42EXQ_js.UNGROUPED_SECTION_ID && group.label === "Ungrouped Slides") {
+      if (group.id === chunkJWNBTFZZ_js.UNGROUPED_SECTION_ID && group.label === "Ungrouped Slides") {
         return { ...group, label: t("pptx.slides.ungroupedSlides") };
       }
-      if (group.id === chunkJAI42EXQ_js.DEFAULT_SECTION_GROUP_ID && group.label === "Slides") {
+      if (group.id === chunkJWNBTFZZ_js.DEFAULT_SECTION_GROUP_ID && group.label === "Slides") {
         return { ...group, label: t("pptx.sections.slides") };
       }
       return group;
@@ -9458,7 +9119,7 @@ function useAnnotationHandlers(input) {
       if (nextMode === "present") {
         presentation.enterPresentMode();
       } else if (mode === "present" && annotations.hasAnyAnnotations) {
-        chunkJAI42EXQ_js.stopAllPersistentAudio();
+        chunkJWNBTFZZ_js.stopAllPersistentAudio();
         if (promptKeepInkAnnotations) {
           pendingModeAfterAnnotationsRef.current = nextMode;
           setShowKeepAnnotationsDialog(true);
@@ -9468,7 +9129,7 @@ function useAnnotationHandlers(input) {
         }
       } else {
         if (mode === "present") {
-          chunkJAI42EXQ_js.stopAllPersistentAudio();
+          chunkJWNBTFZZ_js.stopAllPersistentAudio();
         }
         setMode(nextMode);
       }
@@ -9635,7 +9296,7 @@ function useSerialize(input) {
           guides: pptxGuides.length > 0 ? pptxGuides : void 0
         };
       });
-      const slidesToSave = chunkJAI42EXQ_js.buildSaveSlides(slidesWithGuides, pending.templateElementsBySlideId);
+      const slidesToSave = chunkJWNBTFZZ_js.buildSaveSlides(slidesWithGuides, pending.templateElementsBySlideId);
       const saveOptions = pptx.buildDeckSaveOptions({
         // Without this the Slide Size card edited a viewer-only pixel value and
         // the saved `p:sldSz` never moved: passing `slideSize` is the only way a
@@ -9699,84 +9360,35 @@ function useSerialize(input) {
 }
 function useRecoveryDetection(input) {
   const { filePath, fileName, loading, error, slideCount, autosaveAllowed = true } = input;
-  const recoveryCheckedRef = React17.useRef(false);
-  const recordRef = React17.useRef(null);
-  const actionPendingRef = React17.useRef(false);
-  const [prompt, setPrompt] = React17.useState(null);
-  const [discarding, setDiscarding] = React17.useState(false);
-  const onRestore = input.onRestore;
-  const storageRef = React17.useRef(input.storage);
-  storageRef.current = input.storage;
-  const onOfferedRef = React17.useRef(input.onOffered);
-  React17.useEffect(() => {
-    onOfferedRef.current = input.onOffered;
-  }, [input.onOffered]);
-  const openVersionHistory = input.openVersionHistory;
+  const live = React17.useRef(input);
+  live.current = input;
+  const [controller] = React17.useState(
+    () => pptx.createAutosaveRecoveryController({
+      getStorage: () => live.current.storage,
+      load: (bytes) => live.current.onRestore?.(bytes),
+      onOffered: (record) => {
+        live.current.onOffered?.(record);
+        live.current.openVersionHistory?.();
+      },
+      probe: pptx.probeAutosaveRecovery,
+      discardRecord: pptx.discardAutosaveRecovery
+    })
+  );
+  const { prompt, discarding } = useController(controller);
   React17.useEffect(() => {
-    if (!pptx.shouldProbeAutosaveRecovery({
-      alreadyChecked: recoveryCheckedRef.current,
-      filePath,
-      loading,
-      error,
-      slideCount,
-      autosaveAllowed
-    })) {
-      return;
-    }
-    recoveryCheckedRef.current = true;
-    void (async () => {
-      const offer = await pptx.probeAutosaveRecovery(
-        filePath,
-        Date.now(),
-        fileName,
-        storageRef.current
-      );
-      if (!offer) {
-        return;
-      }
-      recordRef.current = offer.record;
-      setPrompt(offer.prompt);
-      onOfferedRef.current?.(offer.record);
-      openVersionHistory?.();
-    })();
-  }, [filePath, fileName, loading, error, slideCount, autosaveAllowed, openVersionHistory]);
-  const restore = React17.useCallback(() => {
-    if (actionPendingRef.current) {
-      return;
-    }
-    actionPendingRef.current = true;
-    const record = recordRef.current;
-    setPrompt(null);
-    if (record && onRestore) {
-      onRestore(pptx.acceptAutosaveRecovery(record));
-      pptx.acknowledgeAutosaveRecovery(record);
-    }
-    recordRef.current = null;
-  }, [onRestore]);
-  const discard = React17.useCallback(() => {
-    if (actionPendingRef.current) {
-      return;
-    }
-    const record = recordRef.current;
-    if (!record) {
-      setPrompt(null);
-      return;
+    controller.check({ filePath, fileName, loading, error, slideCount, autosaveAllowed });
+  }, [controller, filePath, fileName, loading, error, slideCount, autosaveAllowed]);
+  return {
+    prompt,
+    discarding,
+    restore: () => {
+      void controller.restore().catch(() => {
+      });
+    },
+    discard: () => {
+      void controller.discard();
     }
-    actionPendingRef.current = true;
-    setDiscarding(true);
-    void (async () => {
-      try {
-        await pptx.discardAutosaveRecovery(record, storageRef.current);
-        recordRef.current = null;
-        setPrompt(null);
-      } catch {
-      } finally {
-        actionPendingRef.current = false;
-        setDiscarding(false);
-      }
-    })();
-  }, []);
-  return { prompt, restore, discard, discarding };
+  };
 }
 function usePresentationSetup(input) {
   const {
@@ -9828,7 +9440,7 @@ function usePresentationSetup(input) {
         return;
       }
       if (mode === "present" && nextMode !== "present") {
-        chunkJAI42EXQ_js.stopAllPersistentAudio();
+        chunkJWNBTFZZ_js.stopAllPersistentAudio();
         stopAnimationSound();
         const exitHandler = exitModeHandlerRef.current;
         if (exitHandler) {
@@ -9949,7 +9561,7 @@ function useCanvasImagePaste(input) {
   );
 }
 function formatPatchFor(element, format) {
-  const updated = chunkJAI42EXQ_js.applyFormatToElement(element, format);
+  const updated = chunkJWNBTFZZ_js.applyFormatToElement(element, format);
   const updates = {};
   if (pptx$1.hasShapeProperties(updated)) {
     updates.shapeStyle = updated.shapeStyle;
@@ -9972,7 +9584,7 @@ function useFormatPainterEditing(input) {
   const prevFormatPainterRef = React17.useRef(false);
   React17.useEffect(() => {
     if (formatPainterActive && !prevFormatPainterRef.current && selectedElement) {
-      copiedFormatRef.current = chunkJAI42EXQ_js.copyFormatFromElement(selectedElement);
+      copiedFormatRef.current = chunkJWNBTFZZ_js.copyFormatFromElement(selectedElement);
     } else if (!formatPainterActive) {
       copiedFormatRef.current = null;
     }
@@ -10250,6 +9862,7 @@ function useEditorOperations(input) {
     shapeAdjustmentDragStateRef: state.shapeAdjustmentDragStateRef,
     marqueeStateRef: state.marqueeStateRef,
     justInteractedRef: state.justInteractedRef,
+    gestureRef: state.gestureControllerRef,
     setInlineEditingElementId: state.setInlineEditingElementId,
     setInlineEditingText: state.setInlineEditingText,
     setContextMenuState: state.setContextMenuState,
@@ -10782,6 +10395,8 @@ function useContentLifecycle(input) {
     // deck it has already snapshotted. The two refs are read by `.current`
     // because an inline edit in progress lives there and nowhere else yet.
     onSaved: input.onAutosave,
+    inlineDraftSinkRef: state.autosaveDraftSinkRef,
+    getInlineEditingId: () => state.inlineEditingElementIdRef.current,
     getChangeSources: () => [
       slides,
       state.templateElementsBySlideId,
@@ -10811,138 +10426,27 @@ function useKeyboardShortcuts(input) {
   inputRef.current = input;
   const handleKeyDown = React17.useCallback((e) => {
     const current = inputRef.current;
-    const startAction = current.customization && !pptx.isFeatureEnabled(current.customization, "presentMode") ? null : pptx.mapSlideShowStartKey(e, { isPresenting: current.mode === "present" });
-    if (startAction !== null) {
-      e.preventDefault();
-      if (startAction === "fromBeginning") {
-        current.onStartShowFromBeginning();
-      } else {
-        current.onStartShowFromCurrent();
-      }
-      return;
-    }
-    const { action, dx, dy } = pptx.mapCustomizedEditorKey(
+    pptx.dispatchEditorKey(
       e,
       {
         canEdit: current.canEdit,
-        canPaste: current.canPaste,
-        // The Slide Master view is an editing surface, not a viewing one.
-        // Gating on `mode !== 'edit'` alone made `mapEditorKey` return
-        // NO_ACTION there, so Delete, the arrow-key nudges and the clipboard
-        // keys were all inert over a master shape even though the write path
-        // behind them routes to the owning part correctly. Svelte and
-        // vanilla, which render the master into their ordinary editable
-        // stage, never had the gap.
+        ...current.canPaste === void 0 ? {} : { canPaste: current.canPaste },
+        // The Slide Master view is an editing surface, not a viewing one, so
+        // only the other modes count as "not editing" for the editor keymap.
         isPresenting: current.mode !== "edit" && current.mode !== "master",
+        // F5 is only inert while the show itself runs: a read-only viewer can
+        // still start a show (it has a "From Beginning" button too).
+        isShowRunning: current.mode === "present",
+        canStartShow: !current.customization || pptx.isFeatureEnabled(current.customization, "presentMode"),
         hasSelection: current.hasSelection,
         isEditingText: Boolean(
           current.inlineEditingElementId || current.tableEditorState?.isEditing
         ),
         isDrawing: current.activeTool !== "select",
-        isTextInputTarget: pptx.isEditorTextInputTarget(e.target),
-        isControlTarget: pptx.isEditorControlTarget(e.target)
+        keyboard: current.customization?.keyboard
       },
-      current.customization?.keyboard
+      toEditorKeyHandlers(current)
     );
-    if (action === null) {
-      return;
-    }
-    e.preventDefault();
-    switch (action) {
-      case "escape":
-        current.onEscape();
-        break;
-      case "delete":
-        current.onDelete();
-        break;
-      case "undo":
-        current.onUndo();
-        break;
-      case "redo":
-        current.onRedo();
-        break;
-      case "copy":
-        current.onCopy();
-        break;
-      case "cut":
-        current.onCut();
-        break;
-      case "paste":
-        current.onPaste();
-        break;
-      case "duplicate":
-        current.onDuplicate();
-        break;
-      case "selectAll":
-        current.onSelectAll();
-        break;
-      case "group":
-        current.onGroup?.();
-        break;
-      case "ungroup":
-        current.onUngroup?.();
-        break;
-      case "toggleShortcuts":
-        current.onToggleShortcuts?.();
-        break;
-      case "find":
-        current.onFind?.();
-        break;
-      case "nudge":
-        current.onNudge(dx ?? 0, dy ?? 0);
-        break;
-      case "prevSlide":
-        current.onPrevSlide?.();
-        break;
-      case "nextSlide":
-        current.onNextSlide?.();
-        break;
-      case "alignLeft":
-        current.onAlignLeft?.();
-        break;
-      case "alignCenter":
-        current.onAlignCenter?.();
-        break;
-      case "alignRight":
-        current.onAlignRight?.();
-        break;
-      case "alignJustify":
-        current.onAlignJustify?.();
-        break;
-      case "increaseFontSize":
-        current.onIncreaseFontSize?.();
-        break;
-      case "decreaseFontSize":
-        current.onDecreaseFontSize?.();
-        break;
-      case "copyFormat":
-        current.onCopyFormat?.();
-        break;
-      case "pasteFormat":
-        current.onPasteFormat?.();
-        break;
-      case "newSlide":
-        current.onNewSlide?.();
-        break;
-      case "hyperlink":
-        current.onHyperlink?.();
-        break;
-      case "findReplace":
-        current.onFindReplace?.();
-        break;
-      case "clearFormatting":
-        current.onClearFormatting?.();
-        break;
-      case "cycleSelectionNext":
-        current.onCycleSelectionNext?.();
-        break;
-      case "cycleSelectionPrev":
-        current.onCycleSelectionPrev?.();
-        break;
-      case "pasteSpecial":
-        current.onPasteSpecial?.();
-        break;
-    }
   }, []);
   React17.useEffect(() => {
     window.addEventListener("keydown", handleKeyDown);
@@ -10951,6 +10455,43 @@ function useKeyboardShortcuts(input) {
     };
   }, [handleKeyDown]);
 }
+function toEditorKeyHandlers(current) {
+  return {
+    startShowFromBeginning: current.onStartShowFromBeginning,
+    startShowFromCurrent: current.onStartShowFromCurrent,
+    escape: current.onEscape,
+    delete: current.onDelete,
+    undo: current.onUndo,
+    redo: current.onRedo,
+    copy: current.onCopy,
+    cut: current.onCut,
+    paste: current.onPaste,
+    duplicate: current.onDuplicate,
+    selectAll: current.onSelectAll,
+    group: current.onGroup,
+    ungroup: current.onUngroup,
+    toggleShortcuts: current.onToggleShortcuts,
+    find: current.onFind,
+    nudge: current.onNudge,
+    prevSlide: current.onPrevSlide,
+    nextSlide: current.onNextSlide,
+    alignLeft: current.onAlignLeft,
+    alignCenter: current.onAlignCenter,
+    alignRight: current.onAlignRight,
+    alignJustify: current.onAlignJustify,
+    increaseFontSize: current.onIncreaseFontSize,
+    decreaseFontSize: current.onDecreaseFontSize,
+    copyFormat: current.onCopyFormat,
+    pasteFormat: current.onPasteFormat,
+    newSlide: current.onNewSlide,
+    hyperlink: current.onHyperlink,
+    findReplace: current.onFindReplace,
+    clearFormatting: current.onClearFormatting,
+    cycleSelectionNext: current.onCycleSelectionNext,
+    cycleSelectionPrev: current.onCycleSelectionPrev,
+    pasteSpecial: current.onPasteSpecial
+  };
+}
 var CLEAR_FORMATTING_PATCH = {
   bold: false,
   italic: false,
@@ -11216,7 +10757,8 @@ function useViewerIntegration(input) {
     updateSlides: editorOps.ops.updateSlides,
     updateElementById: editorOps.ops.updateElementById,
     markDirty: history.markDirty,
-    livePatcher: state.livePatcher
+    livePatcher: state.livePatcher,
+    gestureRef: state.gestureControllerRef
   });
   const [isEncryptedDialogOpen, setIsEncryptedDialogOpen] = React17.useState(false);
   const [loadVersion, setLoadVersion] = React17.useState(0);
@@ -11664,7 +11206,7 @@ function useCollaborationWriteBack(input) {
       getSourceBytes: () => latest.current.getSourceBytes?.() ?? null,
       getSaveOptions: () => latest.current.getSaveOptions?.(),
       getTemplateElements: () => latest.current.templateElementsBySlideId,
-      mergeTemplateElements: chunkJAI42EXQ_js.buildSaveSlides,
+      mergeTemplateElements: chunkJWNBTFZZ_js.buildSaveSlides,
       onWriteBackStatus: () => latest.current.onWriteBackStatus?.(
         pptx.writeBackReport(latest.current.config, created.getState())
       )
@@ -12223,8 +11765,8 @@ function useTouchGestures(input) {
     }
     const recognizer = pptx.createTouchGestureRecognizer({
       getScale: () => scaleRef.current,
-      minScale: chunkJAI42EXQ_js.MIN_ZOOM_SCALE,
-      maxScale: chunkJAI42EXQ_js.MAX_ZOOM_SCALE,
+      minScale: chunkJWNBTFZZ_js.MIN_ZOOM_SCALE,
+      maxScale: chunkJWNBTFZZ_js.MAX_ZOOM_SCALE,
       callbacks: {
         onPinchZoom: (newScale) => callbacksRef.current.onPinchZoom?.(newScale),
         onSwipe: (direction) => callbacksRef.current.onSwipe?.(direction),
@@ -12348,7 +11890,7 @@ function buildCanvasProps(input) {
     if (pptx.shouldConfirmExternalHyperlink(viewerOptions, url) && !window.confirm(buildHyperlinkConfirmMessage(url))) {
       return;
     }
-    chunkJAI42EXQ_js.safeOpenUrl(url, target);
+    chunkJWNBTFZZ_js.safeOpenUrl(url, target);
   };
   const handleActionClick = (elementId, action) => {
     if (mode === "present") {
@@ -12363,9 +11905,9 @@ function buildCanvasProps(input) {
     }
   };
   const handleHyperlinkClick = (url, target) => {
-    if (chunkJAI42EXQ_js.isPpactionUrl(url)) {
+    if (chunkJWNBTFZZ_js.isPpactionUrl(url)) {
       if (mode === "present") {
-        const parsed = chunkJAI42EXQ_js.parsePpactionUrl(url);
+        const parsed = chunkJWNBTFZZ_js.parsePpactionUrl(url);
         if (parsed) {
           presentation.handlePresentationAction({
             action: parsed.action,
@@ -12653,6 +12195,7 @@ function buildToolbarProps(input) {
     onAddShape: insertHandlers.handleAddShape,
     onAddTable: insertHandlers.handleAddTable,
     onAddChart: insertHandlers.handleAddChart,
+    onOpenChartDialog: () => dialogs.setIsChartDialogOpen(true),
     onAddSmartArt: () => dialogs.setIsSmartArtDialogOpen(true),
     onAddEquation: () => {
       dialogs.setEditingEquationOmml(null);
@@ -12792,7 +12335,7 @@ function buildToolbarProps(input) {
       markDirty: history.markDirty
     }),
     formatPainterActive: s.formatPainterActive,
-    canActivateFormatPainter: chunkJAI42EXQ_js.hasCopyableFormat(selectedElement),
+    canActivateFormatPainter: chunkJWNBTFZZ_js.hasCopyableFormat(selectedElement),
     onToggleFormatPainter: () => s.setFormatPainterActive((p) => !p),
     isSelectionPaneOpen: s.isSelectionPaneOpen,
     onToggleSelectionPane: () => s.setIsSelectionPaneOpen((p) => !p),
@@ -13670,23 +13213,23 @@ function ColorChangedImage({
   className,
   alt
 }) {
-  const tolerance = tolerancePct ?? chunkJAI42EXQ_js.DEFAULT_COLOR_CHANGE_TOLERANCE;
-  const cacheKey = chunkJAI42EXQ_js.buildCacheKey(
+  const tolerance = tolerancePct ?? chunkJWNBTFZZ_js.DEFAULT_COLOR_CHANGE_TOLERANCE;
+  const cacheKey = chunkJWNBTFZZ_js.buildCacheKey(
     src,
     clrChange.clrFrom,
     clrChange.clrTo,
     tolerance,
     Boolean(clrChange.clrToTransparent)
   );
-  const cached = chunkJAI42EXQ_js.getCachedResult(cacheKey);
+  const cached = chunkJWNBTFZZ_js.getCachedResult(cacheKey);
   const [processedSrc, setProcessedSrc] = React17.useState(cached ?? null);
   React17.useEffect(() => {
-    if (chunkJAI42EXQ_js.getCachedResult(cacheKey)) {
-      setProcessedSrc(chunkJAI42EXQ_js.getCachedResult(cacheKey) ?? null);
+    if (chunkJWNBTFZZ_js.getCachedResult(cacheKey)) {
+      setProcessedSrc(chunkJWNBTFZZ_js.getCachedResult(cacheKey) ?? null);
       return;
     }
     let cancelled = false;
-    chunkJAI42EXQ_js.applyColorChange(
+    chunkJWNBTFZZ_js.applyColorChange(
       src,
       clrChange.clrFrom,
       clrChange.clrTo,
@@ -13694,7 +13237,7 @@ function ColorChangedImage({
       Boolean(clrChange.clrToTransparent)
     ).then((result) => {
       if (!cancelled) {
-        chunkJAI42EXQ_js.setCachedResult(cacheKey, result.dataUrl);
+        chunkJWNBTFZZ_js.setCachedResult(cacheKey, result.dataUrl);
         setProcessedSrc(result.dataUrl);
       }
       return void 0;
@@ -13786,7 +13329,7 @@ function TiledImageLayer({
       cancelled = true;
     };
   }, [src]);
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className, style: { ...chunkJAI42EXQ_js.getImageTilingStyle(element, nativeSize), ...style } });
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className, style: { ...chunkJWNBTFZZ_js.getImageTilingStyle(element, nativeSize), ...style } });
 }
 function renderImageEffectDefinitions(element, excludeDuotone = false) {
   return pptx.getImageSvgFilters(element).filter((definition) => !excludeDuotone || definition.id !== `duotone-${element.id}`).map((definition) => /* @__PURE__ */ jsxRuntime.jsx(
@@ -13855,7 +13398,7 @@ function renderImg(el, style, filter, alt, opacity) {
     ...filter ? { filter } : {},
     ...opacity !== void 0 ? { opacity } : {}
   };
-  if (chunkJAI42EXQ_js.isImageTiled(el)) {
+  if (chunkJWNBTFZZ_js.isImageTiled(el)) {
     const tileSrc = imgSrc(el);
     if (!tileSrc) {
       return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-full h-full flex items-center justify-center text-[11px] text-gray-500 bg-gray-100", children: "Image" });
@@ -13877,9 +13420,9 @@ function renderImg(el, style, filter, alt, opacity) {
     pptx$1.isImageLikeElement(el) ? el.imageEffects?.colorWash : void 0
   );
   const clrChange = "imageEffects" in el ? el.imageEffects?.clrChange : void 0;
-  const duotoneColors = chunkJAI42EXQ_js.getDuotoneColors(el);
+  const duotoneColors = chunkJWNBTFZZ_js.getDuotoneColors(el);
   const useDuotoneCanvas = Boolean(duotoneColors && !clrChange);
-  const filterForImg = useDuotoneCanvas ? chunkJAI42EXQ_js.getImageEffectsFilter(el, { excludeDuotone: true }) : filter;
+  const filterForImg = useDuotoneCanvas ? chunkJWNBTFZZ_js.getImageEffectsFilter(el, { excludeDuotone: true }) : filter;
   const canvasEffectStyles = {
     ...filterForImg ? { filter: filterForImg } : {},
     ...opacity !== void 0 ? { opacity } : {}
@@ -13955,10 +13498,10 @@ function SlideBackgroundImageLayer({
       style: { zIndex: 0 },
       children: renderImg(
         backgroundElement,
-        chunkJAI42EXQ_js.getImageRenderStyle(backgroundElement),
-        chunkJAI42EXQ_js.getImageEffectsFilter(backgroundElement),
+        chunkJWNBTFZZ_js.getImageRenderStyle(backgroundElement),
+        chunkJWNBTFZZ_js.getImageEffectsFilter(backgroundElement),
         "",
-        chunkJAI42EXQ_js.getImageEffectsOpacity(backgroundElement)
+        chunkJWNBTFZZ_js.getImageEffectsOpacity(backgroundElement)
       )
     }
   );
@@ -14244,7 +13787,7 @@ function ChartElementView({
     pptx.getBarFacePicturePixelSampleVersion
   );
   const viewModel = React17.useMemo(() => {
-    return canEdit ? chunkJAI42EXQ_js.buildReactChartViewModel(element) : null;
+    return canEdit ? chunkJWNBTFZZ_js.buildReactChartViewModel(element) : null;
   }, [canEdit, element, barFacePictureSampleVersion]);
   React17.useEffect(pptx.ensureChartInteractionStyles, []);
   React17.useEffect(() => {
@@ -14349,9 +13892,9 @@ function ChartElementView({
             textStyle: animationState?.textStyle,
             onSelect: chart3D.onSelect,
             onDrag: chart3D.onDrag,
-            children: chunkJAI42EXQ_js.renderChartElement(renderedElement, (key) => t(key))
+            children: chunkJWNBTFZZ_js.renderChartElement(renderedElement, (key) => t(key))
           }
-        ) : chunkJAI42EXQ_js.renderChartElement(renderedElement, (key) => t(key)),
+        ) : chunkJWNBTFZZ_js.renderChartElement(renderedElement, (key) => t(key)),
         dragValue !== null && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute top-1 right-1 z-10 rounded bg-primary/90 px-1.5 py-0.5 text-[10px] font-medium text-white pointer-events-none", children: pptx.formatAxisValue(dragValue) }),
         titleDraft !== null && /* @__PURE__ */ jsxRuntime.jsx(
           "input",
@@ -14512,6 +14055,50 @@ var EDGE_HANDLES = [
     sizeClass: "w-2 h-5 max-md:w-3 max-md:h-8 rounded-sm"
   }
 ];
+var wholeDegrees = (deg) => Math.round((deg % 360 + 360) % 360) % 360;
+function startRotateKnobGesture(options) {
+  const { button, elementId, rotation, onRotate } = options;
+  const scope = button.closest("[data-pptx-viewport]") ?? document;
+  const wrapper = scope.querySelector(pptx.elementIdSelector(elementId));
+  if (!wrapper) {
+    return;
+  }
+  const rect = wrapper.getBoundingClientRect();
+  const base = options.nonRotationTransform ? ` ${options.nonRotationTransform}` : "";
+  const paint = (deg) => {
+    const transform = `rotate(${deg}deg)${base}`;
+    wrapper.style.transform = transform;
+    syncSelectionHandleOverlay(wrapper, elementId, { transform });
+  };
+  if (options.pointerId !== void 0) {
+    button.setPointerCapture?.(options.pointerId);
+  }
+  const gesture = pptx.createGestureController({
+    getScale: () => 1,
+    getElementBox: () => ({
+      x: rect.left,
+      y: rect.top,
+      width: rect.width,
+      height: rect.height,
+      rotation
+    }),
+    getSiblings: () => [],
+    getStageOrigin: () => ({ left: 0, top: 0 }),
+    onStart: () => void 0,
+    onPreview: (transform) => paint(wholeDegrees(transform.rotation)),
+    onEnd: (transform) => {
+      const deg = transform ? wholeDegrees(transform.rotation) : rotation;
+      if (deg !== rotation) {
+        onRotate?.(elementId, deg);
+      }
+    }
+  });
+  gesture.begin("rotate", elementId, {
+    clientX: options.pointer.clientX,
+    clientY: options.pointer.clientY,
+    shiftKey: false
+  });
+}
 var appearance = { fill: "var(--color-primary)", borderColor: "#ffffff" };
 var cornerSize = "var(--pptx-react-corner-default, 12px)";
 var edgeLength = "var(--pptx-react-edge-length-default, 20px)";
@@ -14625,50 +14212,15 @@ function ResizeHandles({
     e.currentTarget.setPointerCapture?.(e.pointerId);
     onResizePointerDown(elementId, e, handle);
   };
-  const startRotate = (btn, pointer, pointerId) => {
-    const scope = btn.closest("[data-pptx-viewport]") ?? document;
-    const wrapper = scope.querySelector(pptx.elementIdSelector(elementId));
-    if (!wrapper) {
-      return;
-    }
-    const rect = wrapper.getBoundingClientRect();
-    const cx = rect.left + rect.width / 2;
-    const cy = rect.top + rect.height / 2;
-    const base = nonRotationTransform ? ` ${nonRotationTransform}` : "";
-    const startDeg = rotation ?? 0;
-    const dragRotation = pptx.createRotationDrag(
-      { x: cx, y: cy },
-      { x: pointer.clientX, y: pointer.clientY },
-      startDeg
-    );
-    let last = startDeg;
-    if (pointerId !== void 0) {
-      btn.setPointerCapture?.(pointerId);
-    }
-    const apply = (clientX, clientY, shift) => {
-      let deg = dragRotation({ x: clientX, y: clientY });
-      if (shift) {
-        deg = Math.round(deg / 15) * 15;
-      }
-      deg = Math.round((deg % 360 + 360) % 360);
-      last = deg;
-      const transform = `rotate(${deg}deg)${base}`;
-      wrapper.style.transform = transform;
-      syncSelectionHandleOverlay(wrapper, elementId, { transform });
-    };
-    const onPointerMove = (ev) => apply(ev.clientX, ev.clientY, ev.shiftKey);
-    const end = () => {
-      window.removeEventListener("pointermove", onPointerMove);
-      window.removeEventListener("pointerup", end);
-      window.removeEventListener("pointercancel", end);
-      if (last !== startDeg) {
-        onRotate?.(elementId, last);
-      }
-    };
-    window.addEventListener("pointermove", onPointerMove);
-    window.addEventListener("pointerup", end);
-    window.addEventListener("pointercancel", end);
-  };
+  const startRotate = (button, pointer) => startRotateKnobGesture({
+    button,
+    elementId,
+    pointer,
+    pointerId: pointer.pointerId,
+    rotation: rotation ?? 0,
+    ...nonRotationTransform ? { nonRotationTransform } : {},
+    ...onRotate ? { onRotate } : {}
+  });
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     [...CORNER_HANDLES, ...EDGE_HANDLES].map(({ handle, posClass, cursor }) => {
       const corner = handle.length === 2;
@@ -14681,7 +14233,7 @@ function ResizeHandles({
           "aria-label": t("pptx.selectionOverlay.resize", { handle }),
           "data-pptx-handle-kind": "resize",
           "data-pptx-compact": true,
-          className: chunkJAI42EXQ_js.cn(
+          className: chunkJWNBTFZZ_js.cn(
             "absolute z-10 group border-0 bg-transparent p-0",
             RESIZE_DEFAULT_CLASSES,
             posClass,
@@ -14707,7 +14259,7 @@ function ResizeHandles({
               "div",
               {
                 "data-pptx-handle-hit": true,
-                className: chunkJAI42EXQ_js.cn(
+                className: chunkJWNBTFZZ_js.cn(
                   "absolute -inset-px pointer-events-auto [--pptx-handle-hit-inset:-1px]",
                   corner ? "max-md:-inset-1.5 max-md:[--pptx-handle-hit-inset:-6px]" : "max-md:-inset-2 max-md:[--pptx-handle-hit-inset:-8px]"
                 ),
@@ -14728,7 +14280,7 @@ function ResizeHandles({
         "aria-label": t("pptx.selectionOverlay.rotate"),
         "data-pptx-handle-kind": "rotate",
         "data-pptx-compact": true,
-        className: chunkJAI42EXQ_js.cn(
+        className: chunkJWNBTFZZ_js.cn(
           "absolute left-1/2 top-0 -translate-x-1/2 -translate-y-1/2 z-20 border-0 bg-transparent p-0 cursor-grab active:cursor-grabbing",
           ROTATE_DEFAULT_CLASSES
         ),
@@ -14739,7 +14291,7 @@ function ResizeHandles({
         },
         onPointerDown: (e) => {
           e.stopPropagation();
-          startRotate(e.currentTarget, e, e.pointerId);
+          startRotate(e.currentTarget, e);
         },
         onMouseDown: (e) => {
           e.stopPropagation();
@@ -14805,10 +14357,10 @@ var ConnectorElementRendererMemo = /* @__PURE__ */ React17__default.default.memo
     const svgHeight = Math.max(el.height, 1);
     const ss = shapeEl?.shapeStyle;
     const strokeWidth = Math.max(0, ss?.strokeWidth ?? 2);
-    const strokeColor = chunkJAI42EXQ_js.normalizeHexColor(ss?.strokeColor, chunkJAI42EXQ_js.DEFAULT_STROKE_COLOR);
-    const strokePaint = chunkJAI42EXQ_js.colorWithOpacity(strokeColor, ss?.strokeOpacity);
-    const dashType = chunkJAI42EXQ_js.normalizeStrokeDashType(ss?.strokeDash);
-    const dashArray = chunkJAI42EXQ_js.getSvgStrokeDasharray(
+    const strokeColor = chunkJWNBTFZZ_js.normalizeHexColor(ss?.strokeColor, chunkJWNBTFZZ_js.DEFAULT_STROKE_COLOR);
+    const strokePaint = chunkJWNBTFZZ_js.colorWithOpacity(strokeColor, ss?.strokeOpacity);
+    const dashType = chunkJWNBTFZZ_js.normalizeStrokeDashType(ss?.strokeDash);
+    const dashArray = chunkJWNBTFZZ_js.getSvgStrokeDasharray(
       dashType,
       Math.max(strokeWidth, 1),
       ss?.customDashSegments
@@ -14819,14 +14371,14 @@ var ConnectorElementRendererMemo = /* @__PURE__ */ React17__default.default.memo
     const markerSeed = el.id.replace(/[^a-zA-Z0-9_-]/gu, "_");
     const startMarkerId = `${markerSeed}-sel-start`;
     const endMarkerId = `${markerSeed}-sel-end`;
-    const compoundOffsets = chunkJAI42EXQ_js.getCompoundLineOffsets(compoundLine, strokeWidth);
-    const compoundWidths = chunkJAI42EXQ_js.getCompoundLineWidths(compoundLine, strokeWidth);
+    const compoundOffsets = chunkJWNBTFZZ_js.getCompoundLineOffsets(compoundLine, strokeWidth);
+    const compoundWidths = chunkJWNBTFZZ_js.getCompoundLineWidths(compoundLine, strokeWidth);
     const strokeCap = pptx.svgLineCap(ss?.lineCap);
     const textEl = pptx$1.hasTextProperties(el) ? el : void 0;
     const connectorText = textEl?.text?.trim() ?? "";
     const connectorTextSegments = textEl?.textSegments;
     const connectorTextStyle = textEl?.textStyle;
-    const pathGeometry = shapeEl ? chunkJAI42EXQ_js.getConnectorPathGeometry(shapeEl) : {
+    const pathGeometry = shapeEl ? chunkJWNBTFZZ_js.getConnectorPathGeometry(shapeEl) : {
       pathData: `M 0 0 L ${viewWidth} ${viewHeight}`,
       startX: 0,
       startY: 0,
@@ -14835,16 +14387,16 @@ var ConnectorElementRendererMemo = /* @__PURE__ */ React17__default.default.memo
     };
     const hitTargetWidth = Math.max(strokeWidth * 3, 14);
     const selColor = selClr === "blue-400" ? "#60a5fa" : "#3b82f6";
-    const lineShadow = chunkJAI42EXQ_js.buildLineShadowCss(el);
-    const lineGlow = chunkJAI42EXQ_js.buildLineGlowFilter(el);
+    const lineShadow = chunkJWNBTFZZ_js.buildLineShadowCss(el);
+    const lineGlow = chunkJWNBTFZZ_js.buildLineGlowFilter(el);
     return /* @__PURE__ */ jsxRuntime.jsxs(
       "div",
       {
         "data-pptx-element": "true",
         "data-element-id": el.id,
-        role: chunkJAI42EXQ_js.getAriaRole(el, { actionable: false }),
-        "aria-label": chunkJAI42EXQ_js.getAriaLabel(el),
-        "aria-roledescription": chunkJAI42EXQ_js.getAriaRoleDescription(el),
+        role: chunkJWNBTFZZ_js.getAriaRole(el, { actionable: false }),
+        "aria-label": chunkJWNBTFZZ_js.getAriaLabel(el),
+        "aria-roledescription": chunkJWNBTFZZ_js.getAriaRoleDescription(el),
         "aria-selected": isSelected ? true : void 0,
         className: "absolute",
         style: {
@@ -14877,14 +14429,14 @@ var ConnectorElementRendererMemo = /* @__PURE__ */ React17__default.default.memo
               style: { overflow: "visible", pointerEvents: "none" },
               children: [
                 /* @__PURE__ */ jsxRuntime.jsxs("defs", { children: [
-                  chunkJAI42EXQ_js.renderConnectorMarker(
+                  chunkJWNBTFZZ_js.renderConnectorMarker(
                     startMarkerId,
                     startArrow,
                     strokePaint,
                     ss?.connectorStartArrowWidth,
                     ss?.connectorStartArrowLength
                   ),
-                  chunkJAI42EXQ_js.renderConnectorMarker(
+                  chunkJWNBTFZZ_js.renderConnectorMarker(
                     endMarkerId,
                     endArrow,
                     strokePaint,
@@ -15093,14 +14645,14 @@ function getElementInteractionProps({
   };
 }
 function renderDagDuotoneFilterForElement(el) {
-  if (!chunkJAI42EXQ_js.hasDagDuotoneEffect(el)) {
+  if (!chunkJWNBTFZZ_js.hasDagDuotoneEffect(el)) {
     return null;
   }
   const duotone = el.shapeStyle?.dagDuotone;
   if (!duotone) {
     return null;
   }
-  return chunkJAI42EXQ_js.renderDagDuotoneSvgFilter(el.id, duotone.color1, duotone.color2);
+  return chunkJWNBTFZZ_js.renderDagDuotoneSvgFilter(el.id, duotone.color1, duotone.color2);
 }
 function getContainerStyle({
   el,
@@ -15127,10 +14679,10 @@ function getContainerStyle({
     top: isFullscreenMedia ? fs.top : el.y,
     width: isFullscreenMedia ? fs.width : painted.width,
     ...heightStyle,
-    transform: isFullscreenMedia ? fs.transform : chunkJAI42EXQ_js.getElementTransform(el),
+    transform: isFullscreenMedia ? fs.transform : chunkJWNBTFZZ_js.getElementTransform(el),
     transformOrigin: "center",
     overflow: overflowValue,
-    clipPath: isPicture ? void 0 : isImg && !has3DExtrusion ? chunkJAI42EXQ_js.getCropShapeClipPath(el) : void 0,
+    clipPath: isPicture ? void 0 : isImg && !has3DExtrusion ? chunkJWNBTFZZ_js.getCropShapeClipPath(el) : void 0,
     zIndex: isFullscreenMedia ? fs.zIndex : zIndex,
     visibility: animationState?.visible === false ? "hidden" : "visible",
     animation: animationState?.cssAnimation,
@@ -15167,9 +14719,9 @@ function getContainerStyle({
 function shapeParams(element) {
   const style = pptx$1.hasShapeProperties(element) ? element.shapeStyle : void 0;
   const strokeWidth = pptx.paintedStrokeWidth(style);
-  const strokeColor = chunkJAI42EXQ_js.normalizeHexColor(style?.strokeColor, chunkJAI42EXQ_js.DEFAULT_STROKE_COLOR);
-  const fillColor = chunkJAI42EXQ_js.normalizeHexColor(style?.fillColor, chunkJAI42EXQ_js.DEFAULT_FILL_COLOR);
-  const hasFill = style?.fillColor !== void 0 && style.fillColor !== "transparent" || Boolean(chunkJAI42EXQ_js.buildCssGradientFromShapeStyle(style) || style?.fillGradient) || style?.fillMode === "pattern" && Boolean(style.fillPatternPreset);
+  const strokeColor = chunkJWNBTFZZ_js.normalizeHexColor(style?.strokeColor, chunkJWNBTFZZ_js.DEFAULT_STROKE_COLOR);
+  const fillColor = chunkJWNBTFZZ_js.normalizeHexColor(style?.fillColor, chunkJWNBTFZZ_js.DEFAULT_FILL_COLOR);
+  const hasFill = style?.fillColor !== void 0 && style.fillColor !== "transparent" || Boolean(chunkJWNBTFZZ_js.buildCssGradientFromShapeStyle(style) || style?.fillGradient) || style?.fillMode === "pattern" && Boolean(style.fillPatternPreset);
   return { hf: hasFill, fc: fillColor, sw: strokeWidth, sc: strokeColor };
 }
 var Extrusion3DOverlayMemo = /* @__PURE__ */ React17__default.default.memo(
@@ -15277,7 +14829,7 @@ function ShapeEffectOverlay({
   const fillOverlayStyle = overlay ? {
     position: "absolute",
     inset: 0,
-    ...pptx$1.isImageLikeElement(element) ? chunkJAI42EXQ_js.getImageSurfaceMaskStyle(element) : {},
+    ...pptx$1.isImageLikeElement(element) ? chunkJWNBTFZZ_js.getImageSurfaceMaskStyle(element) : {},
     background: overlay.color,
     mixBlendMode: overlay.blendMode,
     pointerEvents: "none"
@@ -15484,10 +15036,10 @@ var ElementRenderer = /* @__PURE__ */ React17__default.default.memo(
     const backgroundAnimationState = pptx.getBackgroundAnimationState(el, presentationElementStates);
     const effectPlacement = pptx.getShapeEffectLayerPlacement(el);
     const visualAnimationState = backgroundAnimationState ?? animationState;
-    const isTxt = chunkJAI42EXQ_js.isEditableTextElement(el) && allow.textEditable;
+    const isTxt = chunkJWNBTFZZ_js.isEditableTextElement(el) && allow.textEditable;
     const txtSE = pptx$1.hasTextProperties(el) ? el.textStyle : void 0;
     const textStyleOverrideCss = pptx.buildTextStyleOverrideCss(el.id, visualAnimationState?.textStyle);
-    const ss = chunkJAI42EXQ_js.getShapeVisualStyle(
+    const ss = chunkJWNBTFZZ_js.getShapeVisualStyle(
       el,
       hf,
       fc,
@@ -15496,9 +15048,9 @@ var ElementRenderer = /* @__PURE__ */ React17__default.default.memo(
       visualAnimationState?.animatesFill,
       visualAnimationState?.animatesStroke
     );
-    const ts = chunkJAI42EXQ_js.getTextStyleForElement(el, chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR);
+    const ts = chunkJWNBTFZZ_js.getTextStyleForElement(el, chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR);
     const isImg = el.type === "picture" || el.type === "image";
-    const vs = chunkJAI42EXQ_js.renderVectorShape(
+    const vs = chunkJWNBTFZZ_js.renderVectorShape(
       el,
       isImg ? false : hf,
       fc,
@@ -15508,10 +15060,10 @@ var ElementRenderer = /* @__PURE__ */ React17__default.default.memo(
       visualAnimationState?.animatesStroke
     );
     const isModel3D = el.type === "model3d";
-    const isConn = chunkJAI42EXQ_js.isConnectorOrLineElement(el);
+    const isConn = chunkJWNBTFZZ_js.isConnectorOrLineElement(el);
     const shapeStyle3d = pptx$1.hasShapeProperties(el) ? el.shapeStyle : void 0;
     const extrusionData = React17.useMemo(
-      () => chunkJAI42EXQ_js.build3DExtrusionData(shapeStyle3d?.shape3d, shapeStyle3d?.scene3d, fc, el.width, el.height),
+      () => chunkJWNBTFZZ_js.build3DExtrusionData(shapeStyle3d?.shape3d, shapeStyle3d?.scene3d, fc, el.width, el.height),
       [shapeStyle3d?.shape3d, shapeStyle3d?.scene3d, fc, el.width, el.height]
     );
     const actionAffordance = useActionAffordance(el, canInteract);
@@ -15601,7 +15153,7 @@ var ElementRenderer = /* @__PURE__ */ React17__default.default.memo(
         "aria-hidden": aria.hidden ? true : void 0,
         "aria-selected": isSelected ? true : void 0,
         tabIndex: isFocusable ? 0 : -1,
-        className: chunkJAI42EXQ_js.cn(
+        className: chunkJWNBTFZZ_js.cn(
           "absolute",
           "focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-500",
           cur,
@@ -15674,9 +15226,9 @@ var ElementRenderer = /* @__PURE__ */ React17__default.default.memo(
             txtSE,
             txtS: ts,
             vecShape: backgroundAnimationState && !isImg ? null : vs,
-            imgStyle: chunkJAI42EXQ_js.getImageRenderStyle(el),
-            imgFilter: chunkJAI42EXQ_js.getImageEffectsFilter(el),
-            imgOpacity: chunkJAI42EXQ_js.getImageEffectsOpacity(el),
+            imgStyle: chunkJWNBTFZZ_js.getImageRenderStyle(el),
+            imgFilter: chunkJWNBTFZZ_js.getImageEffectsFilter(el),
+            imgOpacity: chunkJWNBTFZZ_js.getImageEffectsOpacity(el),
             imgAlt: imageAltText,
             isTxtEl: isTxt,
             media: mediaDataUrls,
@@ -15813,10 +15365,10 @@ function renderStrokeView(view, pressureSensitive, replayStyle, key) {
 }
 function renderInk(el, options) {
   const replay = options?.replay ?? false;
-  const strokes = chunkJAI42EXQ_js.buildInkGroupStrokes(el, { color: "#000", width: 3 });
+  const strokes = chunkJWNBTFZZ_js.buildInkGroupStrokes(el, { color: "#000", width: 3 });
   strokes.some((s) => s.circles || s.nibMarks);
   const pressureSensitive = options?.pressureSensitive;
-  const replayStyles = replay ? chunkJAI42EXQ_js.getInkReplayStyles(el, options?.replayConfig) : null;
+  const replayStyles = replay ? chunkJWNBTFZZ_js.getInkReplayStyles(el, options?.replayConfig) : null;
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "svg",
     {
@@ -15824,7 +15376,7 @@ function renderInk(el, options) {
       viewBox: `0 0 ${Math.max(el.width, 1)} ${Math.max(el.height, 1)}`,
       preserveAspectRatio: "none",
       children: [
-        replay && /* @__PURE__ */ jsxRuntime.jsx("style", { children: chunkJAI42EXQ_js.INK_REPLAY_KEYFRAMES }),
+        replay && /* @__PURE__ */ jsxRuntime.jsx("style", { children: chunkJWNBTFZZ_js.INK_REPLAY_KEYFRAMES }),
         strokes.map(
           (s, i) => renderStrokeView(s, pressureSensitive, replayStyles?.[i], `${el.id}-ink-${i}`)
         )
@@ -15835,7 +15387,7 @@ function renderInk(el, options) {
 function renderGroup(children, parentGroupFill) {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative w-full h-full pointer-events-none", children: pptx.filterRenderedElements(children).map((c, childIndex) => {
     const { hf, fc, sw, sc } = shapeParams(c);
-    const baseSs = chunkJAI42EXQ_js.getShapeVisualStyle(c, hf, fc, sw, sc);
+    const baseSs = chunkJWNBTFZZ_js.getShapeVisualStyle(c, hf, fc, sw, sc);
     const inheritedFill = pptx.resolveGroupChildFill(c, parentGroupFill);
     const ss = inheritedFill ? {
       ...baseSs,
@@ -15846,9 +15398,9 @@ function renderGroup(children, parentGroupFill) {
       backgroundPosition: inheritedFill.backgroundPosition
     } : baseSs;
     const isI = c.type === "picture" || c.type === "image";
-    const vs = chunkJAI42EXQ_js.renderVectorShape(c, isI ? false : hf, fc, sw, sc);
-    const ts = chunkJAI42EXQ_js.getTextStyleForElement(c, chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR);
-    const isTxt = chunkJAI42EXQ_js.isEditableTextElement(c);
+    const vs = chunkJWNBTFZZ_js.renderVectorShape(c, isI ? false : hf, fc, sw, sc);
+    const ts = chunkJWNBTFZZ_js.getTextStyleForElement(c, chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR);
+    const isTxt = chunkJWNBTFZZ_js.isEditableTextElement(c);
     return /* @__PURE__ */ jsxRuntime.jsxs(
       "div",
       {
@@ -15857,9 +15409,9 @@ function renderGroup(children, parentGroupFill) {
         style: {
           left: c.x,
           top: c.y,
-          width: Math.max(c.width, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE),
-          height: Math.max(c.height, chunkJAI42EXQ_js.MIN_ELEMENT_SIZE),
-          transform: chunkJAI42EXQ_js.getElementTransform(c),
+          width: Math.max(c.width, chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE),
+          height: Math.max(c.height, chunkJWNBTFZZ_js.MIN_ELEMENT_SIZE),
+          transform: chunkJWNBTFZZ_js.getElementTransform(c),
           transformOrigin: "center",
           ...ss,
           ...isI ? {
@@ -15884,8 +15436,8 @@ function renderGroup(children, parentGroupFill) {
             // A nested group: recurse, chaining the inherited fill so a
             // `grpFill` shape under a fill-less sub-group still paints.
             renderGroup(c.children, pptx.getGroupChildParentFill(c, parentGroupFill))
-          ) : isI && ("svgData" in c && c.svgData || "imageData" in c && c.imageData) ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "absolute inset-0 pointer-events-none", style: chunkJAI42EXQ_js.getImageSurfaceStyle(c), children: [
-            chunkJAI42EXQ_js.isImageTiled(c) ? /* @__PURE__ */ jsxRuntime.jsx(
+          ) : isI && ("svgData" in c && c.svgData || "imageData" in c && c.imageData) ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "absolute inset-0 pointer-events-none", style: chunkJWNBTFZZ_js.getImageSurfaceStyle(c), children: [
+            chunkJWNBTFZZ_js.isImageTiled(c) ? /* @__PURE__ */ jsxRuntime.jsx(
               TiledImageLayer,
               {
                 element: c,
@@ -15898,7 +15450,7 @@ function renderGroup(children, parentGroupFill) {
                 src: "svgData" in c && c.svgData ? c.svgData : c.imageData,
                 alt: i18n.translationsEn["pptx.ink.groupChildAlt"],
                 className: "pointer-events-none select-none",
-                style: chunkJAI42EXQ_js.getImageRenderStyle(c),
+                style: chunkJWNBTFZZ_js.getImageRenderStyle(c),
                 draggable: false
               }
             ),
@@ -15910,7 +15462,7 @@ function renderGroup(children, parentGroupFill) {
               {
                 className: "relative z-10 w-full h-full pointer-events-none whitespace-pre-wrap break-words leading-[1.3]",
                 style: ts,
-                children: chunkJAI42EXQ_js.renderTextSegments(c, chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR)
+                children: chunkJWNBTFZZ_js.renderTextSegments(c, chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR)
               }
             ) : null
           ] })
@@ -15924,8 +15476,8 @@ function renderContentPart(el, options) {
   if (el.inkStrokes && el.inkStrokes.length > 0) {
     const replay = options?.replay ?? false;
     const pressureSensitive = options?.pressureSensitive ?? true;
-    const strokes = chunkJAI42EXQ_js.buildContentPartStrokes(el);
-    const replayStyles = replay ? chunkJAI42EXQ_js.getContentPartReplayStyles(el.inkStrokes, options?.replayConfig) : null;
+    const strokes = chunkJWNBTFZZ_js.buildContentPartStrokes(el);
+    const replayStyles = replay ? chunkJWNBTFZZ_js.getContentPartReplayStyles(el.inkStrokes, options?.replayConfig) : null;
     return /* @__PURE__ */ jsxRuntime.jsxs(
       "svg",
       {
@@ -15933,7 +15485,7 @@ function renderContentPart(el, options) {
         viewBox: `0 0 ${Math.max(el.width, 1)} ${Math.max(el.height, 1)}`,
         preserveAspectRatio: "none",
         children: [
-          replay && /* @__PURE__ */ jsxRuntime.jsx("style", { children: chunkJAI42EXQ_js.INK_REPLAY_KEYFRAMES }),
+          replay && /* @__PURE__ */ jsxRuntime.jsx("style", { children: chunkJWNBTFZZ_js.INK_REPLAY_KEYFRAMES }),
           strokes.map(
             (s, i) => renderStrokeView(s, pressureSensitive, replayStyles?.[i], `${el.id}-cp-ink-${i}`)
           )
@@ -16160,9 +15712,9 @@ function useInlineListEditor(element, rootRef, onChange, onModelReplacement) {
         collaboration: connected,
         model: pptx.createInlineListModelObserver(element),
         activationSelection,
-        children: seed && !connected ? chunkJAI42EXQ_js.renderTextSegments(
+        children: seed && !connected ? chunkJWNBTFZZ_js.renderTextSegments(
           element,
-          chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR,
+          chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR,
           void 0,
           void 0,
           void 0,
@@ -16398,8 +15950,8 @@ function InlineTextEditor({
       pending.endOffset
     );
   });
-  const warpStyle = chunkJAI42EXQ_js.getTextWarpStyle(textStyleRaw);
-  const compensationTransform = chunkJAI42EXQ_js.getTextCompensationTransform(element);
+  const warpStyle = chunkJWNBTFZZ_js.getTextWarpStyle(textStyleRaw);
+  const compensationTransform = chunkJWNBTFZZ_js.getTextCompensationTransform(element);
   const warpTransform = warpStyle?.transform;
   const mergedTransform = [compensationTransform, warpTransform].filter(Boolean).join(" ") || void 0;
   const wrapperStyle = {
@@ -16487,7 +16039,7 @@ function InlineTextEditor({
         const text = e.clipboardData.getData("text/plain");
         document.execCommand("insertText", false, text);
       },
-      children: list.seed ? list.children : seed.hasRichSegments ? chunkJAI42EXQ_js.renderTextSegments(element, chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR) : seed.initialText
+      children: list.seed ? list.children : seed.hasRichSegments ? chunkJWNBTFZZ_js.renderTextSegments(element, chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR) : seed.initialText
     },
     list.seed?.paragraphs[0].token ?? "plain"
   );
@@ -17634,7 +17186,7 @@ function groupIntoParagraphs(element, fieldContext) {
     element,
     fieldContext ? (seg) => {
       if (seg.fieldType) {
-        const substituted = chunkJAI42EXQ_js.substituteFieldText(
+        const substituted = chunkJWNBTFZZ_js.substituteFieldText(
           seg.text,
           seg.fieldType,
           fieldContext,
@@ -17669,13 +17221,13 @@ function getSegmentTspanProps(segment, element, fallbackColor) {
   if (s.strikethrough) {
     decos.push("line-through");
   }
-  const fill = s.hyperlink ? chunkJAI42EXQ_js.normalizeHexColor(s.color || element.textStyle?.color, chunkJAI42EXQ_js.HYPERLINK_COLOR) : chunkJAI42EXQ_js.normalizeHexColor(s.color || element.textStyle?.color, fallbackColor);
+  const fill = s.hyperlink ? chunkJWNBTFZZ_js.normalizeHexColor(s.color || element.textStyle?.color, chunkJWNBTFZZ_js.HYPERLINK_COLOR) : chunkJWNBTFZZ_js.normalizeHexColor(s.color || element.textStyle?.color, fallbackColor);
   return {
     fill,
-    fontSize: s.fontSize ?? element.textStyle?.fontSize ?? chunkJAI42EXQ_js.DEFAULT_TEXT_FONT_SIZE,
+    fontSize: s.fontSize ?? element.textStyle?.fontSize ?? chunkJWNBTFZZ_js.DEFAULT_TEXT_FONT_SIZE,
     fontWeight: pptx.resolveFontWeight(s.fontFamily || element.textStyle?.fontFamily, s.bold),
     fontStyle: pptx.resolveFontItalic(s.fontFamily || element.textStyle?.fontFamily, s.italic) ? "italic" : void 0,
-    fontFamily: s.fontFamily || element.textStyle?.fontFamily ? pptx$1.getSubstituteFontFamily(s.fontFamily || element.textStyle?.fontFamily || "") : chunkJAI42EXQ_js.DEFAULT_FONT_FAMILY,
+    fontFamily: s.fontFamily || element.textStyle?.fontFamily ? pptx$1.getSubstituteFontFamily(s.fontFamily || element.textStyle?.fontFamily || "") : chunkJWNBTFZZ_js.DEFAULT_FONT_FAMILY,
     textDecoration: decos.length > 0 ? decos.join(" ") : void 0
   };
 }
@@ -17683,8 +17235,8 @@ function resolveSegmentFont(segment, element) {
   const s = segment.style || {};
   const family = s.fontFamily || element.textStyle?.fontFamily;
   return {
-    fontFamily: family ? pptx$1.getSubstituteFontFamily(family) : chunkJAI42EXQ_js.DEFAULT_FONT_FAMILY,
-    fontSizePx: s.fontSize ?? element.textStyle?.fontSize ?? chunkJAI42EXQ_js.DEFAULT_TEXT_FONT_SIZE,
+    fontFamily: family ? pptx$1.getSubstituteFontFamily(family) : chunkJWNBTFZZ_js.DEFAULT_FONT_FAMILY,
+    fontSizePx: s.fontSize ?? element.textStyle?.fontSize ?? chunkJWNBTFZZ_js.DEFAULT_TEXT_FONT_SIZE,
     bold: s.bold ?? element.textStyle?.bold,
     italic: s.italic ?? element.textStyle?.italic
   };
@@ -17768,9 +17320,9 @@ function WarpedText({
   const warpAdj2 = textEl.textStyle?.textWarpAdj2;
   const align = textEl.textStyle?.align ?? "center";
   const { startOffset, textAnchor } = getAlignmentProps(align);
-  const baseFontSize = textEl.textStyle?.fontSize ?? chunkJAI42EXQ_js.DEFAULT_TEXT_FONT_SIZE;
-  const baseFontFamily = textEl.textStyle?.fontFamily ? pptx$1.getSubstituteFontFamily(textEl.textStyle.fontFamily) : chunkJAI42EXQ_js.DEFAULT_FONT_FAMILY;
-  const baseFill = chunkJAI42EXQ_js.normalizeHexColor(textEl.textStyle?.color, fallbackColor);
+  const baseFontSize = textEl.textStyle?.fontSize ?? chunkJWNBTFZZ_js.DEFAULT_TEXT_FONT_SIZE;
+  const baseFontFamily = textEl.textStyle?.fontFamily ? pptx$1.getSubstituteFontFamily(textEl.textStyle.fontFamily) : chunkJWNBTFZZ_js.DEFAULT_FONT_FAMILY;
+  const baseFill = chunkJWNBTFZZ_js.normalizeHexColor(textEl.textStyle?.color, fallbackColor);
   if (pptx.hasGlyphEnvelope(preset)) {
     const perLine = pptx.buildGlyphEnvelopeBlock(
       preset,
@@ -17872,7 +17424,7 @@ function WarpedText({
 var GLYPH_BY_SHAPE = /* @__PURE__ */ buildGlyphByShape();
 function buildGlyphByShape() {
   const glyphs = Object.fromEntries(
-    chunkJAI42EXQ_js.ACTION_BUTTON_PRESETS.map((p) => [p.shapeType, p.iconPath])
+    chunkJWNBTFZZ_js.ACTION_BUTTON_PRESETS.map((p) => [p.shapeType, p.iconPath])
   );
   glyphs["actionButtonForwardOrNext"] = glyphs["actionButtonForwardNext"];
   glyphs["actionButtonBackOrPrevious"] = glyphs["actionButtonBackPrevious"];
@@ -17946,9 +17498,9 @@ function renderTextElementBody(options) {
   const useSvgWarp = pptx.shouldUseSvgWarp(
     pptx$1.hasTextProperties(el) ? el.textStyle?.textWarpPreset : void 0
   );
-  const scene3dStyle = pptx$1.hasTextProperties(el) ? chunkJAI42EXQ_js.buildTextBody3DSceneStyle(el.textStyle, { width: el.width, height: el.height }) : void 0;
+  const scene3dStyle = pptx$1.hasTextProperties(el) ? chunkJWNBTFZZ_js.buildTextBody3DSceneStyle(el.textStyle, { width: el.width, height: el.height }) : void 0;
   const rotationTransform = pptx.getTextBodyRotationTransform(el);
-  const composedTransform = [rotationTransform, chunkJAI42EXQ_js.getTextCompensationTransform(el), scene3dStyle?.transform].filter(Boolean).join(" ") || void 0;
+  const composedTransform = [rotationTransform, chunkJWNBTFZZ_js.getTextCompensationTransform(el), scene3dStyle?.transform].filter(Boolean).join(" ") || void 0;
   const transformStyle = {
     transform: composedTransform,
     // A COM-measured homography (`scene3dStyle.transformOrigin === '0 0'`)
@@ -17978,18 +17530,18 @@ function renderTextElementBody(options) {
     shouldRenderText && (useSvgWarp ? /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
-        className: chunkJAI42EXQ_js.cn(
+        className: chunkJWNBTFZZ_js.cn(
           "relative z-10 w-full h-full",
           onHyperlinkClick ? "" : "pointer-events-none"
         ),
-        style: { ...chunkJAI42EXQ_js.getTextLayoutStyle(el), ...transformStyle },
+        style: { ...chunkJWNBTFZZ_js.getTextLayoutStyle(el), ...transformStyle },
         children: /* @__PURE__ */ jsxRuntime.jsx(
           WarpedText,
           {
             element: el,
             width: el.width,
             height: el.height,
-            fallbackColor: chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR,
+            fallbackColor: chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR,
             findHighlights: findHl,
             fieldContext
           }
@@ -17998,19 +17550,19 @@ function renderTextElementBody(options) {
     ) : /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
-        className: chunkJAI42EXQ_js.cn(
+        className: chunkJWNBTFZZ_js.cn(
           "relative z-10 w-full h-full whitespace-pre-wrap break-words leading-[1.3]",
           onHyperlinkClick ? "" : "pointer-events-none"
         ),
         style: {
-          ...chunkJAI42EXQ_js.getTextLayoutStyle(el),
+          ...chunkJWNBTFZZ_js.getTextLayoutStyle(el),
           ...txtS,
-          ...chunkJAI42EXQ_js.getTextWarpStyle(txtSE),
+          ...chunkJWNBTFZZ_js.getTextWarpStyle(txtSE),
           ...transformStyle
         },
-        children: chunkJAI42EXQ_js.renderTextSegments(
+        children: chunkJWNBTFZZ_js.renderTextSegments(
           el,
-          chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR,
+          chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR,
           void 0,
           findHl,
           onHyperlinkClick,
@@ -18329,7 +17881,7 @@ function renderBody(options) {
     );
   }
   if (isImg) {
-    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "absolute inset-0 pointer-events-none", style: chunkJAI42EXQ_js.getImageSurfaceStyle(el), children: [
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "absolute inset-0 pointer-events-none", style: chunkJWNBTFZZ_js.getImageSurfaceStyle(el), children: [
       renderImg(el, imgStyle, imgFilter, imgAlt, imgOpacity),
       vecShape ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "pointer-events-none absolute inset-0", children: vecShape }) : null
     ] });
@@ -18346,7 +17898,7 @@ function renderBody(options) {
           textDirection: txtSE?.textDirection,
           textStyle: txtS,
           textStyleRaw: txtSE,
-          layoutStyle: chunkJAI42EXQ_js.getTextLayoutStyle(el),
+          layoutStyle: chunkJWNBTFZZ_js.getTextLayoutStyle(el),
           element: el,
           onCommit,
           onCancel,
@@ -18357,7 +17909,7 @@ function renderBody(options) {
     ] });
   }
   if (el.type === "table") {
-    return chunkJAI42EXQ_js.renderTableElement(el, txtS, {
+    return chunkJWNBTFZZ_js.renderTableElement(el, txtS, {
       editable: isSel,
       selectedCell: isSel ? tableSt : null,
       onSelectCell: onCellSel,
@@ -18390,7 +17942,7 @@ function renderBody(options) {
     );
   }
   if (el.type === "media") {
-    return chunkJAI42EXQ_js.renderMediaElement(el, media, {
+    return chunkJWNBTFZZ_js.renderMediaElement(el, media, {
       // Present mode autoplays every media element on the active slide,
       // not only ones persisted with their own `autoPlay` flag (matching
       // the other four bindings' unconditional `presenting`-gated
@@ -18442,27 +17994,27 @@ function renderBody(options) {
     }
     return renderGroup(el.children, pptx.getGroupChildParentFill(el));
   }
-  if (chunkJAI42EXQ_js.shouldRenderFallbackLabel(el, isTxtEl)) {
-    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-full h-full flex items-center justify-center text-[11px] text-white/80 pointer-events-none", children: chunkJAI42EXQ_js.getElementLabel(el) });
+  if (chunkJWNBTFZZ_js.shouldRenderFallbackLabel(el, isTxtEl)) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-full h-full flex items-center justify-center text-[11px] text-white/80 pointer-events-none", children: chunkJWNBTFZZ_js.getElementLabel(el) });
   }
   return renderTextElementBody(options);
 }
 function defaultTextColorForFill(fillColor) {
   const hex = String(fillColor ?? "").replace(/^#/u, "");
   if (!/^[0-9a-f]{6}$/iu.test(hex)) {
-    return chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR;
+    return chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR;
   }
   const channels = [0, 2, 4].map((offset) => Number.parseInt(hex.slice(offset, offset + 2), 16) / 255).map((channel) => channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4);
   const luminance = channels[0] * 0.2126 + channels[1] * 0.7152 + channels[2] * 0.0722;
-  return luminance > 0.179 ? chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR : "#ffffff";
+  return luminance > 0.179 ? chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR : "#ffffff";
 }
 function getStaticElementVisualState(element, parentGroupFill) {
   const style = pptx$1.hasShapeProperties(element) ? element.shapeStyle : void 0;
-  const hasFill = style?.fillColor !== void 0 && style.fillColor !== "transparent" || Boolean(chunkJAI42EXQ_js.buildCssGradientFromShapeStyle(style) || style?.fillGradient) || style?.fillMode === "pattern" && Boolean(style.fillPatternPreset);
-  const fill = chunkJAI42EXQ_js.normalizeHexColor(style?.fillColor, chunkJAI42EXQ_js.DEFAULT_FILL_COLOR);
+  const hasFill = style?.fillColor !== void 0 && style.fillColor !== "transparent" || Boolean(chunkJWNBTFZZ_js.buildCssGradientFromShapeStyle(style) || style?.fillGradient) || style?.fillMode === "pattern" && Boolean(style.fillPatternPreset);
+  const fill = chunkJWNBTFZZ_js.normalizeHexColor(style?.fillColor, chunkJWNBTFZZ_js.DEFAULT_FILL_COLOR);
   const strokeWidth = pptx.paintedStrokeWidth(style);
-  const stroke = chunkJAI42EXQ_js.normalizeHexColor(style?.strokeColor, chunkJAI42EXQ_js.DEFAULT_STROKE_COLOR);
-  const baseVisualStyle = chunkJAI42EXQ_js.getShapeVisualStyle(element, hasFill, fill, strokeWidth, stroke);
+  const stroke = chunkJWNBTFZZ_js.normalizeHexColor(style?.strokeColor, chunkJWNBTFZZ_js.DEFAULT_STROKE_COLOR);
+  const baseVisualStyle = chunkJWNBTFZZ_js.getShapeVisualStyle(element, hasFill, fill, strokeWidth, stroke);
   const inheritedFill = pptx.resolveGroupChildFill(element, parentGroupFill);
   const visualStyle = inheritedFill ? {
     ...baseVisualStyle,
@@ -18472,9 +18024,9 @@ function getStaticElementVisualState(element, parentGroupFill) {
     backgroundSize: inheritedFill.backgroundSize,
     backgroundPosition: inheritedFill.backgroundPosition
   } : baseVisualStyle;
-  const textStyle = chunkJAI42EXQ_js.getTextStyleForElement(
+  const textStyle = chunkJWNBTFZZ_js.getTextStyleForElement(
     element,
-    element.type === "shape" && hasFill ? defaultTextColorForFill(fill) : chunkJAI42EXQ_js.DEFAULT_TEXT_COLOR
+    element.type === "shape" && hasFill ? defaultTextColorForFill(fill) : chunkJWNBTFZZ_js.DEFAULT_TEXT_COLOR
   );
   const isImage = element.type === "picture" || element.type === "image";
   const letsTextOverflow = pptx$1.hasTextProperties(element) && element.textStyle?.autoFitMode === "shrink" && (element.type === "text" || element.locks?.txBox === true);
@@ -18499,7 +18051,7 @@ function getStaticElementInteractionState(element, hasActionHandler, exposeEleme
   return { action, isActionable, contractRole };
 }
 function getStaticElementWrapperClassName(element, visual, positioned, isActionable) {
-  const overflowClass = visual.isImage || visual.strokeWidth > 0 || element.type === "group" || chunkJAI42EXQ_js.isConnectorOrLineElement(element) || visual.isCallout || visual.letsTextOverflow ? "" : "overflow-hidden";
+  const overflowClass = visual.isImage || visual.strokeWidth > 0 || element.type === "group" || chunkJWNBTFZZ_js.isConnectorOrLineElement(element) || visual.isCallout || visual.letsTextOverflow ? "" : "overflow-hidden";
   const pointerClass = isActionable ? "pointer-events-auto cursor-pointer" : "pointer-events-none";
   return `${positioned ? "absolute" : "relative"} ${overflowClass} ${pointerClass}`;
 }
@@ -18582,7 +18134,7 @@ function StaticElementRendererImpl({
         top: positioned ? element.y : void 0,
         width: positioned ? Math.max(element.width, 1) : "100%",
         height: positioned ? Math.max(element.height, 1) : "100%",
-        transform: positioned ? chunkJAI42EXQ_js.getElementTransform(element) : void 0,
+        transform: positioned ? chunkJWNBTFZZ_js.getElementTransform(element) : void 0,
         transformOrigin: "center",
         zIndex,
         ...visualStyle,
@@ -18625,18 +18177,18 @@ function StaticElementRendererImpl({
           spellCheck: false,
           txtSE: pptx$1.hasTextProperties(element) ? element.textStyle : void 0,
           txtS: textStyle,
-          vecShape: chunkJAI42EXQ_js.renderVectorShape(
+          vecShape: chunkJWNBTFZZ_js.renderVectorShape(
             element,
             isImage ? false : hasFill,
             fill,
             strokeWidth,
             stroke
           ),
-          imgStyle: imageAnimation ? { ...chunkJAI42EXQ_js.getImageRenderStyle(element), animation: imageAnimation } : chunkJAI42EXQ_js.getImageRenderStyle(element),
-          imgFilter: chunkJAI42EXQ_js.getImageEffectsFilter(element),
-          imgOpacity: chunkJAI42EXQ_js.getImageEffectsOpacity(element),
+          imgStyle: imageAnimation ? { ...chunkJWNBTFZZ_js.getImageRenderStyle(element), animation: imageAnimation } : chunkJWNBTFZZ_js.getImageRenderStyle(element),
+          imgFilter: chunkJWNBTFZZ_js.getImageEffectsFilter(element),
+          imgOpacity: chunkJWNBTFZZ_js.getImageEffectsOpacity(element),
           imgAlt: "",
-          isTxtEl: chunkJAI42EXQ_js.isEditableTextElement(element),
+          isTxtEl: chunkJWNBTFZZ_js.isEditableTextElement(element),
           media: mediaDataUrls,
           tableSt: null,
           isSel: false,
@@ -18684,7 +18236,7 @@ function SlideLayer({
       style: {
         width: safeWidth,
         height: safeHeight,
-        backgroundColor: slide.backgroundColor ? chunkJAI42EXQ_js.normalizeHexColor(slide.backgroundColor, "#ffffff") : "#ffffff",
+        backgroundColor: slide.backgroundColor ? chunkJWNBTFZZ_js.normalizeHexColor(slide.backgroundColor, "#ffffff") : "#ffffff",
         backgroundImage: slide.backgroundImage ? `url(${slide.backgroundImage})` : slide.backgroundGradient ? slide.backgroundGradient : void 0,
         backgroundSize: slide.backgroundImage ? "cover" : void 0,
         backgroundPosition: slide.backgroundImage ? "center" : void 0
@@ -19206,7 +18758,6 @@ exports.Rendering3DFlagsContext = Rendering3DFlagsContext;
 exports.ResizeHandles = ResizeHandles;
 exports.SlideBackgroundImageLayer = SlideBackgroundImageLayer;
 exports.SlideLayer = SlideLayer;
-exports.SmartArtRenderer = SmartArtRenderer;
 exports.StaticElementRenderer = StaticElementRenderer;
 exports.ViewerOptionsContext = ViewerOptionsContext;
 exports.ViewerOptionsStoreContext = ViewerOptionsStoreContext;
@@ -19240,6 +18791,7 @@ exports.useCollaborativeState = useCollaborativeState;
 exports.useComments = useComments;
 exports.useCompatibilityToastsState = useCompatibilityToastsState;
 exports.useContentLifecycle = useContentLifecycle;
+exports.useController = useController;
 exports.useDerivedElementState = useDerivedElementState;
 exports.useDerivedSlideState = useDerivedSlideState;
 exports.useDialogCustomShows = useDialogCustomShows;