@pixerate/editor-react 0.41.0 → 0.42.0

package/dist/canvas/index.cjs

@@ -20,317 +20,318 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/canvas/index.ts
 var canvas_exports = {};
 __export(canvas_exports, {
-  ANIMATABLE_PROPERTIES: () => import_canvas28.ANIMATABLE_PROPERTIES,
-  ANIMATION_DATA_KEY: () => import_canvas28.ANIMATION_DATA_KEY,
-  ANIMATION_EASING_LABELS: () => import_canvas28.ANIMATION_EASING_LABELS,
-  ANIMATION_EASING_PRESETS: () => import_canvas28.ANIMATION_EASING_PRESETS,
-  ANIMATION_TIME_EPSILON: () => import_canvas28.ANIMATION_TIME_EPSILON,
-  AUTO_LAYOUT_DATA_KEY: () => import_canvas26.AUTO_LAYOUT_DATA_KEY,
+  ANIMATABLE_PROPERTIES: () => import_canvas29.ANIMATABLE_PROPERTIES,
+  ANIMATION_DATA_KEY: () => import_canvas29.ANIMATION_DATA_KEY,
+  ANIMATION_EASING_LABELS: () => import_canvas29.ANIMATION_EASING_LABELS,
+  ANIMATION_EASING_PRESETS: () => import_canvas29.ANIMATION_EASING_PRESETS,
+  ANIMATION_TIME_EPSILON: () => import_canvas29.ANIMATION_TIME_EPSILON,
+  AUTO_LAYOUT_DATA_KEY: () => import_canvas27.AUTO_LAYOUT_DATA_KEY,
   AgentPresenceLayer: () => AgentPresenceLayer,
-  AnimationEditError: () => import_canvas28.AnimationEditError,
-  AnimationPlayer: () => import_canvas28.AnimationPlayer,
+  AnimationEditError: () => import_canvas29.AnimationEditError,
+  AnimationPlayer: () => import_canvas29.AnimationPlayer,
   AnimationTimeline: () => AnimationTimeline,
-  CANVAS_COMPONENT_DRAG_TYPE: () => import_canvas29.CANVAS_COMPONENT_DRAG_TYPE,
-  CANVAS_GRADIENT_PRESETS: () => import_canvas29.CANVAS_GRADIENT_PRESETS,
-  CANVAS_TOKEN_PROPERTIES: () => import_canvas27.CANVAS_TOKEN_PROPERTIES,
-  CHILD_LAYOUT_DATA_KEY: () => import_canvas26.CHILD_LAYOUT_DATA_KEY,
-  CONNECTION_LINE_TYPES: () => import_canvas22.CONNECTION_LINE_TYPES,
-  CSS_ANIMATION_PROPERTIES: () => import_canvas28.CSS_ANIMATION_PROPERTIES,
-  CUBIC_BEZIER_PRESETS: () => import_canvas28.CUBIC_BEZIER_PRESETS,
+  CANVAS_COMPONENT_DRAG_TYPE: () => import_canvas30.CANVAS_COMPONENT_DRAG_TYPE,
+  CANVAS_GRADIENT_PRESETS: () => import_canvas30.CANVAS_GRADIENT_PRESETS,
+  CANVAS_TOKEN_PROPERTIES: () => import_canvas28.CANVAS_TOKEN_PROPERTIES,
+  CHILD_LAYOUT_DATA_KEY: () => import_canvas27.CHILD_LAYOUT_DATA_KEY,
+  CONNECTION_LINE_TYPES: () => import_canvas23.CONNECTION_LINE_TYPES,
+  CSS_ANIMATION_PROPERTIES: () => import_canvas29.CSS_ANIMATION_PROPERTIES,
+  CUBIC_BEZIER_PRESETS: () => import_canvas29.CUBIC_BEZIER_PRESETS,
   CanvasComponentsPanel: () => CanvasComponentsPanel,
   CanvasDrawLayer: () => CanvasDrawLayer,
   CanvasGuidesLayer: () => CanvasGuidesLayer,
   CanvasInstanceInspector: () => CanvasInstanceInspector,
-  CanvasScenesStore: () => import_canvas22.CanvasScenesStore,
-  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas22.DEFAULT_ARRANGE_SHORTCUTS,
+  CanvasScenesStore: () => import_canvas23.CanvasScenesStore,
+  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas23.DEFAULT_ARRANGE_SHORTCUTS,
   DiagramPresenceLayer: () => DiagramPresenceLayer,
-  MAX_KEYFRAME_REFS: () => import_canvas28.MAX_KEYFRAME_REFS,
-  ManualClock: () => import_canvas25.ManualClock,
+  MAX_KEYFRAME_REFS: () => import_canvas29.MAX_KEYFRAME_REFS,
+  ManualClock: () => import_canvas26.ManualClock,
   MermaidDiagramGroup: () => MermaidDiagramGroup,
   MermaidDiagramNode: () => MermaidDiagramNode,
-  RESIZE_HANDLES: () => import_canvas21.RESIZE_HANDLES,
-  SHAPE_DATA_KEY: () => import_canvas23.SHAPE_DATA_KEY,
-  SHAPE_KINDS: () => import_canvas23.SHAPE_KINDS,
-  SHAPE_NODE_TYPE: () => import_canvas23.SHAPE_NODE_TYPE,
-  SHAPE_OPERATIONS: () => import_canvas23.SHAPE_OPERATIONS,
+  MermaidThumbnail: () => MermaidThumbnail,
+  RESIZE_HANDLES: () => import_canvas22.RESIZE_HANDLES,
+  SHAPE_DATA_KEY: () => import_canvas24.SHAPE_DATA_KEY,
+  SHAPE_KINDS: () => import_canvas24.SHAPE_KINDS,
+  SHAPE_NODE_TYPE: () => import_canvas24.SHAPE_NODE_TYPE,
+  SHAPE_OPERATIONS: () => import_canvas24.SHAPE_OPERATIONS,
   ShapeNode: () => ShapeNode,
-  TOKEN_BINDINGS_DATA_KEY: () => import_canvas27.TOKEN_BINDINGS_DATA_KEY,
-  TOKEN_MODES_DATA_KEY: () => import_canvas27.TOKEN_MODES_DATA_KEY,
+  TOKEN_BINDINGS_DATA_KEY: () => import_canvas28.TOKEN_BINDINGS_DATA_KEY,
+  TOKEN_MODES_DATA_KEY: () => import_canvas28.TOKEN_MODES_DATA_KEY,
   TokenBindingPicker: () => TokenBindingPicker,
   TokenModeSwitcher: () => TokenModeSwitcher,
-  addCanvasVariant: () => import_canvas29.addCanvasVariant,
-  addKeyframesAtTime: () => import_canvas28.addKeyframesAtTime,
-  alignNodes: () => import_canvas22.alignNodes,
-  angleToSvgLinearCoords: () => import_canvas29.angleToSvgLinearCoords,
-  animateNode: () => import_canvas28.animateNode,
-  applyAnimation: () => import_canvas28.applyAnimation,
-  applyAnimationOverrides: () => import_canvas28.applyAnimationOverrides,
-  applyConstraints: () => import_canvas26.applyConstraints,
-  applyNodeUpdates: () => import_canvas22.applyNodeUpdates,
-  applyShapeCombination: () => import_canvas23.applyShapeCombination,
-  applyShapeReplacement: () => import_canvas24.applyShapeReplacement,
-  bezierPathArea: () => import_canvas24.bezierPathArea,
-  bezierPathBounds: () => import_canvas24.bezierPathBounds,
-  bezierPathLength: () => import_canvas24.bezierPathLength,
-  bezierPathPointAtLength: () => import_canvas24.bezierPathPointAtLength,
-  bezierPathSignedArea: () => import_canvas24.bezierPathSignedArea,
-  bezierPathToSvg: () => import_canvas24.bezierPathToSvg,
-  bindCanvasComponentProperty: () => import_canvas29.bindCanvasComponentProperty,
-  bindCanvasToken: () => import_canvas27.bindCanvasToken,
-  blendLayout: () => import_canvas25.blendLayout,
-  boundsOf: () => import_canvas25.boundsOf,
-  calculateDagreReflowDisplacement: () => import_canvas25.calculateDagreReflowDisplacement,
-  calculateDirectionalDisplacement: () => import_canvas25.calculateDirectionalDisplacement,
-  canCombineShapeNodes: () => import_canvas23.canCombineShapeNodes,
-  canOffsetShapeNodes: () => import_canvas24.canOffsetShapeNodes,
-  canOutlineShapeNodeStrokes: () => import_canvas24.canOutlineShapeNodeStrokes,
-  canvasHeight: () => import_canvas25.canvasHeight,
-  centerNodes: () => import_canvas25.centerNodes,
-  centre: () => import_canvas25.centre,
-  clampAnimationValue: () => import_canvas28.clampAnimationValue,
-  clampLayoutSize: () => import_canvas26.clampLayoutSize,
-  combineCanvasComponentsAsVariants: () => import_canvas29.combineCanvasComponentsAsVariants,
-  combineShapeNodes: () => import_canvas23.combineShapeNodes,
-  computeNodesBoundingBox: () => import_canvas25.computeNodesBoundingBox,
-  computeSnapGuides: () => import_canvas22.computeSnapGuides,
-  connectedOnly: () => import_canvas25.connectedOnly,
-  copyKeyframes: () => import_canvas28.copyKeyframes,
-  countPathSegments: () => import_canvas24.countPathSegments,
-  createAnimationPlayer: () => import_canvas28.createAnimationPlayer,
-  createBezierTrajectory: () => import_canvas25.createBezierTrajectory,
-  createCanvasAnimationController: () => import_canvas28.createCanvasAnimationController,
-  createCanvasAutoLayoutController: () => import_canvas26.createCanvasAutoLayoutController,
-  createCanvasComponent: () => import_canvas29.createCanvasComponent,
-  createCanvasComponentsController: () => import_canvas29.createCanvasComponentsController,
-  createCanvasDrawController: () => import_canvas29.createCanvasDrawController,
-  createCanvasInstance: () => import_canvas29.createCanvasInstance,
-  createCanvasScenesStore: () => import_canvas22.createCanvasScenesStore,
-  createDefaultStrokeStyle: () => import_canvas29.createDefaultStrokeStyle,
-  createFanOutTrajectory: () => import_canvas25.createFanOutTrajectory,
-  createGuideIndex: () => import_canvas22.createGuideIndex,
-  createNodeGuideIndex: () => import_canvas22.createNodeGuideIndex,
-  cubicBezierAt: () => import_canvas28.cubicBezierAt,
-  cubicPointAt: () => import_canvas21.cubicPointAt,
-  cubicsToPathData: () => import_canvas21.cubicsToPathData,
-  dashContours: () => import_canvas24.dashContours,
-  defaultEasing: () => import_canvas25.defaultEasing,
-  deleteKeyframes: () => import_canvas28.deleteKeyframes,
-  detachCanvasInstance: () => import_canvas29.detachCanvasInstance,
-  detachTokenBindings: () => import_canvas27.detachTokenBindings,
-  distanceToBezierPath: () => import_canvas24.distanceToBezierPath,
-  distributeNodes: () => import_canvas22.distributeNodes,
-  dividePaths: () => import_canvas24.dividePaths,
-  dividePolygons: () => import_canvas23.dividePolygons,
-  easingFromInfluence: () => import_canvas28.easingFromInfluence,
-  easingLabel: () => import_canvas28.easingLabel,
-  easingToCss: () => import_canvas28.easingToCss,
-  ensureLayout: () => import_canvas25.ensureLayout,
-  estimateCanvasHeight: () => import_canvas25.estimateCanvasHeight,
-  estimateNodeSize: () => import_canvas25.estimateNodeSize,
-  evaluateAnimation: () => import_canvas28.evaluateAnimation,
-  evaluateEasing: () => import_canvas28.evaluateEasing,
-  evaluateTrack: () => import_canvas28.evaluateTrack,
-  excludePaths: () => import_canvas24.excludePaths,
-  exportCssAnimation: () => import_canvas28.exportCssAnimation,
-  findConnectorSnap: () => import_canvas22.findConnectorSnap,
-  findStrokesAtPoint: () => import_canvas29.findStrokesAtPoint,
-  fitCubicRun: () => import_canvas21.fitCubicRun,
-  fitCubics: () => import_canvas21.fitCubics,
-  fitFreehandPath: () => import_canvas21.fitFreehandPath,
-  fitPathData: () => import_canvas21.fitPathData,
-  fitViewportToNodes: () => import_canvas22.fitViewportToNodes,
-  fitViewportToRect: () => import_canvas22.fitViewportToRect,
-  flattenSvgPath: () => import_canvas23.flattenSvgPath,
-  flowSide: () => import_canvas25.flowSide,
-  formatAnimationTime: () => import_canvas28.formatAnimationTime,
-  formatOklab: () => import_canvas28.formatOklab,
-  getAbsolutePosition: () => import_canvas22.getAbsolutePosition,
-  getAnimatableProperty: () => import_canvas28.getAnimatableProperty,
-  getAnimatedProperties: () => import_canvas28.getAnimatedProperties,
-  getAnimatedValue: () => import_canvas28.getAnimatedValue,
-  getAnimationDuration: () => import_canvas28.getAnimationDuration,
-  getAnimationTrack: () => import_canvas28.getAnimationTrack,
-  getAutoLayout: () => import_canvas26.getAutoLayout,
-  getAutoLayoutGrid: () => import_canvas26.getAutoLayoutGrid,
-  getAutoLayoutInsertTarget: () => import_canvas26.getAutoLayoutInsertTarget,
-  getBindableTokenProperties: () => import_canvas27.getBindableTokenProperties,
-  getCanvasComponentDragId: () => import_canvas29.getCanvasComponentDragId,
-  getCanvasTokenProperty: () => import_canvas27.getCanvasTokenProperty,
-  getCenteredNodePosition: () => import_canvas25.getCenteredNodePosition,
-  getChildLayout: () => import_canvas26.getChildLayout,
-  getComponentSourceId: () => import_canvas29.getComponentSourceId,
-  getCssPropertyAnimations: () => import_canvas28.getCssPropertyAnimations,
-  getEffectiveTokenModes: () => import_canvas27.getEffectiveTokenModes,
-  getFlowChildren: () => import_canvas26.getFlowChildren,
-  getInstanceData: () => import_canvas29.getInstanceData,
-  getInstanceStatus: () => import_canvas29.getInstanceStatus,
-  getKeyframeTimes: () => import_canvas28.getKeyframeTimes,
-  getLayoutParent: () => import_canvas26.getLayoutParent,
-  getLayoutSizing: () => import_canvas26.getLayoutSizing,
-  getLayoutedNodes: () => import_canvas25.getLayoutedNodes,
-  getNextVariantValues: () => import_canvas29.getNextVariantValues,
-  getNodeAnimation: () => import_canvas28.getNodeAnimation,
-  getNodeOverrides: () => import_canvas29.getNodeOverrides,
-  getNodeRect: () => import_canvas22.getNodeRect,
-  getNodeShape: () => import_canvas23.getNodeShape,
-  getNodeSize: () => import_canvas22.getNodeSize,
-  getNodeTokenBindings: () => import_canvas27.getNodeTokenBindings,
-  getNodeTokenModes: () => import_canvas27.getNodeTokenModes,
-  getResizingNodeRect: () => import_canvas21.getResizingNodeRect,
-  getShapeRenderData: () => import_canvas23.getShapeRenderData,
-  getShapeSvg: () => import_canvas23.getShapeSvg,
-  getTimelineRows: () => import_canvas28.getTimelineRows,
-  getTimelineTicks: () => import_canvas28.getTimelineTicks,
-  getTokenPropertyScope: () => import_canvas27.getTokenPropertyScope,
-  getTokensForProperty: () => import_canvas27.getTokensForProperty,
-  gradientToSvgDef: () => import_canvas29.gradientToSvgDef,
-  handlePoint: () => import_canvas22.handlePoint,
-  hasVisibleStroke: () => import_canvas24.hasVisibleStroke,
-  inferResizeHandle: () => import_canvas21.inferResizeHandle,
-  inspectCanvasInstance: () => import_canvas29.inspectCanvasInstance,
-  inspectNodeTokens: () => import_canvas27.inspectNodeTokens,
-  interpolateAnimationValue: () => import_canvas28.interpolateAnimationValue,
-  intersectPaths: () => import_canvas24.intersectPaths,
-  intersectPolygons: () => import_canvas23.intersectPolygons,
-  invertNodeUpdates: () => import_canvas22.invertNodeUpdates,
-  isAnimationEasing: () => import_canvas28.isAnimationEasing,
-  isAnimationKeyframe: () => import_canvas28.isAnimationKeyframe,
-  isAutoLayoutFrame: () => import_canvas26.isAutoLayoutFrame,
-  isCanvasComponent: () => import_canvas29.isCanvasComponent,
-  isCanvasComponentSet: () => import_canvas29.isCanvasComponentSet,
-  isCanvasGradient: () => import_canvas29.isCanvasGradient,
-  isCanvasInstance: () => import_canvas29.isCanvasInstance,
-  isCssExportExact: () => import_canvas28.isCssExportExact,
-  isEventFromTextInput: () => import_canvas25.isEventFromTextInput,
-  isKeyframeSelected: () => import_canvas28.isKeyframeSelected,
-  isLocked: () => import_canvas22.isLocked,
-  isMeasureModifierHeld: () => import_canvas21.isMeasureModifierHeld,
-  isNodeAnimated: () => import_canvas28.isNodeAnimated,
-  isShapeDescription: () => import_canvas23.isShapeDescription,
-  isShapeNode: () => import_canvas23.isShapeNode,
-  isStraightCubic: () => import_canvas21.isStraightCubic,
-  isValidCanvasNode: () => import_canvas25.isValidCanvasNode,
-  isValidUrl: () => import_canvas25.isValidUrl,
-  layoutAll: () => import_canvas26.layoutAll,
-  layoutBounds: () => import_canvas25.layoutBounds,
-  layoutFrame: () => import_canvas26.layoutFrame,
-  layoutUp: () => import_canvas26.layoutUp,
-  layoutUpMany: () => import_canvas26.layoutUpMany,
-  linearPositionTrajectory: () => import_canvas25.linearPositionTrajectory,
-  linearTrajectory: () => import_canvas25.linearTrajectory,
-  listCanvasComponents: () => import_canvas29.listCanvasComponents,
-  lockNodes: () => import_canvas22.lockNodes,
-  makeSizingCoherent: () => import_canvas26.makeSizingCoherent,
-  matchArrangeShortcut: () => import_canvas22.matchArrangeShortcut,
-  matchSize: () => import_canvas22.matchSize,
-  measureBetween: () => import_canvas21.measureBetween,
-  measureLabel: () => import_canvas21.measureLabel,
-  measureSelection: () => import_canvas21.measureSelection,
-  measureToLine: () => import_canvas21.measureToLine,
-  mergeNodeUpdates: () => import_canvas26.mergeNodeUpdates,
+  addCanvasVariant: () => import_canvas30.addCanvasVariant,
+  addKeyframesAtTime: () => import_canvas29.addKeyframesAtTime,
+  alignNodes: () => import_canvas23.alignNodes,
+  angleToSvgLinearCoords: () => import_canvas30.angleToSvgLinearCoords,
+  animateNode: () => import_canvas29.animateNode,
+  applyAnimation: () => import_canvas29.applyAnimation,
+  applyAnimationOverrides: () => import_canvas29.applyAnimationOverrides,
+  applyConstraints: () => import_canvas27.applyConstraints,
+  applyNodeUpdates: () => import_canvas23.applyNodeUpdates,
+  applyShapeCombination: () => import_canvas24.applyShapeCombination,
+  applyShapeReplacement: () => import_canvas25.applyShapeReplacement,
+  bezierPathArea: () => import_canvas25.bezierPathArea,
+  bezierPathBounds: () => import_canvas25.bezierPathBounds,
+  bezierPathLength: () => import_canvas25.bezierPathLength,
+  bezierPathPointAtLength: () => import_canvas25.bezierPathPointAtLength,
+  bezierPathSignedArea: () => import_canvas25.bezierPathSignedArea,
+  bezierPathToSvg: () => import_canvas25.bezierPathToSvg,
+  bindCanvasComponentProperty: () => import_canvas30.bindCanvasComponentProperty,
+  bindCanvasToken: () => import_canvas28.bindCanvasToken,
+  blendLayout: () => import_canvas26.blendLayout,
+  boundsOf: () => import_canvas26.boundsOf,
+  calculateDagreReflowDisplacement: () => import_canvas26.calculateDagreReflowDisplacement,
+  calculateDirectionalDisplacement: () => import_canvas26.calculateDirectionalDisplacement,
+  canCombineShapeNodes: () => import_canvas24.canCombineShapeNodes,
+  canOffsetShapeNodes: () => import_canvas25.canOffsetShapeNodes,
+  canOutlineShapeNodeStrokes: () => import_canvas25.canOutlineShapeNodeStrokes,
+  canvasHeight: () => import_canvas26.canvasHeight,
+  centerNodes: () => import_canvas26.centerNodes,
+  centre: () => import_canvas26.centre,
+  clampAnimationValue: () => import_canvas29.clampAnimationValue,
+  clampLayoutSize: () => import_canvas27.clampLayoutSize,
+  combineCanvasComponentsAsVariants: () => import_canvas30.combineCanvasComponentsAsVariants,
+  combineShapeNodes: () => import_canvas24.combineShapeNodes,
+  computeNodesBoundingBox: () => import_canvas26.computeNodesBoundingBox,
+  computeSnapGuides: () => import_canvas23.computeSnapGuides,
+  connectedOnly: () => import_canvas26.connectedOnly,
+  copyKeyframes: () => import_canvas29.copyKeyframes,
+  countPathSegments: () => import_canvas25.countPathSegments,
+  createAnimationPlayer: () => import_canvas29.createAnimationPlayer,
+  createBezierTrajectory: () => import_canvas26.createBezierTrajectory,
+  createCanvasAnimationController: () => import_canvas29.createCanvasAnimationController,
+  createCanvasAutoLayoutController: () => import_canvas27.createCanvasAutoLayoutController,
+  createCanvasComponent: () => import_canvas30.createCanvasComponent,
+  createCanvasComponentsController: () => import_canvas30.createCanvasComponentsController,
+  createCanvasDrawController: () => import_canvas30.createCanvasDrawController,
+  createCanvasInstance: () => import_canvas30.createCanvasInstance,
+  createCanvasScenesStore: () => import_canvas23.createCanvasScenesStore,
+  createDefaultStrokeStyle: () => import_canvas30.createDefaultStrokeStyle,
+  createFanOutTrajectory: () => import_canvas26.createFanOutTrajectory,
+  createGuideIndex: () => import_canvas23.createGuideIndex,
+  createNodeGuideIndex: () => import_canvas23.createNodeGuideIndex,
+  cubicBezierAt: () => import_canvas29.cubicBezierAt,
+  cubicPointAt: () => import_canvas22.cubicPointAt,
+  cubicsToPathData: () => import_canvas22.cubicsToPathData,
+  dashContours: () => import_canvas25.dashContours,
+  defaultEasing: () => import_canvas26.defaultEasing,
+  deleteKeyframes: () => import_canvas29.deleteKeyframes,
+  detachCanvasInstance: () => import_canvas30.detachCanvasInstance,
+  detachTokenBindings: () => import_canvas28.detachTokenBindings,
+  distanceToBezierPath: () => import_canvas25.distanceToBezierPath,
+  distributeNodes: () => import_canvas23.distributeNodes,
+  dividePaths: () => import_canvas25.dividePaths,
+  dividePolygons: () => import_canvas24.dividePolygons,
+  easingFromInfluence: () => import_canvas29.easingFromInfluence,
+  easingLabel: () => import_canvas29.easingLabel,
+  easingToCss: () => import_canvas29.easingToCss,
+  ensureLayout: () => import_canvas26.ensureLayout,
+  estimateCanvasHeight: () => import_canvas26.estimateCanvasHeight,
+  estimateNodeSize: () => import_canvas26.estimateNodeSize,
+  evaluateAnimation: () => import_canvas29.evaluateAnimation,
+  evaluateEasing: () => import_canvas29.evaluateEasing,
+  evaluateTrack: () => import_canvas29.evaluateTrack,
+  excludePaths: () => import_canvas25.excludePaths,
+  exportCssAnimation: () => import_canvas29.exportCssAnimation,
+  findConnectorSnap: () => import_canvas23.findConnectorSnap,
+  findStrokesAtPoint: () => import_canvas30.findStrokesAtPoint,
+  fitCubicRun: () => import_canvas22.fitCubicRun,
+  fitCubics: () => import_canvas22.fitCubics,
+  fitFreehandPath: () => import_canvas22.fitFreehandPath,
+  fitPathData: () => import_canvas22.fitPathData,
+  fitViewportToNodes: () => import_canvas23.fitViewportToNodes,
+  fitViewportToRect: () => import_canvas23.fitViewportToRect,
+  flattenSvgPath: () => import_canvas24.flattenSvgPath,
+  flowSide: () => import_canvas26.flowSide,
+  formatAnimationTime: () => import_canvas29.formatAnimationTime,
+  formatOklab: () => import_canvas29.formatOklab,
+  getAbsolutePosition: () => import_canvas23.getAbsolutePosition,
+  getAnimatableProperty: () => import_canvas29.getAnimatableProperty,
+  getAnimatedProperties: () => import_canvas29.getAnimatedProperties,
+  getAnimatedValue: () => import_canvas29.getAnimatedValue,
+  getAnimationDuration: () => import_canvas29.getAnimationDuration,
+  getAnimationTrack: () => import_canvas29.getAnimationTrack,
+  getAutoLayout: () => import_canvas27.getAutoLayout,
+  getAutoLayoutGrid: () => import_canvas27.getAutoLayoutGrid,
+  getAutoLayoutInsertTarget: () => import_canvas27.getAutoLayoutInsertTarget,
+  getBindableTokenProperties: () => import_canvas28.getBindableTokenProperties,
+  getCanvasComponentDragId: () => import_canvas30.getCanvasComponentDragId,
+  getCanvasTokenProperty: () => import_canvas28.getCanvasTokenProperty,
+  getCenteredNodePosition: () => import_canvas26.getCenteredNodePosition,
+  getChildLayout: () => import_canvas27.getChildLayout,
+  getComponentSourceId: () => import_canvas30.getComponentSourceId,
+  getCssPropertyAnimations: () => import_canvas29.getCssPropertyAnimations,
+  getEffectiveTokenModes: () => import_canvas28.getEffectiveTokenModes,
+  getFlowChildren: () => import_canvas27.getFlowChildren,
+  getInstanceData: () => import_canvas30.getInstanceData,
+  getInstanceStatus: () => import_canvas30.getInstanceStatus,
+  getKeyframeTimes: () => import_canvas29.getKeyframeTimes,
+  getLayoutParent: () => import_canvas27.getLayoutParent,
+  getLayoutSizing: () => import_canvas27.getLayoutSizing,
+  getLayoutedNodes: () => import_canvas26.getLayoutedNodes,
+  getNextVariantValues: () => import_canvas30.getNextVariantValues,
+  getNodeAnimation: () => import_canvas29.getNodeAnimation,
+  getNodeOverrides: () => import_canvas30.getNodeOverrides,
+  getNodeRect: () => import_canvas23.getNodeRect,
+  getNodeShape: () => import_canvas24.getNodeShape,
+  getNodeSize: () => import_canvas23.getNodeSize,
+  getNodeTokenBindings: () => import_canvas28.getNodeTokenBindings,
+  getNodeTokenModes: () => import_canvas28.getNodeTokenModes,
+  getResizingNodeRect: () => import_canvas22.getResizingNodeRect,
+  getShapeRenderData: () => import_canvas24.getShapeRenderData,
+  getShapeSvg: () => import_canvas24.getShapeSvg,
+  getTimelineRows: () => import_canvas29.getTimelineRows,
+  getTimelineTicks: () => import_canvas29.getTimelineTicks,
+  getTokenPropertyScope: () => import_canvas28.getTokenPropertyScope,
+  getTokensForProperty: () => import_canvas28.getTokensForProperty,
+  gradientToSvgDef: () => import_canvas30.gradientToSvgDef,
+  handlePoint: () => import_canvas23.handlePoint,
+  hasVisibleStroke: () => import_canvas25.hasVisibleStroke,
+  inferResizeHandle: () => import_canvas22.inferResizeHandle,
+  inspectCanvasInstance: () => import_canvas30.inspectCanvasInstance,
+  inspectNodeTokens: () => import_canvas28.inspectNodeTokens,
+  interpolateAnimationValue: () => import_canvas29.interpolateAnimationValue,
+  intersectPaths: () => import_canvas25.intersectPaths,
+  intersectPolygons: () => import_canvas24.intersectPolygons,
+  invertNodeUpdates: () => import_canvas23.invertNodeUpdates,
+  isAnimationEasing: () => import_canvas29.isAnimationEasing,
+  isAnimationKeyframe: () => import_canvas29.isAnimationKeyframe,
+  isAutoLayoutFrame: () => import_canvas27.isAutoLayoutFrame,
+  isCanvasComponent: () => import_canvas30.isCanvasComponent,
+  isCanvasComponentSet: () => import_canvas30.isCanvasComponentSet,
+  isCanvasGradient: () => import_canvas30.isCanvasGradient,
+  isCanvasInstance: () => import_canvas30.isCanvasInstance,
+  isCssExportExact: () => import_canvas29.isCssExportExact,
+  isEventFromTextInput: () => import_canvas26.isEventFromTextInput,
+  isKeyframeSelected: () => import_canvas29.isKeyframeSelected,
+  isLocked: () => import_canvas23.isLocked,
+  isMeasureModifierHeld: () => import_canvas22.isMeasureModifierHeld,
+  isNodeAnimated: () => import_canvas29.isNodeAnimated,
+  isShapeDescription: () => import_canvas24.isShapeDescription,
+  isShapeNode: () => import_canvas24.isShapeNode,
+  isStraightCubic: () => import_canvas22.isStraightCubic,
+  isValidCanvasNode: () => import_canvas26.isValidCanvasNode,
+  isValidUrl: () => import_canvas26.isValidUrl,
+  layoutAll: () => import_canvas27.layoutAll,
+  layoutBounds: () => import_canvas26.layoutBounds,
+  layoutFrame: () => import_canvas27.layoutFrame,
+  layoutUp: () => import_canvas27.layoutUp,
+  layoutUpMany: () => import_canvas27.layoutUpMany,
+  linearPositionTrajectory: () => import_canvas26.linearPositionTrajectory,
+  linearTrajectory: () => import_canvas26.linearTrajectory,
+  listCanvasComponents: () => import_canvas30.listCanvasComponents,
+  lockNodes: () => import_canvas23.lockNodes,
+  makeSizingCoherent: () => import_canvas27.makeSizingCoherent,
+  matchArrangeShortcut: () => import_canvas23.matchArrangeShortcut,
+  matchSize: () => import_canvas23.matchSize,
+  measureBetween: () => import_canvas22.measureBetween,
+  measureLabel: () => import_canvas22.measureLabel,
+  measureSelection: () => import_canvas22.measureSelection,
+  measureToLine: () => import_canvas22.measureToLine,
+  mergeNodeUpdates: () => import_canvas27.mergeNodeUpdates,
   mermaidNodeStyle: () => mermaidNodeStyle,
-  mixColorsOklab: () => import_canvas28.mixColorsOklab,
-  moveKeyframes: () => import_canvas28.moveKeyframes,
-  moveLayoutChild: () => import_canvas26.moveLayoutChild,
-  multiPolygonArea: () => import_canvas23.multiPolygonArea,
-  multiPolygonBounds: () => import_canvas23.multiPolygonBounds,
-  nearestHandlePositions: () => import_canvas22.nearestHandlePositions,
-  normalizeBezierPath: () => import_canvas24.normalizeBezierPath,
-  normalizeKeyframes: () => import_canvas28.normalizeKeyframes,
-  offsetPath: () => import_canvas24.offsetPath,
-  offsetShapeNodes: () => import_canvas24.offsetShapeNodes,
-  oklabToRgb: () => import_canvas28.oklabToRgb,
-  oppositePosition: () => import_canvas22.oppositePosition,
-  outlineShapeNodeStrokes: () => import_canvas24.outlineShapeNodeStrokes,
-  outlineStroke: () => import_canvas24.outlineStroke,
-  overlaps: () => import_canvas25.overlaps,
-  parseCanvasClipboardData: () => import_canvas25.parseCanvasClipboardData,
-  parseCanvasScenes: () => import_canvas22.parseCanvasScenes,
-  parseCssEasing: () => import_canvas28.parseCssEasing,
-  parseCssGradient: () => import_canvas29.parseCssGradient,
-  parseKeyframeClipboard: () => import_canvas28.parseKeyframeClipboard,
-  parseOklab: () => import_canvas28.parseOklab,
-  parseSvgPath: () => import_canvas23.parseSvgPath,
-  pasteKeyframes: () => import_canvas28.pasteKeyframes,
-  pathBoolean: () => import_canvas24.pathBoolean,
-  placeBeside: () => import_canvas25.placeBeside,
-  playWebAnimations: () => import_canvas28.playWebAnimations,
-  pointInBezierPath: () => import_canvas24.pointInBezierPath,
-  pointInMultiPolygon: () => import_canvas23.pointInMultiPolygon,
-  pointInRings: () => import_canvas23.pointInRings,
-  polygonArea: () => import_canvas23.polygonArea,
-  polygonBoolean: () => import_canvas23.polygonBoolean,
-  polygonToSvgPath: () => import_canvas23.polygonToSvgPath,
-  positionToSide: () => import_canvas22.positionToSide,
-  pruneCanvasTokenModes: () => import_canvas27.pruneCanvasTokenModes,
-  pushCanvasInstanceOverrides: () => import_canvas29.pushCanvasInstanceOverrides,
-  readAnimatableValue: () => import_canvas28.readAnimatableValue,
-  readNodeStyleProperty: () => import_canvas27.readNodeStyleProperty,
-  readStyleSize: () => import_canvas22.readStyleSize,
-  realClock: () => import_canvas25.realClock,
-  recordAnimationChanges: () => import_canvas28.recordAnimationChanges,
-  relayoutUpdates: () => import_canvas26.relayoutUpdates,
-  remapPastedNodes: () => import_canvas25.remapPastedNodes,
-  removeCanvasVariant: () => import_canvas29.removeCanvasVariant,
-  removeTrack: () => import_canvas28.removeTrack,
-  renameCanvasVariantProperty: () => import_canvas29.renameCanvasVariantProperty,
-  renameCanvasVariantValue: () => import_canvas29.renameCanvasVariantValue,
-  reorderNodes: () => import_canvas22.reorderNodes,
-  repositionNodesTo: () => import_canvas25.repositionNodesTo,
-  resetCanvasInstanceOverrides: () => import_canvas29.resetCanvasInstanceOverrides,
-  resizeHandleAxes: () => import_canvas21.resizeHandleAxes,
-  resolveCanvasGradient: () => import_canvas29.resolveCanvasGradient,
-  resolveCanvasTokens: () => import_canvas27.resolveCanvasTokens,
-  resolveEasing: () => import_canvas28.resolveEasing,
-  resolvePadding: () => import_canvas26.resolvePadding,
-  restoreCanvasMainComponent: () => import_canvas29.restoreCanvasMainComponent,
-  revertShapeCombination: () => import_canvas23.revertShapeCombination,
-  rgbToOklab: () => import_canvas28.rgbToOklab,
-  ringSignedArea: () => import_canvas23.ringSignedArea,
-  runMultiNodeTransition: () => import_canvas25.runMultiNodeTransition,
-  sampleAnimationFrames: () => import_canvas28.sampleAnimationFrames,
-  scaleKeyframes: () => import_canvas28.scaleKeyframes,
-  serializeCanvasNodes: () => import_canvas25.serializeCanvasNodes,
-  setCanvasComponentProperty: () => import_canvas29.setCanvasComponentProperty,
-  setCanvasInstanceProperties: () => import_canvas29.setCanvasInstanceProperties,
-  setCanvasTokenMode: () => import_canvas27.setCanvasTokenMode,
-  setCanvasVariantProperties: () => import_canvas29.setCanvasVariantProperties,
-  setKeyframe: () => import_canvas28.setKeyframe,
-  setKeyframeEasing: () => import_canvas28.setKeyframeEasing,
-  setMotionPath: () => import_canvas28.setMotionPath,
-  setTrackEnabled: () => import_canvas28.setTrackEnabled,
-  shapeNodeToBezierPath: () => import_canvas24.shapeNodeToBezierPath,
-  shapeNodeToPolygon: () => import_canvas23.shapeNodeToPolygon,
-  shapeToBezierPath: () => import_canvas24.shapeToBezierPath,
-  shapeToPolygon: () => import_canvas23.shapeToPolygon,
-  sideToPosition: () => import_canvas22.sideToPosition,
-  simplifyRing: () => import_canvas23.simplifyRing,
-  snapKeyframeDelta: () => import_canvas28.snapKeyframeDelta,
-  snapNodeDrag: () => import_canvas22.snapNodeDrag,
-  snapNodeResize: () => import_canvas21.snapNodeResize,
-  snapResize: () => import_canvas21.snapResize,
-  snapTimeToFrame: () => import_canvas28.snapTimeToFrame,
-  snapToGrid: () => import_canvas21.snapToGrid,
-  springAt: () => import_canvas28.springAt,
-  streamlinePoints: () => import_canvas29.streamlinePoints,
-  strokeOutlineRings: () => import_canvas24.strokeOutlineRings,
-  strokePointsToPathData: () => import_canvas29.strokePointsToPathData,
-  strokeToShapeNode: () => import_canvas29.strokeToShapeNode,
-  subtractPaths: () => import_canvas24.subtractPaths,
-  subtractPolygons: () => import_canvas23.subtractPolygons,
-  swapCanvasInstance: () => import_canvas29.swapCanvasInstance,
-  syncAllCanvasInstances: () => import_canvas29.syncAllCanvasInstances,
-  syncCanvasComponents: () => import_canvas29.syncCanvasComponents,
-  syncCanvasInstance: () => import_canvas29.syncCanvasInstance,
-  timeToX: () => import_canvas28.timeToX,
-  toBezierPath: () => import_canvas24.toBezierPath,
-  toWebAnimations: () => import_canvas28.toWebAnimations,
-  toggleLockNodes: () => import_canvas22.toggleLockNodes,
-  transformBezierPath: () => import_canvas24.transformBezierPath,
-  unionPolygons: () => import_canvas23.unionPolygons,
-  unitePaths: () => import_canvas24.unitePaths,
-  unlockNodes: () => import_canvas22.unlockNodes,
-  updateKeyframe: () => import_canvas28.updateKeyframe,
+  mixColorsOklab: () => import_canvas29.mixColorsOklab,
+  moveKeyframes: () => import_canvas29.moveKeyframes,
+  moveLayoutChild: () => import_canvas27.moveLayoutChild,
+  multiPolygonArea: () => import_canvas24.multiPolygonArea,
+  multiPolygonBounds: () => import_canvas24.multiPolygonBounds,
+  nearestHandlePositions: () => import_canvas23.nearestHandlePositions,
+  normalizeBezierPath: () => import_canvas25.normalizeBezierPath,
+  normalizeKeyframes: () => import_canvas29.normalizeKeyframes,
+  offsetPath: () => import_canvas25.offsetPath,
+  offsetShapeNodes: () => import_canvas25.offsetShapeNodes,
+  oklabToRgb: () => import_canvas29.oklabToRgb,
+  oppositePosition: () => import_canvas23.oppositePosition,
+  outlineShapeNodeStrokes: () => import_canvas25.outlineShapeNodeStrokes,
+  outlineStroke: () => import_canvas25.outlineStroke,
+  overlaps: () => import_canvas26.overlaps,
+  parseCanvasClipboardData: () => import_canvas26.parseCanvasClipboardData,
+  parseCanvasScenes: () => import_canvas23.parseCanvasScenes,
+  parseCssEasing: () => import_canvas29.parseCssEasing,
+  parseCssGradient: () => import_canvas30.parseCssGradient,
+  parseKeyframeClipboard: () => import_canvas29.parseKeyframeClipboard,
+  parseOklab: () => import_canvas29.parseOklab,
+  parseSvgPath: () => import_canvas24.parseSvgPath,
+  pasteKeyframes: () => import_canvas29.pasteKeyframes,
+  pathBoolean: () => import_canvas25.pathBoolean,
+  placeBeside: () => import_canvas26.placeBeside,
+  playWebAnimations: () => import_canvas29.playWebAnimations,
+  pointInBezierPath: () => import_canvas25.pointInBezierPath,
+  pointInMultiPolygon: () => import_canvas24.pointInMultiPolygon,
+  pointInRings: () => import_canvas24.pointInRings,
+  polygonArea: () => import_canvas24.polygonArea,
+  polygonBoolean: () => import_canvas24.polygonBoolean,
+  polygonToSvgPath: () => import_canvas24.polygonToSvgPath,
+  positionToSide: () => import_canvas23.positionToSide,
+  pruneCanvasTokenModes: () => import_canvas28.pruneCanvasTokenModes,
+  pushCanvasInstanceOverrides: () => import_canvas30.pushCanvasInstanceOverrides,
+  readAnimatableValue: () => import_canvas29.readAnimatableValue,
+  readNodeStyleProperty: () => import_canvas28.readNodeStyleProperty,
+  readStyleSize: () => import_canvas23.readStyleSize,
+  realClock: () => import_canvas26.realClock,
+  recordAnimationChanges: () => import_canvas29.recordAnimationChanges,
+  relayoutUpdates: () => import_canvas27.relayoutUpdates,
+  remapPastedNodes: () => import_canvas26.remapPastedNodes,
+  removeCanvasVariant: () => import_canvas30.removeCanvasVariant,
+  removeTrack: () => import_canvas29.removeTrack,
+  renameCanvasVariantProperty: () => import_canvas30.renameCanvasVariantProperty,
+  renameCanvasVariantValue: () => import_canvas30.renameCanvasVariantValue,
+  reorderNodes: () => import_canvas23.reorderNodes,
+  repositionNodesTo: () => import_canvas26.repositionNodesTo,
+  resetCanvasInstanceOverrides: () => import_canvas30.resetCanvasInstanceOverrides,
+  resizeHandleAxes: () => import_canvas22.resizeHandleAxes,
+  resolveCanvasGradient: () => import_canvas30.resolveCanvasGradient,
+  resolveCanvasTokens: () => import_canvas28.resolveCanvasTokens,
+  resolveEasing: () => import_canvas29.resolveEasing,
+  resolvePadding: () => import_canvas27.resolvePadding,
+  restoreCanvasMainComponent: () => import_canvas30.restoreCanvasMainComponent,
+  revertShapeCombination: () => import_canvas24.revertShapeCombination,
+  rgbToOklab: () => import_canvas29.rgbToOklab,
+  ringSignedArea: () => import_canvas24.ringSignedArea,
+  runMultiNodeTransition: () => import_canvas26.runMultiNodeTransition,
+  sampleAnimationFrames: () => import_canvas29.sampleAnimationFrames,
+  scaleKeyframes: () => import_canvas29.scaleKeyframes,
+  serializeCanvasNodes: () => import_canvas26.serializeCanvasNodes,
+  setCanvasComponentProperty: () => import_canvas30.setCanvasComponentProperty,
+  setCanvasInstanceProperties: () => import_canvas30.setCanvasInstanceProperties,
+  setCanvasTokenMode: () => import_canvas28.setCanvasTokenMode,
+  setCanvasVariantProperties: () => import_canvas30.setCanvasVariantProperties,
+  setKeyframe: () => import_canvas29.setKeyframe,
+  setKeyframeEasing: () => import_canvas29.setKeyframeEasing,
+  setMotionPath: () => import_canvas29.setMotionPath,
+  setTrackEnabled: () => import_canvas29.setTrackEnabled,
+  shapeNodeToBezierPath: () => import_canvas25.shapeNodeToBezierPath,
+  shapeNodeToPolygon: () => import_canvas24.shapeNodeToPolygon,
+  shapeToBezierPath: () => import_canvas25.shapeToBezierPath,
+  shapeToPolygon: () => import_canvas24.shapeToPolygon,
+  sideToPosition: () => import_canvas23.sideToPosition,
+  simplifyRing: () => import_canvas24.simplifyRing,
+  snapKeyframeDelta: () => import_canvas29.snapKeyframeDelta,
+  snapNodeDrag: () => import_canvas23.snapNodeDrag,
+  snapNodeResize: () => import_canvas22.snapNodeResize,
+  snapResize: () => import_canvas22.snapResize,
+  snapTimeToFrame: () => import_canvas29.snapTimeToFrame,
+  snapToGrid: () => import_canvas22.snapToGrid,
+  springAt: () => import_canvas29.springAt,
+  streamlinePoints: () => import_canvas30.streamlinePoints,
+  strokeOutlineRings: () => import_canvas25.strokeOutlineRings,
+  strokePointsToPathData: () => import_canvas30.strokePointsToPathData,
+  strokeToShapeNode: () => import_canvas30.strokeToShapeNode,
+  subtractPaths: () => import_canvas25.subtractPaths,
+  subtractPolygons: () => import_canvas24.subtractPolygons,
+  swapCanvasInstance: () => import_canvas30.swapCanvasInstance,
+  syncAllCanvasInstances: () => import_canvas30.syncAllCanvasInstances,
+  syncCanvasComponents: () => import_canvas30.syncCanvasComponents,
+  syncCanvasInstance: () => import_canvas30.syncCanvasInstance,
+  timeToX: () => import_canvas29.timeToX,
+  toBezierPath: () => import_canvas25.toBezierPath,
+  toWebAnimations: () => import_canvas29.toWebAnimations,
+  toggleLockNodes: () => import_canvas23.toggleLockNodes,
+  transformBezierPath: () => import_canvas25.transformBezierPath,
+  unionPolygons: () => import_canvas24.unionPolygons,
+  unitePaths: () => import_canvas25.unitePaths,
+  unlockNodes: () => import_canvas23.unlockNodes,
+  updateKeyframe: () => import_canvas29.updateKeyframe,
   useCanvasAnimation: () => useCanvasAnimation,
   useCanvasArrange: () => useCanvasArrange,
   useCanvasArrangeShortcuts: () => useCanvasArrangeShortcuts,
@@ -352,13 +353,13 @@ __export(canvas_exports, {
   useMermaidStream: () => useMermaidStream,
   usePresenceState: () => usePresenceState,
   useStreamingCanvas: () => useStreamingCanvas,
-  withNodeAnimation: () => import_canvas28.withNodeAnimation,
-  withStyleSize: () => import_canvas22.withStyleSize,
-  wouldCreateComponentCycle: () => import_canvas29.wouldCreateComponentCycle,
-  wrapAnimationTime: () => import_canvas28.wrapAnimationTime,
-  writeNodeStyleProperty: () => import_canvas27.writeNodeStyleProperty,
-  xToTime: () => import_canvas28.xToTime,
-  xorPolygons: () => import_canvas23.xorPolygons
+  withNodeAnimation: () => import_canvas29.withNodeAnimation,
+  withStyleSize: () => import_canvas23.withStyleSize,
+  wouldCreateComponentCycle: () => import_canvas30.wouldCreateComponentCycle,
+  wrapAnimationTime: () => import_canvas29.wrapAnimationTime,
+  writeNodeStyleProperty: () => import_canvas28.writeNodeStyleProperty,
+  xToTime: () => import_canvas29.xToTime,
+  xorPolygons: () => import_canvas24.xorPolygons
 });
 module.exports = __toCommonJS(canvas_exports);
 
@@ -1577,8 +1578,8 @@ function useCanvasMeasure(options) {
 }
 
 // src/canvas/index.ts
-var import_canvas21 = require("@pixerate/editor/canvas");
 var import_canvas22 = require("@pixerate/editor/canvas");
+var import_canvas23 = require("@pixerate/editor/canvas");
 
 // src/canvas/ShapeNode.tsx
 var import_canvas11 = require("@pixerate/editor/canvas");
@@ -1636,10 +1637,10 @@ function ShapeNode({ id, data, width, height, selected, className = "", children
 }
 
 // src/canvas/index.ts
-var import_canvas23 = require("@pixerate/editor/canvas");
 var import_canvas24 = require("@pixerate/editor/canvas");
 var import_canvas25 = require("@pixerate/editor/canvas");
 var import_canvas26 = require("@pixerate/editor/canvas");
+var import_canvas27 = require("@pixerate/editor/canvas");
 
 // src/canvas/useCanvasAutoLayout.ts
 var import_react13 = require("react");
@@ -1851,7 +1852,7 @@ function TokenModeSwitcher({
 }
 
 // src/canvas/index.ts
-var import_canvas27 = require("@pixerate/editor/canvas");
+var import_canvas28 = require("@pixerate/editor/canvas");
 
 // src/canvas/useCanvasAnimation.ts
 var import_react15 = require("react");
@@ -2105,7 +2106,7 @@ function AnimationTimeline({ animation, nodeIds, width = 360, snapThreshold = 8,
 }
 
 // src/canvas/index.ts
-var import_canvas28 = require("@pixerate/editor/canvas");
+var import_canvas29 = require("@pixerate/editor/canvas");
 
 // src/canvas/useCanvasComponents.ts
 var import_react17 = require("react");
@@ -2516,7 +2517,7 @@ function CanvasInstanceInspector({
 }
 
 // src/canvas/index.ts
-var import_canvas29 = require("@pixerate/editor/canvas");
+var import_canvas30 = require("@pixerate/editor/canvas");
 
 // src/canvas/useMermaidDiagram.ts
 var import_react19 = require("react");
@@ -2673,34 +2674,51 @@ function MermaidDiagramGroup({ data, selected, className = "", children }) {
   );
 }
 
-// src/canvas/useDiagramDirector.ts
+// src/canvas/MermaidThumbnail.tsx
 var import_react20 = require("react");
 var import_diagram2 = require("@pixerate/editor/diagram");
+var import_canvas21 = require("@pixerate/editor/canvas");
+var import_jsx_runtime9 = require("react/jsx-runtime");
+function MermaidThumbnail({ source, className = "", fallback = null, ...options }) {
+  const doc = (0, import_react20.useMemo)(() => typeof source === "string" ? (0, import_diagram2.parseMermaid)(source) : source, [source]);
+  const key = JSON.stringify(options);
+  const drawn = (0, import_react20.useMemo)(
+    () => doc.tier === "editable" && doc.graph.nodes.length ? (0, import_canvas21.mermaidThumbnailSvg)(doc, options) : null,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [doc, key]
+  );
+  if (!drawn) return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_jsx_runtime9.Fragment, { children: fallback });
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: `pixerate-diagram-thumbnail ${className}`.trim(), style: { display: "inline-block", lineHeight: 0 }, dangerouslySetInnerHTML: { __html: drawn.svg } });
+}
+
+// src/canvas/useDiagramDirector.ts
+var import_react21 = require("react");
+var import_diagram3 = require("@pixerate/editor/diagram");
 function useDiagramDirector(controller, options) {
-  const placement = (0, import_react20.useRef)(options.placement);
+  const placement = (0, import_react21.useRef)(options.placement);
   placement.current = options.placement;
-  const ref = (0, import_react20.useRef)(null);
+  const ref = (0, import_react21.useRef)(null);
   if (!ref.current) {
-    const presence = new import_diagram2.PresenceStore();
+    const presence = new import_diagram3.PresenceStore();
     ref.current = {
       presence,
-      director: new import_diagram2.DiagramDirector(controller, presence, { placement: () => placement.current(), speed: options.speed, clock: options.clock, linger: options.linger })
+      director: new import_diagram3.DiagramDirector(controller, presence, { placement: () => placement.current(), speed: options.speed, clock: options.clock, linger: options.linger })
     };
   }
   return ref.current;
 }
 function usePresenceState(presence) {
-  return (0, import_react20.useSyncExternalStore)(presence.subscribe, presence.getState, presence.getState);
+  return (0, import_react21.useSyncExternalStore)(presence.subscribe, presence.getState, presence.getState);
 }
 
 // src/canvas/DiagramPresenceLayer.tsx
-var import_jsx_runtime9 = require("react/jsx-runtime");
+var import_jsx_runtime10 = require("react/jsx-runtime");
 function DiagramPresenceLayer({ presence, viewport, className = "" }) {
   const { actors } = usePresenceState(presence);
   if (!actors.length) return null;
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { className: `pixerate-diagram-presence ${className}`.trim(), "aria-hidden": "true", style: { position: "absolute", inset: 0, pointerEvents: "none", overflow: "hidden", zIndex: 50 }, children: actors.map((a) => /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { "data-actor": a.id, style: { position: "absolute", left: 0, top: 0, transform: `translate(${a.x * viewport.zoom + viewport.x}px, ${a.y * viewport.zoom + viewport.y}px)` }, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("svg", { width: "18", height: "20", viewBox: "0 0 12 18", style: { display: "block", transform: a.pressed ? "scale(0.85)" : void 0, transformOrigin: "0 0" }, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("path", { d: "M0,0 L0,14 L4,10.5 L7,17 L9.5,16 L6.5,9.5 L11.5,9.5 Z", style: { fill: a.color, stroke: "#ffffff", strokeWidth: 1 } }) }),
-    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { style: { position: "absolute", left: 14, top: 16, whiteSpace: "nowrap", borderRadius: 4, padding: "1px 6px", fontSize: 11, fontWeight: 600, color: "#ffffff", background: a.color }, children: a.message ?? a.name })
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: `pixerate-diagram-presence ${className}`.trim(), "aria-hidden": "true", style: { position: "absolute", inset: 0, pointerEvents: "none", overflow: "hidden", zIndex: 50 }, children: actors.map((a) => /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { "data-actor": a.id, style: { position: "absolute", left: 0, top: 0, transform: `translate(${a.x * viewport.zoom + viewport.x}px, ${a.y * viewport.zoom + viewport.y}px)` }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("svg", { width: "18", height: "20", viewBox: "0 0 12 18", style: { display: "block", transform: a.pressed ? "scale(0.85)" : void 0, transformOrigin: "0 0" }, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("path", { d: "M0,0 L0,14 L4,10.5 L7,17 L9.5,16 L6.5,9.5 L11.5,9.5 Z", style: { fill: a.color, stroke: "#ffffff", strokeWidth: 1 } }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { style: { position: "absolute", left: 14, top: 16, whiteSpace: "nowrap", borderRadius: 4, padding: "1px 6px", fontSize: 11, fontWeight: 600, color: "#ffffff", background: a.color }, children: a.message ?? a.name })
   ] }, a.id)) });
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -2733,6 +2751,7 @@ function DiagramPresenceLayer({ presence, viewport, className = "" }) {
   ManualClock,
   MermaidDiagramGroup,
   MermaidDiagramNode,
+  MermaidThumbnail,
   RESIZE_HANDLES,
   SHAPE_DATA_KEY,
   SHAPE_KINDS,