pptx-react-viewer 1.16.1 → 1.17.0

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/lib/canvas-export.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBAoCsB,eACrB,SAAS,aACT,UAAS,QAAQ,WACf,QAAQ"}

package/dist/index.js

@@ -1,67 +1,67 @@
 'use strict';
 
-var chunkYQHPV3VP_js = require('./chunk-YQHPV3VP.js');
-var chunk4LRPKUP7_js = require('./chunk-4LRPKUP7.js');
-var chunkTLGPM7SI_js = require('./chunk-TLGPM7SI.js');
+var chunkXW5OMXW6_js = require('./chunk-XW5OMXW6.js');
+var chunk3P6O7ZDM_js = require('./chunk-3P6O7ZDM.js');
+var chunkJWS3RQKN_js = require('./chunk-JWS3RQKN.js');
 require('./chunk-WGLJ32FW.js');
-require('./chunk-VMQLQEGG.js');
+require('./chunk-MGLRKGCH.js');
 require('./chunk-QGM4M3NI.js');
 
 
 
 Object.defineProperty(exports, "PowerPointViewer", {
   enumerable: true,
-  get: function () { return chunkYQHPV3VP_js.PowerPointViewer; }
+  get: function () { return chunkXW5OMXW6_js.PowerPointViewer; }
 });
 Object.defineProperty(exports, "ViewerThemeProvider", {
   enumerable: true,
-  get: function () { return chunkYQHPV3VP_js.ViewerThemeProvider; }
+  get: function () { return chunkXW5OMXW6_js.ViewerThemeProvider; }
 });
 Object.defineProperty(exports, "useViewerTheme", {
   enumerable: true,
-  get: function () { return chunkYQHPV3VP_js.useViewerTheme; }
+  get: function () { return chunkXW5OMXW6_js.useViewerTheme; }
 });
 Object.defineProperty(exports, "getAnimationInitialStyle", {
   enumerable: true,
-  get: function () { return chunk4LRPKUP7_js.getAnimationInitialStyle; }
+  get: function () { return chunk3P6O7ZDM_js.getAnimationInitialStyle; }
 });
 Object.defineProperty(exports, "renderToCanvas", {
   enumerable: true,
-  get: function () { return chunk4LRPKUP7_js.renderToCanvas; }
+  get: function () { return chunk3P6O7ZDM_js.renderToCanvas; }
 });
 Object.defineProperty(exports, "defaultCssVars", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.defaultCssVars; }
+  get: function () { return chunkJWS3RQKN_js.defaultCssVars; }
 });
 Object.defineProperty(exports, "defaultRadius", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.defaultRadius; }
+  get: function () { return chunkJWS3RQKN_js.defaultRadius; }
 });
 Object.defineProperty(exports, "defaultThemeColors", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.defaultThemeColors; }
+  get: function () { return chunkJWS3RQKN_js.defaultThemeColors; }
 });
 Object.defineProperty(exports, "themeToCssVars", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.themeToCssVars; }
+  get: function () { return chunkJWS3RQKN_js.themeToCssVars; }
 });
 Object.defineProperty(exports, "vermilionDarkColors", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.vermilionDarkColors; }
+  get: function () { return chunkJWS3RQKN_js.vermilionDarkColors; }
 });
 Object.defineProperty(exports, "vermilionDarkTheme", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.vermilionDarkTheme; }
+  get: function () { return chunkJWS3RQKN_js.vermilionDarkTheme; }
 });
 Object.defineProperty(exports, "vermilionLightColors", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.vermilionLightColors; }
+  get: function () { return chunkJWS3RQKN_js.vermilionLightColors; }
 });
 Object.defineProperty(exports, "vermilionLightTheme", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.vermilionLightTheme; }
+  get: function () { return chunkJWS3RQKN_js.vermilionLightTheme; }
 });
 Object.defineProperty(exports, "vermilionRadius", {
   enumerable: true,
-  get: function () { return chunkTLGPM7SI_js.vermilionRadius; }
+  get: function () { return chunkJWS3RQKN_js.vermilionRadius; }
 });

package/dist/index.mjs

@@ -1,6 +1,6 @@
-export { PowerPointViewer, ViewerThemeProvider, useViewerTheme } from './chunk-YW23L4KK.mjs';
-export { getAnimationInitialStyle, renderToCanvas } from './chunk-XOSQDCHZ.mjs';
-export { defaultCssVars, defaultRadius, defaultThemeColors, themeToCssVars, vermilionDarkColors, vermilionDarkTheme, vermilionLightColors, vermilionLightTheme, vermilionRadius } from './chunk-YARAQWA4.mjs';
+export { PowerPointViewer, ViewerThemeProvider, useViewerTheme } from './chunk-LNSHC2Z5.mjs';
+export { getAnimationInitialStyle, renderToCanvas } from './chunk-LLHFNGAF.mjs';
+export { defaultCssVars, defaultRadius, defaultThemeColors, themeToCssVars, vermilionDarkColors, vermilionDarkTheme, vermilionLightColors, vermilionLightTheme, vermilionRadius } from './chunk-G22EWPLH.mjs';
 import './chunk-HJQZJ3VE.mjs';
-import './chunk-AJPW5FS7.mjs';
+import './chunk-XRYREYXC.mjs';
 import './chunk-6DZX6EAA.mjs';

package/dist/types-BK7Nt13M.d.ts

@@ -0,0 +1,483 @@
+import { ConnectorArrowType, PptxAnimationPreset, PptxElement, PptxElementAnimation, PptxSlide, PptxSlideTransition, ShapeStyle, StrokeDashType, XmlObject } from "pptx-viewer-core";
+import { CollaborationConfig as CollaborationConfig$1, CollaborationRole, ElementClipboardPayload, PowerPointViewerAPI, ViewerFontSource, ViewerMode as ViewerMode$1, ViewerTheme, ViewerThemeColors, defaultCssVars, defaultRadius, defaultThemeColors, themeToCssVars, vermilionDarkColors, vermilionDarkTheme, vermilionLightColors, vermilionLightTheme, vermilionRadius } from "pptx-viewer-shared";
+import React$1 from "react";
+import { Doc } from "yjs";
+//#region src/viewer/types-core.d.ts
+/**
+ * Union of all shape preset types that the viewer can insert or render.
+ * Maps to OOXML `a:prstGeom` preset values (e.g. "rect", "ellipse").
+ * Includes basic shapes, arrows, connectors, and freeform paths.
+ */
+type SupportedShapeType = 'rect' | 'roundRect' | 'ellipse' | 'triangle' | 'rtTriangle' | 'diamond' | 'cylinder' | 'parallelogram' | 'trapezoid' | 'pentagon' | 'hexagon' | 'octagon' | 'chevron' | 'star5' | 'star6' | 'star8' | 'plus' | 'heart' | 'cloud' | 'sun' | 'moon' | 'pie' | 'plaque' | 'teardrop' | 'line' | 'rtArrow' | 'leftArrow' | 'upArrow' | 'downArrow' | 'connector' | 'freeform';
+/**
+ * Connector geometry presets corresponding to OOXML `a:prstGeom` connector types.
+ * Determines the routing style (straight, bent with N segments, or curved).
+ */
+type ConnectorGeometryType = 'straightConnector1' | 'bentConnector2' | 'bentConnector3' | 'bentConnector4' | 'bentConnector5' | 'curvedConnector2' | 'curvedConnector3' | 'curvedConnector4' | 'curvedConnector5';
+/** The pixel dimensions of the slide canvas (presentation slide size). */
+interface CanvasSize {
+  /** Width of the canvas in CSS pixels. */
+  width: number;
+  /** Height of the canvas in CSS pixels. */
+  height: number;
+}
+/**
+ * Tracks the state of an ongoing element drag operation.
+ * Created on pointer-down and destroyed on pointer-up.
+ * During the drag, position changes are applied directly to DOM elements
+ * for performance (bypassing React state) and committed to state on completion.
+ */
+interface DragState {
+  /** ID of the primary element being dragged. */
+  elementId: string;
+  /** Client X coordinate at the start of the drag. */
+  startClientX: number;
+  /** Client Y coordinate at the start of the drag. */
+  startClientY: number;
+  /** Original positions of all selected elements, keyed by element ID. */
+  startPositionsById: Record<string, {
+    x: number;
+    y: number;
+  }>;
+  /** DOM elements cached at drag-start to avoid per-frame querySelector calls. */
+  domEls: Map<string, HTMLElement>;
+  /** Whether the pointer has actually moved since the drag started. */
+  moved: boolean;
+  /** Accumulated delta, stored during DOM-only drag, committed on pointerup. */
+  lastDx: number;
+  lastDy: number;
+}
+/** Handle used as the resize anchor point (corners + edge midpoints). */
+type ResizeHandle = 'nw' | 'ne' | 'sw' | 'se' | 'n' | 's' | 'e' | 'w';
+/**
+ * Tracks the state of an ongoing element resize operation.
+ * Uses direct DOM manipulation during the resize for performance,
+ * then commits the final geometry to React state on pointer-up.
+ */
+interface ResizeState {
+  /** ID of the element being resized. */
+  elementId: string;
+  /** Client X coordinate at the start of the resize. */
+  startClientX: number;
+  /** Client Y coordinate at the start of the resize. */
+  startClientY: number;
+  /** Original X position of the element. */
+  startX: number;
+  /** Original Y position of the element. */
+  startY: number;
+  /** Original width of the element. */
+  startWidth: number;
+  /** Original height of the element. */
+  startHeight: number;
+  /** Which handle initiated the resize. */
+  handle: ResizeHandle;
+  /** Whether the pointer has actually moved since the resize started. */
+  moved: boolean;
+  /** DOM element cached at resize-start to avoid per-frame querySelector calls. */
+  domEl: HTMLElement | null;
+  /** Accumulated final geometry, committed on pointerup. */
+  lastX: number;
+  lastY: number;
+  lastWidth: number;
+  lastHeight: number;
+}
+/**
+ * Describes the position and value of a shape adjustment handle (yellow diamond).
+ * Adjustment handles allow users to modify shape parameters like corner radius,
+ * arrow width, etc. without a full resize.
+ */
+interface ShapeAdjustmentHandleDescriptor {
+  key: string;
+  left: number;
+  top: number;
+  value: number;
+  cursor: string;
+}
+/**
+ * Tracks the state of an ongoing shape adjustment handle drag.
+ * Used when the user drags the yellow diamond handle to alter
+ * shape-specific parameters (e.g. corner radius on a rounded rectangle).
+ */
+interface ShapeAdjustmentDragState {
+  elementId: string;
+  key: string;
+  shapeType: string;
+  startClientX: number;
+  startClientY: number;
+  startAdjustment: number;
+  startWidth: number;
+  startHeight: number;
+  moved: boolean;
+}
+/**
+ * A snapshot of editor state captured for undo/redo history.
+ * Contains the full slide deck state at a point in time so that
+ * any editing operation can be reverted or replayed.
+ */
+interface EditorHistorySnapshot {
+  width: number;
+  height: number;
+  activeSlideIndex: number;
+  slides: PptxSlide[];
+  templateElementsBySlideId: Record<string, PptxElement[]>;
+  actionLabel?: string;
+}
+/** Axis-aligned bounding box for an element, used for hit-testing and alignment. */
+interface ElementBounds {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+/**
+ * Geometry data for rendering a connector line as an SVG path.
+ * Includes start/end coordinates, the SVG path data string,
+ * and optional marker (arrowhead) identifiers.
+ */
+interface ConnectorPathGeometry {
+  startX: number;
+  startY: number;
+  endX: number;
+  endY: number;
+  pathData: string;
+  d?: string;
+  viewBox?: string;
+  startMarkerId?: string;
+  endMarkerId?: string;
+}
+/** A named preset shape style used in the Quick Styles gallery. */
+interface ShapeQuickStyle {
+  name: string;
+  style: Partial<ShapeStyle>;
+}
+//#endregion
+//#region src/theme/context.d.ts
+interface ViewerThemeProviderProps {
+  theme?: ViewerTheme;
+  children: React.ReactNode;
+}
+/**
+ * Provides a `ViewerTheme` to all descendant viewer components.
+ *
+ * Typically you do **not** need to use this directly; passing a `theme`
+ * prop to `<PowerPointViewer>` is sufficient. This provider is exposed
+ * for advanced use-cases where you want to wrap multiple viewers or
+ * share a theme across a wider subtree.
+ */
+declare function ViewerThemeProvider({ theme, children }: ViewerThemeProviderProps): import("react").JSX.Element;
+/**
+ * Returns the active `ViewerTheme` (if any) from the nearest
+ * `ViewerThemeProvider`.
+ */
+declare function useViewerTheme(): ViewerTheme | undefined;
+//#endregion
+//#region src/viewer/hooks/collaboration/types.d.ts
+/** Connection lifecycle states for the Yjs WebSocket provider. */
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+/**
+ * Presence data broadcast to other participants.
+ * Cursor position is relative to the slide canvas (0..canvasWidth, 0..canvasHeight).
+ */
+interface UserPresence {
+  /** Unique client ID (assigned by Yjs awareness). */
+  clientId: number;
+  /** Sanitised display name. */
+  userName: string;
+  /** Optional avatar URL (validated). */
+  userAvatar?: string;
+  /** Hex colour for the user's cursor ring. */
+  userColor: string;
+  /** Slide index the user is currently viewing. */
+  activeSlideIndex: number;
+  /** Cursor X on the canvas (clamped to slide bounds). */
+  cursorX: number;
+  /** Cursor Y on the canvas (clamped to slide bounds). */
+  cursorY: number;
+  /** ISO timestamp of last update (for stale-presence cleanup). */
+  lastUpdated: string;
+  /** Optional currently selected element ID. */
+  selectedElementId?: string;
+  /** Role in the session (owner, viewer, or collaborator). */
+  role?: CollaborationRole;
+}
+/** Value exposed by `CollaborationContext`. */
+interface CollaborationContextValue {
+  /** Current WebSocket connection status. */
+  status: ConnectionStatus;
+  /** Presence data for all remote users (excludes the local user). */
+  remoteUsers: UserPresence[];
+  /** Broadcast the local user's presence state. */
+  broadcastPresence: (update: Partial<Omit<UserPresence, 'clientId'>>) => void;
+  /** Total number of connected users (including local). */
+  connectedCount: number;
+  /** The collaboration config that was provided. */
+  config: CollaborationConfig$1;
+  /** The Yjs document (for document sync). */
+  doc: Doc | null;
+  /**
+   * Whether the provider completed its initial document sync (or the
+   * first-write grace period elapsed). Local doc writes are gated on this.
+   */
+  synced: boolean;
+  /** Manually retry the WebSocket connection after a timeout or error. */
+  retry: () => void;
+}
+//#endregion
+//#region src/viewer/types-ui.d.ts
+/**
+ * Base handle interface for file viewer components.
+ * Defined locally to avoid dependency on external file-viewer plugin packages.
+ * Provides a standard `getContent` method used by the host application to
+ * retrieve the current file content (e.g. for saving).
+ */
+interface FileViewerHandle {
+  /** Get the current content of the file (for saving) */
+  getContent: () => Promise<string | Uint8Array>;
+}
+/** A shape preset entry used in the toolbar shape insertion palette. */
+interface ShapePreset {
+  type: SupportedShapeType;
+  label: string;
+  icon: React$1.ReactNode;
+}
+/** Tracks the position and target element of an open context menu. */
+interface ElementContextMenuState {
+  x: number;
+  y: number;
+  elementId: string;
+}
+/** Identifies an action triggered from the element right-click context menu. */
+type ElementContextMenuAction = 'copy' | 'cut' | 'paste' | 'duplicate' | 'delete' | 'bring-forward' | 'send-backward' | 'bring-front' | 'send-back' | 'bringForward' | 'sendBackward' | 'bringToFront' | 'sendToBack' | 'comment' | 'addComment' | 'group' | 'ungroup' | 'editPoints' | 'editHyperlink';
+/**
+ * State of an active marquee (rubber-band) selection rectangle.
+ * Created when the user clicks and drags on the canvas background,
+ * and used to compute which elements fall within the selection area.
+ */
+interface MarqueeSelectionState {
+  startX: number;
+  startY: number;
+  currentX: number;
+  currentY: number;
+  additive: boolean;
+  baseSelectionIds?: string[];
+}
+/** Tracks which table cell is selected and/or actively being edited. */
+interface TableCellEditorState {
+  rowIndex: number;
+  columnIndex: number;
+  /** When true the cell has an active text input. */
+  isEditing?: boolean;
+  /** Optional multi-cell selection (Shift+Click range). Each entry is {row, col}. */
+  selectedCells?: Array<{
+    row: number;
+    col: number;
+  }>;
+}
+/** A single parsed table cell with its position, text content, and computed CSS style. */
+interface ParsedTableCell {
+  rowIndex: number;
+  columnIndex: number;
+  text: string;
+  style: React$1.CSSProperties;
+  rawCell: XmlObject;
+}
+/** Complete parsed table data including row/column structure and all cells. */
+interface ParsedTableData {
+  rowCount: number;
+  columnCount: number;
+  rows: XmlObject[];
+  columnPercentages: number[];
+  cells: ParsedTableCell[];
+}
+/** Runtime state for a single element's animation during presentation mode. */
+interface PresentationAnimationRuntime {
+  elementId: string;
+  state: 'hidden' | 'entering' | 'visible';
+  animation: PptxElementAnimation;
+}
+/**
+ * Groups slides into named sections for the slides pane sidebar.
+ * Corresponds to OOXML `p15:section` elements in `presentation.xml`.
+ */
+interface SlideSectionGroup {
+  id: string;
+  label: string;
+  slideIndexes: number[];
+  /** Section highlight color from p15:sectionPr. */
+  color?: string;
+  /** Whether the section should start collapsed (from p15:sectionPr). */
+  defaultCollapsed?: boolean;
+}
+/** Alignment direction for distributing/aligning multiple selected elements on the slide. */
+type SlideAlignment = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
+/** Identifies one of the ribbon-style toolbar tabs (home, insert, text, etc.). */
+type ToolbarSection = 'file' | 'home' | 'insert' | 'text' | 'arrange' | 'draw' | 'design' | 'transitions' | 'animations' | 'slideShow' | 'record' | 'review' | 'view' | 'help';
+/** The active drawing/inking tool selected in the Draw toolbar tab. */
+type DrawingTool = 'select' | 'pen' | 'highlighter' | 'eraser' | 'freeform';
+/** A single entry in the keyboard shortcuts help panel. */
+interface ShortcutReferenceItem {
+  actionKey: string;
+  shortcut: string;
+}
+/** An accessibility audit finding (missing alt text, reading order issues, etc.). */
+interface AccessibilityIssue {
+  slideIndex: number;
+  elementId?: string;
+  severity: 'error' | 'warning' | 'info';
+  message: string;
+}
+/** Dropdown option for selecting a connector geometry type. */
+interface ConnectorGeometryOption {
+  value: ConnectorGeometryType;
+  label: string;
+}
+/** Dropdown option for selecting a connector arrowhead style. */
+interface ConnectorArrowOption {
+  value: ConnectorArrowType;
+  label: string;
+}
+/** Dropdown option for selecting a stroke dash pattern. */
+interface StrokeDashOption {
+  value: StrokeDashType;
+  label: string;
+}
+/** Dropdown option for selecting a slide transition type. */
+interface SlideTransitionOption {
+  value: NonNullable<PptxSlideTransition['type']>;
+  label: string;
+}
+/** Dropdown option for selecting an animation effect preset. */
+interface AnimationPresetOption {
+  value: Exclude<PptxAnimationPreset, 'none'>;
+  label: string;
+}
+interface PowerPointViewerProps {
+  /** PowerPoint content as Uint8Array */
+  content: Uint8Array;
+  /** Licensed fonts supplied by the host application. No fonts are bundled. */
+  fonts?: ViewerFontSource[];
+  /** Original file path, used for autosave recovery */
+  filePath?: string;
+  /**
+   * Display name of the open document, shown in the PowerPoint-style title
+   * bar (e.g. "quarterly-review.pptx"). Falls back to a generic label.
+   */
+  fileName?: string;
+  /** Callback when content has unsaved changes */
+  onDirtyChange?: (isDirty: boolean) => void;
+  onContentChange?: (content: Uint8Array) => void;
+  /** Callback when active slide changes */
+  onActiveSlideChange?: (slideIndex: number) => void;
+  /** Callback when the viewer mode changes (e.g. edit to present). */
+  onModeChange?: (mode: import('pptx-viewer-shared').ViewerMode) => void;
+  /** Callback when the zoom level changes. */
+  onZoomChange?: (zoom: number) => void;
+  /** Callback when element selection changes. */
+  onSelectionChange?: (elementIds: string[]) => void;
+  /** Callback when the total slide count changes (slide added/deleted). */
+  onSlideCountChange?: (count: number) => void;
+  /**
+   * Host override for the File ▸ Open action. When provided, the built-in
+   * native file picker is bypassed and this is invoked instead; the host is
+   * then responsible for supplying a new `content` buffer. When omitted, the
+   * viewer opens its own picker and loads the chosen presentation in place.
+   */
+  onOpenFile?: () => void;
+  /** Whether editing actions are enabled */
+  canEdit?: boolean;
+  /** Optional class name */
+  className?: string;
+  /**
+   * Display name used as the author for comments and annotations.
+   * Falls back to `collaboration.userName` when collaborating, or `'You'`.
+   */
+  authorName?: string;
+  /**
+   * Theme configuration for customising the viewer's appearance.
+   *
+   * Accepts partial color overrides, a custom border-radius, and
+   * arbitrary CSS custom properties. Unset values fall back to the
+   * built-in dark theme.
+   *
+   * @example
+   * ```tsx
+   * <PowerPointViewer
+   *   content={bytes}
+   *   theme={{
+   *     colors: { primary: "#6366f1", background: "#0f172a" },
+   *     radius: "0.75rem",
+   *   }}
+   * />
+   * ```
+   *
+   * @see {@link ViewerTheme} for the full type definition.
+   */
+  theme?: ViewerTheme;
+  /**
+   * Optional real-time collaboration configuration.
+   *
+   * When provided, the viewer enables collaborative editing with live
+   * cursors, user presence indicators, and CRDT-based state sync via Yjs.
+   * Requires `yjs` and `y-websocket` peer dependencies.
+   *
+   * @example
+   * ```tsx
+   * <PowerPointViewer
+   *   content={bytes}
+   *   collaboration={{
+   *     roomId: "my-room-123",
+   *     serverUrl: "wss://collab.example.com",
+   *     userName: "Alice",
+   *     userColor: "#6366f1",
+   *   }}
+   * />
+   * ```
+   */
+  collaboration?: CollaborationConfig$1;
+  /**
+   * Callback invoked when the user starts a collaboration session from the
+   * Share dialog. The host app should use this to set the `collaboration`
+   * prop with the returned config.
+   */
+  onStartCollaboration?: (config: CollaborationConfig$1) => void;
+  /**
+   * Callback invoked when the user stops a collaboration session from the
+   * Share dialog. The host app should clear the `collaboration` prop.
+   */
+  onStopCollaboration?: () => void;
+  /**
+   * Default values for the Share dialog fields. The host app should provide
+   * these to control the session name, user display name, and server URL.
+   * If omitted, the Share dialog fields will be empty and require user input.
+   *
+   * @example
+   * ```tsx
+   * <PowerPointViewer
+   *   shareDefaults={{
+   *     roomId: "session-abc123",
+   *     userName: "Alice",
+   *     serverUrl: "ws://localhost:1234",
+   *   }}
+   * />
+   * ```
+   */
+  shareDefaults?: {
+    roomId?: string;
+    userName?: string;
+    serverUrl?: string;
+  };
+  /**
+   * Opt in to the experimental Three.js SmartArt renderer. When `true`,
+   * SmartArt diagrams render as extruded 3D blocks on a WebGL canvas instead
+   * of flat SVG. Requires the optional `three` peer dependency; when it is not
+   * installed (or the diagram has no geometry), the viewer transparently falls
+   * back to the SVG `SmartArtRenderer`. Default `false`.
+   */
+  smartArt3D?: boolean;
+}
+interface PowerPointViewerHandle extends FileViewerHandle, PowerPointViewerAPI {
+  getContent: () => Promise<Uint8Array>;
+}
+//#endregion
+export { SupportedShapeType as $, defaultCssVars as A, ViewerThemeColors as B, CollaborationConfig$1 as C, UserPresence as D, ConnectionStatus as E, vermilionLightTheme as F, EditorHistorySnapshot as G, ConnectorGeometryType as H, vermilionRadius as I, ResizeHandle as J, ElementBounds as K, defaultRadius as L, vermilionDarkColors as M, vermilionDarkTheme as N, ViewerThemeProvider as O, vermilionLightColors as P, ShapeQuickStyle as Q, defaultThemeColors as R, ToolbarSection as S, CollaborationRole as T, ConnectorPathGeometry as U, CanvasSize as V, DragState as W, ShapeAdjustmentDragState as X, ResizeState as Y, ShapeAdjustmentHandleDescriptor as Z, SlideAlignment as _, DrawingTool as a, StrokeDashOption as b, FileViewerHandle as c, ParsedTableData as d, ViewerMode$1 as et, PowerPointViewerHandle as f, ShortcutReferenceItem as g, ShapePreset as h, ConnectorGeometryOption as i, themeToCssVars as j, useViewerTheme as k, MarqueeSelectionState as l, PresentationAnimationRuntime as m, AnimationPresetOption as n, ElementContextMenuAction as o, PowerPointViewerProps as p, ElementClipboardPayload as q, ConnectorArrowOption as r, ElementContextMenuState as s, AccessibilityIssue as t, ParsedTableCell as u, SlideSectionGroup as v, CollaborationContextValue as w, TableCellEditorState as x, SlideTransitionOption as y, ViewerTheme as z };
+//# sourceMappingURL=types-BK7Nt13M.d.ts.map

package/dist/types-BK7Nt13M.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BK7Nt13M.d.ts","names":[],"sources":["../src/viewer/types-core.ts","../src/theme/context.tsx","../src/viewer/hooks/collaboration/types.ts","../src/viewer/types-ui.ts"],"mappings":";;;;;;;;;;KA+BY;;;;;KAqCA;;UAgBK;;EAEhB;;EAEA;;;;;;;;UAagB;;EAEhB;;EAEA;;EAEA;;EAEA,oBAAoB;IAAiB;IAAW;;;EAEhD,QAAQ,YAAY;;EAEpB;;EAEA;EACA;;;KAIW;;;;;;UAOK;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,QAAQ;;EAER;;EAEA,OAAO;;EAEP;EACA;EACA;EACA;;;;;;;UAQgB;EAChB;EACA;EACA;EACA;EACA;;;;;;;UAQgB;EAChB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;UAoBgB;EAChB;EACA;EACA;EACA,QAAQ;EACR,2BAA2B,eAAe;EAC1C;;;UAQgB;EAChB;EACA;EACA;EACA;;;;;;;UAQgB;EAChB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;UAQgB;EAChB;EACA,OAAO,QAAQ;;;;UCxOC;EAChB,QAAQ;EACR,UAAU,MAAM;;;;;;;;;;iBAWD,sBAAsB,OAAO,YAAY,2CAAwB,IAAA;;;;;iBAYjE,kBAAkB;;;;KCOtB;;;;;UAUK;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,OAAO;;;UAQS;;EAEhB,QAAQ;;EAER,aAAa;;EAEb,oBAAoB,QAAQ,QAAQ,KAAK;;EAEzC;;EAEA,QAAQ;;EAER,KAAK;;;;;EAKL;;EAEA;;;;;;;;;;UC7EgB;;EAEhB,kBAAkB,iBAAiB;;;UAQnB;EAChB,MAAM;EACN;EACA,MAAM,QAAM;;;UAQI;EAChB;EACA;EACA;;;KAIW;;;;;;UA8BK;EAChB;EACA;EACA;EACA;EACA;EACA;;;UAQgB;EAChB;EACA;;EAEA;;EAEA,gBAAgB;IAAQ;IAAa;;;;UAIrB;EAChB;EACA;EACA;EACA,OAAO,QAAM;EACb,SAAS;;;UAIO;EAChB;EACA;EACA,MAAM;EACN;EACA,OAAO;;;UAQS;EAChB;EACA;EACA,WAAW;;;;;;UAWK;EAChB;EACA;EACA;;EAEA;;EAEA;;;KAQW;;KAGA;;KAiBA;;UAOK;EAChB;EACA;;;UAIgB;EAChB;EACA;EACA;EACA;;;UAQgB;EAChB,OAAO;EACP;;;UAIgB;EAChB,OAAO;EACP;;;UAIgB;EAChB,OAAO;EACP;;;UAIgB;EAChB,OAAO,YAAY;EACnB;;;UAIgB;EAChB,OAAO,QAAQ;EACf;;UAOgB;;EAEhB,SAAS;;EAET,QAAQ;;EAER;;;;;EAKA;;EAEA,iBAAiB;EACjB,mBAAmB,SAAS;;EAE5B,uBAAuB;;EAEvB,gBAAgB,mCAAmC;;EAEnD,gBAAgB;;EAEhB,qBAAqB;;EAErB,sBAAsB;;;;;;;EAOtB;;EAGA;;EAEA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;EAsBA,QAlD4B;;;;;;;;;;;;;;;;;;;;;EAwE5B,gBAAgB;;;;;;EAOhB,wBAAwB,QAAQ;;;;;EAMhC;;;;;;;;;;;;;;;;;EAkBA;IACC;IACA;IACA;;;;;;;;;EAUD;;UAGgB,+BAA+B,kBAAkB;EACjE,kBAAkB,QAAQ"}