@pixerate/editor-react 0.39.0 → 0.41.0

package/dist/canvas/index.cjs

@@ -20,313 +20,317 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/canvas/index.ts
 var canvas_exports = {};
 __export(canvas_exports, {
-  ANIMATABLE_PROPERTIES: () => import_canvas26.ANIMATABLE_PROPERTIES,
-  ANIMATION_DATA_KEY: () => import_canvas26.ANIMATION_DATA_KEY,
-  ANIMATION_EASING_LABELS: () => import_canvas26.ANIMATION_EASING_LABELS,
-  ANIMATION_EASING_PRESETS: () => import_canvas26.ANIMATION_EASING_PRESETS,
-  ANIMATION_TIME_EPSILON: () => import_canvas26.ANIMATION_TIME_EPSILON,
-  AUTO_LAYOUT_DATA_KEY: () => import_canvas24.AUTO_LAYOUT_DATA_KEY,
+  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,
   AgentPresenceLayer: () => AgentPresenceLayer,
-  AnimationEditError: () => import_canvas26.AnimationEditError,
-  AnimationPlayer: () => import_canvas26.AnimationPlayer,
+  AnimationEditError: () => import_canvas28.AnimationEditError,
+  AnimationPlayer: () => import_canvas28.AnimationPlayer,
   AnimationTimeline: () => AnimationTimeline,
-  CANVAS_COMPONENT_DRAG_TYPE: () => import_canvas27.CANVAS_COMPONENT_DRAG_TYPE,
-  CANVAS_GRADIENT_PRESETS: () => import_canvas27.CANVAS_GRADIENT_PRESETS,
-  CANVAS_TOKEN_PROPERTIES: () => import_canvas25.CANVAS_TOKEN_PROPERTIES,
-  CHILD_LAYOUT_DATA_KEY: () => import_canvas24.CHILD_LAYOUT_DATA_KEY,
-  CONNECTION_LINE_TYPES: () => import_canvas20.CONNECTION_LINE_TYPES,
-  CSS_ANIMATION_PROPERTIES: () => import_canvas26.CSS_ANIMATION_PROPERTIES,
-  CUBIC_BEZIER_PRESETS: () => import_canvas26.CUBIC_BEZIER_PRESETS,
+  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,
   CanvasComponentsPanel: () => CanvasComponentsPanel,
   CanvasDrawLayer: () => CanvasDrawLayer,
   CanvasGuidesLayer: () => CanvasGuidesLayer,
   CanvasInstanceInspector: () => CanvasInstanceInspector,
-  CanvasScenesStore: () => import_canvas20.CanvasScenesStore,
-  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas20.DEFAULT_ARRANGE_SHORTCUTS,
-  MAX_KEYFRAME_REFS: () => import_canvas26.MAX_KEYFRAME_REFS,
-  ManualClock: () => import_canvas23.ManualClock,
-  RESIZE_HANDLES: () => import_canvas19.RESIZE_HANDLES,
-  SHAPE_DATA_KEY: () => import_canvas21.SHAPE_DATA_KEY,
-  SHAPE_KINDS: () => import_canvas21.SHAPE_KINDS,
-  SHAPE_NODE_TYPE: () => import_canvas21.SHAPE_NODE_TYPE,
-  SHAPE_OPERATIONS: () => import_canvas21.SHAPE_OPERATIONS,
+  CanvasScenesStore: () => import_canvas22.CanvasScenesStore,
+  DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas22.DEFAULT_ARRANGE_SHORTCUTS,
+  DiagramPresenceLayer: () => DiagramPresenceLayer,
+  MAX_KEYFRAME_REFS: () => import_canvas28.MAX_KEYFRAME_REFS,
+  ManualClock: () => import_canvas25.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,
   ShapeNode: () => ShapeNode,
-  TOKEN_BINDINGS_DATA_KEY: () => import_canvas25.TOKEN_BINDINGS_DATA_KEY,
-  TOKEN_MODES_DATA_KEY: () => import_canvas25.TOKEN_MODES_DATA_KEY,
+  TOKEN_BINDINGS_DATA_KEY: () => import_canvas27.TOKEN_BINDINGS_DATA_KEY,
+  TOKEN_MODES_DATA_KEY: () => import_canvas27.TOKEN_MODES_DATA_KEY,
   TokenBindingPicker: () => TokenBindingPicker,
   TokenModeSwitcher: () => TokenModeSwitcher,
-  addCanvasVariant: () => import_canvas27.addCanvasVariant,
-  addKeyframesAtTime: () => import_canvas26.addKeyframesAtTime,
-  alignNodes: () => import_canvas20.alignNodes,
-  angleToSvgLinearCoords: () => import_canvas27.angleToSvgLinearCoords,
-  animateNode: () => import_canvas26.animateNode,
-  applyAnimation: () => import_canvas26.applyAnimation,
-  applyAnimationOverrides: () => import_canvas26.applyAnimationOverrides,
-  applyConstraints: () => import_canvas24.applyConstraints,
-  applyNodeUpdates: () => import_canvas20.applyNodeUpdates,
-  applyShapeCombination: () => import_canvas21.applyShapeCombination,
-  applyShapeReplacement: () => import_canvas22.applyShapeReplacement,
-  bezierPathArea: () => import_canvas22.bezierPathArea,
-  bezierPathBounds: () => import_canvas22.bezierPathBounds,
-  bezierPathLength: () => import_canvas22.bezierPathLength,
-  bezierPathPointAtLength: () => import_canvas22.bezierPathPointAtLength,
-  bezierPathSignedArea: () => import_canvas22.bezierPathSignedArea,
-  bezierPathToSvg: () => import_canvas22.bezierPathToSvg,
-  bindCanvasComponentProperty: () => import_canvas27.bindCanvasComponentProperty,
-  bindCanvasToken: () => import_canvas25.bindCanvasToken,
-  blendLayout: () => import_canvas23.blendLayout,
-  boundsOf: () => import_canvas23.boundsOf,
-  calculateDagreReflowDisplacement: () => import_canvas23.calculateDagreReflowDisplacement,
-  calculateDirectionalDisplacement: () => import_canvas23.calculateDirectionalDisplacement,
-  canCombineShapeNodes: () => import_canvas21.canCombineShapeNodes,
-  canOffsetShapeNodes: () => import_canvas22.canOffsetShapeNodes,
-  canOutlineShapeNodeStrokes: () => import_canvas22.canOutlineShapeNodeStrokes,
-  canvasHeight: () => import_canvas23.canvasHeight,
-  centerNodes: () => import_canvas23.centerNodes,
-  centre: () => import_canvas23.centre,
-  clampAnimationValue: () => import_canvas26.clampAnimationValue,
-  clampLayoutSize: () => import_canvas24.clampLayoutSize,
-  combineCanvasComponentsAsVariants: () => import_canvas27.combineCanvasComponentsAsVariants,
-  combineShapeNodes: () => import_canvas21.combineShapeNodes,
-  computeNodesBoundingBox: () => import_canvas23.computeNodesBoundingBox,
-  computeSnapGuides: () => import_canvas20.computeSnapGuides,
-  connectedOnly: () => import_canvas23.connectedOnly,
-  copyKeyframes: () => import_canvas26.copyKeyframes,
-  countPathSegments: () => import_canvas22.countPathSegments,
-  createAnimationPlayer: () => import_canvas26.createAnimationPlayer,
-  createBezierTrajectory: () => import_canvas23.createBezierTrajectory,
-  createCanvasAnimationController: () => import_canvas26.createCanvasAnimationController,
-  createCanvasAutoLayoutController: () => import_canvas24.createCanvasAutoLayoutController,
-  createCanvasComponent: () => import_canvas27.createCanvasComponent,
-  createCanvasComponentsController: () => import_canvas27.createCanvasComponentsController,
-  createCanvasDrawController: () => import_canvas27.createCanvasDrawController,
-  createCanvasInstance: () => import_canvas27.createCanvasInstance,
-  createCanvasScenesStore: () => import_canvas20.createCanvasScenesStore,
-  createDefaultStrokeStyle: () => import_canvas27.createDefaultStrokeStyle,
-  createFanOutTrajectory: () => import_canvas23.createFanOutTrajectory,
-  createGuideIndex: () => import_canvas20.createGuideIndex,
-  createNodeGuideIndex: () => import_canvas20.createNodeGuideIndex,
-  cubicBezierAt: () => import_canvas26.cubicBezierAt,
-  cubicPointAt: () => import_canvas19.cubicPointAt,
-  cubicsToPathData: () => import_canvas19.cubicsToPathData,
-  dashContours: () => import_canvas22.dashContours,
-  defaultEasing: () => import_canvas23.defaultEasing,
-  deleteKeyframes: () => import_canvas26.deleteKeyframes,
-  detachCanvasInstance: () => import_canvas27.detachCanvasInstance,
-  detachTokenBindings: () => import_canvas25.detachTokenBindings,
-  distanceToBezierPath: () => import_canvas22.distanceToBezierPath,
-  distributeNodes: () => import_canvas20.distributeNodes,
-  dividePaths: () => import_canvas22.dividePaths,
-  dividePolygons: () => import_canvas21.dividePolygons,
-  easingFromInfluence: () => import_canvas26.easingFromInfluence,
-  easingLabel: () => import_canvas26.easingLabel,
-  easingToCss: () => import_canvas26.easingToCss,
-  ensureLayout: () => import_canvas23.ensureLayout,
-  estimateCanvasHeight: () => import_canvas23.estimateCanvasHeight,
-  estimateNodeSize: () => import_canvas23.estimateNodeSize,
-  evaluateAnimation: () => import_canvas26.evaluateAnimation,
-  evaluateEasing: () => import_canvas26.evaluateEasing,
-  evaluateTrack: () => import_canvas26.evaluateTrack,
-  excludePaths: () => import_canvas22.excludePaths,
-  exportCssAnimation: () => import_canvas26.exportCssAnimation,
-  findConnectorSnap: () => import_canvas20.findConnectorSnap,
-  findStrokesAtPoint: () => import_canvas27.findStrokesAtPoint,
-  fitCubicRun: () => import_canvas19.fitCubicRun,
-  fitCubics: () => import_canvas19.fitCubics,
-  fitFreehandPath: () => import_canvas19.fitFreehandPath,
-  fitPathData: () => import_canvas19.fitPathData,
-  fitViewportToNodes: () => import_canvas20.fitViewportToNodes,
-  fitViewportToRect: () => import_canvas20.fitViewportToRect,
-  flattenSvgPath: () => import_canvas21.flattenSvgPath,
-  flowSide: () => import_canvas23.flowSide,
-  formatAnimationTime: () => import_canvas26.formatAnimationTime,
-  formatOklab: () => import_canvas26.formatOklab,
-  getAbsolutePosition: () => import_canvas20.getAbsolutePosition,
-  getAnimatableProperty: () => import_canvas26.getAnimatableProperty,
-  getAnimatedProperties: () => import_canvas26.getAnimatedProperties,
-  getAnimatedValue: () => import_canvas26.getAnimatedValue,
-  getAnimationDuration: () => import_canvas26.getAnimationDuration,
-  getAnimationTrack: () => import_canvas26.getAnimationTrack,
-  getAutoLayout: () => import_canvas24.getAutoLayout,
-  getAutoLayoutGrid: () => import_canvas24.getAutoLayoutGrid,
-  getAutoLayoutInsertTarget: () => import_canvas24.getAutoLayoutInsertTarget,
-  getBindableTokenProperties: () => import_canvas25.getBindableTokenProperties,
-  getCanvasComponentDragId: () => import_canvas27.getCanvasComponentDragId,
-  getCanvasTokenProperty: () => import_canvas25.getCanvasTokenProperty,
-  getCenteredNodePosition: () => import_canvas23.getCenteredNodePosition,
-  getChildLayout: () => import_canvas24.getChildLayout,
-  getComponentSourceId: () => import_canvas27.getComponentSourceId,
-  getCssPropertyAnimations: () => import_canvas26.getCssPropertyAnimations,
-  getEffectiveTokenModes: () => import_canvas25.getEffectiveTokenModes,
-  getFlowChildren: () => import_canvas24.getFlowChildren,
-  getInstanceData: () => import_canvas27.getInstanceData,
-  getInstanceStatus: () => import_canvas27.getInstanceStatus,
-  getKeyframeTimes: () => import_canvas26.getKeyframeTimes,
-  getLayoutParent: () => import_canvas24.getLayoutParent,
-  getLayoutSizing: () => import_canvas24.getLayoutSizing,
-  getLayoutedNodes: () => import_canvas23.getLayoutedNodes,
-  getNextVariantValues: () => import_canvas27.getNextVariantValues,
-  getNodeAnimation: () => import_canvas26.getNodeAnimation,
-  getNodeOverrides: () => import_canvas27.getNodeOverrides,
-  getNodeRect: () => import_canvas20.getNodeRect,
-  getNodeShape: () => import_canvas21.getNodeShape,
-  getNodeSize: () => import_canvas20.getNodeSize,
-  getNodeTokenBindings: () => import_canvas25.getNodeTokenBindings,
-  getNodeTokenModes: () => import_canvas25.getNodeTokenModes,
-  getResizingNodeRect: () => import_canvas19.getResizingNodeRect,
-  getShapeRenderData: () => import_canvas21.getShapeRenderData,
-  getShapeSvg: () => import_canvas21.getShapeSvg,
-  getTimelineRows: () => import_canvas26.getTimelineRows,
-  getTimelineTicks: () => import_canvas26.getTimelineTicks,
-  getTokenPropertyScope: () => import_canvas25.getTokenPropertyScope,
-  getTokensForProperty: () => import_canvas25.getTokensForProperty,
-  gradientToSvgDef: () => import_canvas27.gradientToSvgDef,
-  handlePoint: () => import_canvas20.handlePoint,
-  hasVisibleStroke: () => import_canvas22.hasVisibleStroke,
-  inferResizeHandle: () => import_canvas19.inferResizeHandle,
-  inspectCanvasInstance: () => import_canvas27.inspectCanvasInstance,
-  inspectNodeTokens: () => import_canvas25.inspectNodeTokens,
-  interpolateAnimationValue: () => import_canvas26.interpolateAnimationValue,
-  intersectPaths: () => import_canvas22.intersectPaths,
-  intersectPolygons: () => import_canvas21.intersectPolygons,
-  invertNodeUpdates: () => import_canvas20.invertNodeUpdates,
-  isAnimationEasing: () => import_canvas26.isAnimationEasing,
-  isAnimationKeyframe: () => import_canvas26.isAnimationKeyframe,
-  isAutoLayoutFrame: () => import_canvas24.isAutoLayoutFrame,
-  isCanvasComponent: () => import_canvas27.isCanvasComponent,
-  isCanvasComponentSet: () => import_canvas27.isCanvasComponentSet,
-  isCanvasGradient: () => import_canvas27.isCanvasGradient,
-  isCanvasInstance: () => import_canvas27.isCanvasInstance,
-  isCssExportExact: () => import_canvas26.isCssExportExact,
-  isEventFromTextInput: () => import_canvas23.isEventFromTextInput,
-  isKeyframeSelected: () => import_canvas26.isKeyframeSelected,
-  isLocked: () => import_canvas20.isLocked,
-  isMeasureModifierHeld: () => import_canvas19.isMeasureModifierHeld,
-  isNodeAnimated: () => import_canvas26.isNodeAnimated,
-  isShapeDescription: () => import_canvas21.isShapeDescription,
-  isShapeNode: () => import_canvas21.isShapeNode,
-  isStraightCubic: () => import_canvas19.isStraightCubic,
-  isValidCanvasNode: () => import_canvas23.isValidCanvasNode,
-  isValidUrl: () => import_canvas23.isValidUrl,
-  layoutAll: () => import_canvas24.layoutAll,
-  layoutBounds: () => import_canvas23.layoutBounds,
-  layoutFrame: () => import_canvas24.layoutFrame,
-  layoutUp: () => import_canvas24.layoutUp,
-  layoutUpMany: () => import_canvas24.layoutUpMany,
-  linearPositionTrajectory: () => import_canvas23.linearPositionTrajectory,
-  linearTrajectory: () => import_canvas23.linearTrajectory,
-  listCanvasComponents: () => import_canvas27.listCanvasComponents,
-  lockNodes: () => import_canvas20.lockNodes,
-  makeSizingCoherent: () => import_canvas24.makeSizingCoherent,
-  matchArrangeShortcut: () => import_canvas20.matchArrangeShortcut,
-  matchSize: () => import_canvas20.matchSize,
-  measureBetween: () => import_canvas19.measureBetween,
-  measureLabel: () => import_canvas19.measureLabel,
-  measureSelection: () => import_canvas19.measureSelection,
-  measureToLine: () => import_canvas19.measureToLine,
-  mergeNodeUpdates: () => import_canvas24.mergeNodeUpdates,
-  mixColorsOklab: () => import_canvas26.mixColorsOklab,
-  moveKeyframes: () => import_canvas26.moveKeyframes,
-  moveLayoutChild: () => import_canvas24.moveLayoutChild,
-  multiPolygonArea: () => import_canvas21.multiPolygonArea,
-  multiPolygonBounds: () => import_canvas21.multiPolygonBounds,
-  nearestHandlePositions: () => import_canvas20.nearestHandlePositions,
-  normalizeBezierPath: () => import_canvas22.normalizeBezierPath,
-  normalizeKeyframes: () => import_canvas26.normalizeKeyframes,
-  offsetPath: () => import_canvas22.offsetPath,
-  offsetShapeNodes: () => import_canvas22.offsetShapeNodes,
-  oklabToRgb: () => import_canvas26.oklabToRgb,
-  oppositePosition: () => import_canvas20.oppositePosition,
-  outlineShapeNodeStrokes: () => import_canvas22.outlineShapeNodeStrokes,
-  outlineStroke: () => import_canvas22.outlineStroke,
-  overlaps: () => import_canvas23.overlaps,
-  parseCanvasClipboardData: () => import_canvas23.parseCanvasClipboardData,
-  parseCanvasScenes: () => import_canvas20.parseCanvasScenes,
-  parseCssEasing: () => import_canvas26.parseCssEasing,
-  parseCssGradient: () => import_canvas27.parseCssGradient,
-  parseKeyframeClipboard: () => import_canvas26.parseKeyframeClipboard,
-  parseOklab: () => import_canvas26.parseOklab,
-  parseSvgPath: () => import_canvas21.parseSvgPath,
-  pasteKeyframes: () => import_canvas26.pasteKeyframes,
-  pathBoolean: () => import_canvas22.pathBoolean,
-  placeBeside: () => import_canvas23.placeBeside,
-  playWebAnimations: () => import_canvas26.playWebAnimations,
-  pointInBezierPath: () => import_canvas22.pointInBezierPath,
-  pointInMultiPolygon: () => import_canvas21.pointInMultiPolygon,
-  pointInRings: () => import_canvas21.pointInRings,
-  polygonArea: () => import_canvas21.polygonArea,
-  polygonBoolean: () => import_canvas21.polygonBoolean,
-  polygonToSvgPath: () => import_canvas21.polygonToSvgPath,
-  positionToSide: () => import_canvas20.positionToSide,
-  pruneCanvasTokenModes: () => import_canvas25.pruneCanvasTokenModes,
-  pushCanvasInstanceOverrides: () => import_canvas27.pushCanvasInstanceOverrides,
-  readAnimatableValue: () => import_canvas26.readAnimatableValue,
-  readNodeStyleProperty: () => import_canvas25.readNodeStyleProperty,
-  readStyleSize: () => import_canvas20.readStyleSize,
-  realClock: () => import_canvas23.realClock,
-  recordAnimationChanges: () => import_canvas26.recordAnimationChanges,
-  relayoutUpdates: () => import_canvas24.relayoutUpdates,
-  remapPastedNodes: () => import_canvas23.remapPastedNodes,
-  removeCanvasVariant: () => import_canvas27.removeCanvasVariant,
-  removeTrack: () => import_canvas26.removeTrack,
-  renameCanvasVariantProperty: () => import_canvas27.renameCanvasVariantProperty,
-  renameCanvasVariantValue: () => import_canvas27.renameCanvasVariantValue,
-  reorderNodes: () => import_canvas20.reorderNodes,
-  repositionNodesTo: () => import_canvas23.repositionNodesTo,
-  resetCanvasInstanceOverrides: () => import_canvas27.resetCanvasInstanceOverrides,
-  resizeHandleAxes: () => import_canvas19.resizeHandleAxes,
-  resolveCanvasGradient: () => import_canvas27.resolveCanvasGradient,
-  resolveCanvasTokens: () => import_canvas25.resolveCanvasTokens,
-  resolveEasing: () => import_canvas26.resolveEasing,
-  resolvePadding: () => import_canvas24.resolvePadding,
-  restoreCanvasMainComponent: () => import_canvas27.restoreCanvasMainComponent,
-  revertShapeCombination: () => import_canvas21.revertShapeCombination,
-  rgbToOklab: () => import_canvas26.rgbToOklab,
-  ringSignedArea: () => import_canvas21.ringSignedArea,
-  runMultiNodeTransition: () => import_canvas23.runMultiNodeTransition,
-  sampleAnimationFrames: () => import_canvas26.sampleAnimationFrames,
-  scaleKeyframes: () => import_canvas26.scaleKeyframes,
-  serializeCanvasNodes: () => import_canvas23.serializeCanvasNodes,
-  setCanvasComponentProperty: () => import_canvas27.setCanvasComponentProperty,
-  setCanvasInstanceProperties: () => import_canvas27.setCanvasInstanceProperties,
-  setCanvasTokenMode: () => import_canvas25.setCanvasTokenMode,
-  setCanvasVariantProperties: () => import_canvas27.setCanvasVariantProperties,
-  setKeyframe: () => import_canvas26.setKeyframe,
-  setKeyframeEasing: () => import_canvas26.setKeyframeEasing,
-  setMotionPath: () => import_canvas26.setMotionPath,
-  setTrackEnabled: () => import_canvas26.setTrackEnabled,
-  shapeNodeToBezierPath: () => import_canvas22.shapeNodeToBezierPath,
-  shapeNodeToPolygon: () => import_canvas21.shapeNodeToPolygon,
-  shapeToBezierPath: () => import_canvas22.shapeToBezierPath,
-  shapeToPolygon: () => import_canvas21.shapeToPolygon,
-  sideToPosition: () => import_canvas20.sideToPosition,
-  simplifyRing: () => import_canvas21.simplifyRing,
-  snapKeyframeDelta: () => import_canvas26.snapKeyframeDelta,
-  snapNodeDrag: () => import_canvas20.snapNodeDrag,
-  snapNodeResize: () => import_canvas19.snapNodeResize,
-  snapResize: () => import_canvas19.snapResize,
-  snapTimeToFrame: () => import_canvas26.snapTimeToFrame,
-  snapToGrid: () => import_canvas19.snapToGrid,
-  springAt: () => import_canvas26.springAt,
-  streamlinePoints: () => import_canvas27.streamlinePoints,
-  strokeOutlineRings: () => import_canvas22.strokeOutlineRings,
-  strokePointsToPathData: () => import_canvas27.strokePointsToPathData,
-  strokeToShapeNode: () => import_canvas27.strokeToShapeNode,
-  subtractPaths: () => import_canvas22.subtractPaths,
-  subtractPolygons: () => import_canvas21.subtractPolygons,
-  swapCanvasInstance: () => import_canvas27.swapCanvasInstance,
-  syncAllCanvasInstances: () => import_canvas27.syncAllCanvasInstances,
-  syncCanvasComponents: () => import_canvas27.syncCanvasComponents,
-  syncCanvasInstance: () => import_canvas27.syncCanvasInstance,
-  timeToX: () => import_canvas26.timeToX,
-  toBezierPath: () => import_canvas22.toBezierPath,
-  toWebAnimations: () => import_canvas26.toWebAnimations,
-  toggleLockNodes: () => import_canvas20.toggleLockNodes,
-  transformBezierPath: () => import_canvas22.transformBezierPath,
-  unionPolygons: () => import_canvas21.unionPolygons,
-  unitePaths: () => import_canvas22.unitePaths,
-  unlockNodes: () => import_canvas20.unlockNodes,
-  updateKeyframe: () => import_canvas26.updateKeyframe,
+  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,
+  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,
   useCanvasAnimation: () => useCanvasAnimation,
   useCanvasArrange: () => useCanvasArrange,
   useCanvasArrangeShortcuts: () => useCanvasArrangeShortcuts,
@@ -342,14 +346,19 @@ __export(canvas_exports, {
   useCanvasScenes: () => useCanvasScenes,
   useCanvasShortcuts: () => useCanvasShortcuts,
   useCanvasTokens: () => useCanvasTokens,
+  useDiagramDirector: () => useDiagramDirector,
+  useDiagramState: () => useDiagramState,
+  useMermaidDiagram: () => useMermaidDiagram,
+  useMermaidStream: () => useMermaidStream,
+  usePresenceState: () => usePresenceState,
   useStreamingCanvas: () => useStreamingCanvas,
-  withNodeAnimation: () => import_canvas26.withNodeAnimation,
-  withStyleSize: () => import_canvas20.withStyleSize,
-  wouldCreateComponentCycle: () => import_canvas27.wouldCreateComponentCycle,
-  wrapAnimationTime: () => import_canvas26.wrapAnimationTime,
-  writeNodeStyleProperty: () => import_canvas25.writeNodeStyleProperty,
-  xToTime: () => import_canvas26.xToTime,
-  xorPolygons: () => import_canvas21.xorPolygons
+  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
 });
 module.exports = __toCommonJS(canvas_exports);
 
@@ -1568,8 +1577,8 @@ function useCanvasMeasure(options) {
 }
 
 // src/canvas/index.ts
-var import_canvas19 = require("@pixerate/editor/canvas");
-var import_canvas20 = require("@pixerate/editor/canvas");
+var import_canvas21 = require("@pixerate/editor/canvas");
+var import_canvas22 = require("@pixerate/editor/canvas");
 
 // src/canvas/ShapeNode.tsx
 var import_canvas11 = require("@pixerate/editor/canvas");
@@ -1627,10 +1636,10 @@ function ShapeNode({ id, data, width, height, selected, className = "", children
 }
 
 // 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");
 var import_canvas24 = require("@pixerate/editor/canvas");
+var import_canvas25 = require("@pixerate/editor/canvas");
+var import_canvas26 = require("@pixerate/editor/canvas");
 
 // src/canvas/useCanvasAutoLayout.ts
 var import_react13 = require("react");
@@ -1842,7 +1851,7 @@ function TokenModeSwitcher({
 }
 
 // src/canvas/index.ts
-var import_canvas25 = require("@pixerate/editor/canvas");
+var import_canvas27 = require("@pixerate/editor/canvas");
 
 // src/canvas/useCanvasAnimation.ts
 var import_react15 = require("react");
@@ -2096,7 +2105,7 @@ function AnimationTimeline({ animation, nodeIds, width = 360, snapThreshold = 8,
 }
 
 // src/canvas/index.ts
-var import_canvas26 = require("@pixerate/editor/canvas");
+var import_canvas28 = require("@pixerate/editor/canvas");
 
 // src/canvas/useCanvasComponents.ts
 var import_react17 = require("react");
@@ -2507,7 +2516,193 @@ function CanvasInstanceInspector({
 }
 
 // src/canvas/index.ts
-var import_canvas27 = require("@pixerate/editor/canvas");
+var import_canvas29 = require("@pixerate/editor/canvas");
+
+// src/canvas/useMermaidDiagram.ts
+var import_react19 = require("react");
+var import_diagram = require("@pixerate/editor/diagram");
+var import_canvas19 = require("@pixerate/editor/canvas");
+function useDiagramState(controller) {
+  return (0, import_react19.useSyncExternalStore)(controller.subscribe, controller.getState, controller.getState);
+}
+function useMermaidDiagram(controllerOrOptions = {}) {
+  const own = (0, import_react19.useRef)(null);
+  let controller;
+  if (controllerOrOptions instanceof import_diagram.DiagramController) controller = controllerOrOptions;
+  else {
+    if (!own.current) own.current = new import_diagram.DiagramController(controllerOrOptions);
+    controller = own.current;
+  }
+  const layoutOptions = controllerOrOptions instanceof import_diagram.DiagramController ? void 0 : controllerOrOptions.layoutOptions;
+  const state = useDiagramState(controller);
+  const canvas = (0, import_react19.useMemo)(
+    () => (0, import_canvas19.mermaidToCanvas)(state.document, { ...layoutOptions, editable: state.editable }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [state.document, state.editable]
+  );
+  const layoutRef = (0, import_react19.useRef)(canvas.layout);
+  layoutRef.current = canvas.layout;
+  const actions = (0, import_react19.useMemo)(
+    () => ({
+      apply: (ops, label) => controller.apply(ops, label),
+      load: (source, options) => controller.load(source, options),
+      moveNodes: (moved, all = moved) => {
+        const op = (0, import_canvas19.mermaidMovesFromCanvas)(layoutRef.current, moved, all, { stored: controller.getDocument().meta.layout ?? {} });
+        return op ? controller.apply(op, "Move") : null;
+      },
+      connect: (source, target, label) => controller.apply({ type: "addEdge", edge: { source, target, ...label ? { label } : {} } }, "Connect"),
+      remove: (ids) => {
+        const graph = controller.getDocument().graph;
+        const edgeIds = new Set(graph.edges.map((e) => e.id));
+        const edges = ids.filter((id) => edgeIds.has(id));
+        const nodes = ids.filter((id) => !edgeIds.has(id));
+        const ops = [];
+        if (edges.length) ops.push({ type: "removeEdges", ids: edges });
+        if (nodes.length) ops.push({ type: "removeNodes", ids: nodes });
+        return controller.apply(ops, "Delete");
+      },
+      rename: (id, label) => controller.apply(
+        controller.getDocument().graph.groups.some((g) => g.id === id) ? { type: "renameGroup", id, label } : { type: "renameNode", id, label },
+        "Rename"
+      ),
+      select: (ids) => controller.select(ids),
+      undo: () => void controller.undo(),
+      redo: () => void controller.redo()
+    }),
+    [controller]
+  );
+  return { controller, state, document: state.document, source: state.source, ...canvas, ...actions };
+}
+function useMermaidStream(source, options = {}) {
+  const { complete = false, duration = 300, ...layoutOptions } = options;
+  const stream = (0, import_react19.useRef)(null);
+  if (!stream.current) stream.current = new import_canvas19.DiagramStream(layoutOptions);
+  const result = (0, import_react19.useMemo)(() => stream.current.update(source, complete), [source, complete]);
+  const [shown, setShown] = (0, import_react19.useState)({ layout: result.layout, settled: true });
+  const shownRef = (0, import_react19.useRef)(shown.layout);
+  shownRef.current = shown.layout;
+  (0, import_react19.useEffect)(() => {
+    const target = result.layout;
+    if (!target) return setShown({ layout: null, settled: true });
+    const from = shownRef.current;
+    if (!from || duration <= 0 || typeof requestAnimationFrame !== "function") return setShown({ layout: target, settled: true });
+    if (from === target) return;
+    let frame = 0;
+    const start = performance.now();
+    const step = () => {
+      const t = Math.min(1, (performance.now() - start) / duration);
+      setShown({ layout: (0, import_canvas19.blendDiagramLayout)(from, target, (0, import_canvas19.easeDiagramTween)(t)), settled: t >= 1 });
+      if (t < 1) frame = requestAnimationFrame(step);
+    };
+    frame = requestAnimationFrame(step);
+    return () => cancelAnimationFrame(frame);
+  }, [result.layout, duration]);
+  const doc = result.document.tier === "editable" ? result.document : null;
+  const canvas = (0, import_react19.useMemo)(() => {
+    if (!doc || !shown.layout) return { nodes: [], edges: [] };
+    const placed = new Set(Object.keys(shown.layout.positions));
+    const graph = {
+      ...doc.graph,
+      nodes: doc.graph.nodes.filter((n) => placed.has(n.id)),
+      groups: doc.graph.groups.filter((g) => placed.has(g.id)),
+      edges: doc.graph.edges.filter((e) => placed.has(e.source) && placed.has(e.target))
+    };
+    return (0, import_canvas19.mermaidToCanvas)({ ...doc, graph }, { layout: shown.layout });
+  }, [doc, shown.layout]);
+  return { document: doc, ...canvas, layout: shown.layout, settled: shown.settled };
+}
+
+// src/canvas/MermaidDiagramNode.tsx
+var import_canvas20 = require("@pixerate/editor/canvas");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function mermaidNodeStyle(styles = {}, selected = false) {
+  const paint = (0, import_canvas20.mermaidNodePaint)(styles, selected);
+  const { color, "stroke-width": strokeWidth, "stroke-dasharray": strokeDasharray, ...vars } = paint;
+  return { ...vars, color, strokeWidth, strokeDasharray };
+}
+function MermaidDiagramNode({ data, width = 160, height = 56, selected, className = "", children }) {
+  const node = data.node;
+  if (!node) return null;
+  const members = (0, import_canvas20.mermaidNodeMembers)(node.data);
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+    "div",
+    {
+      className: `pixerate-diagram-node ${className}`.trim(),
+      "data-shape": node.shape,
+      "data-selected": selected ? "true" : void 0,
+      style: { position: "relative", width: "100%", height: "100%", ...mermaidNodeStyle(data.resolvedStyles, selected) },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("svg", { viewBox: `0 0 ${width} ${height}`, preserveAspectRatio: "none", width: "100%", height: "100%", style: { position: "absolute", inset: 0, overflow: "visible" }, "aria-hidden": "true", children: (0, import_canvas20.mermaidShapePaths)(node.shape, width, height).map((path, i) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { d: path.d, style: { ...import_canvas20.MERMAID_SHAPE_PAINT[path.paint], vectorEffect: "non-scaling-stroke" } }, i)) }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+          "div",
+          {
+            style: { position: "relative", display: "flex", flexDirection: "column", alignItems: "center", justifyContent: members.length ? "flex-start" : "center", height: "100%", padding: "6px 10px", boxSizing: "border-box", fontSize: 13, lineHeight: 1.3, textAlign: "center", pointerEvents: "none" },
+            children: [
+              (0, import_canvas20.mermaidLabelLines)(node.label).map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { style: { fontWeight: members.length ? 600 : void 0 }, children: line }, i)),
+              members.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { style: { alignSelf: "stretch", marginTop: 4, paddingTop: 4, borderTop: "1px solid var(--pixerate-diagram-node-border)", textAlign: "left", fontSize: 12 }, children: members.map((m, i) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { children: m }, i)) })
+            ]
+          }
+        ),
+        children
+      ]
+    }
+  );
+}
+function MermaidDiagramGroup({ data, selected, className = "", children }) {
+  const group = data.group;
+  if (!group) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+    "div",
+    {
+      className: `pixerate-diagram-group ${className}`.trim(),
+      "data-selected": selected ? "true" : void 0,
+      style: {
+        width: "100%",
+        height: "100%",
+        boxSizing: "border-box",
+        borderRadius: 8,
+        border: `1px ${selected ? "solid" : "dashed"} ${selected ? "var(--primary, #2563eb)" : data.resolvedStyles?.stroke ?? "var(--border, #cbd5e1)"}`,
+        background: data.resolvedStyles?.fill ?? "var(--muted, rgba(148, 163, 184, 0.08))",
+        color: data.resolvedStyles?.color ?? "var(--muted-foreground, #475569)"
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { style: { padding: "6px 10px", fontSize: 12, fontWeight: 600 }, children: (0, import_canvas20.mermaidLabelLines)(group.label).join(" ") }),
+        children
+      ]
+    }
+  );
+}
+
+// src/canvas/useDiagramDirector.ts
+var import_react20 = require("react");
+var import_diagram2 = require("@pixerate/editor/diagram");
+function useDiagramDirector(controller, options) {
+  const placement = (0, import_react20.useRef)(options.placement);
+  placement.current = options.placement;
+  const ref = (0, import_react20.useRef)(null);
+  if (!ref.current) {
+    const presence = new import_diagram2.PresenceStore();
+    ref.current = {
+      presence,
+      director: new import_diagram2.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);
+}
+
+// src/canvas/DiagramPresenceLayer.tsx
+var import_jsx_runtime9 = 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 })
+  ] }, a.id)) });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ANIMATABLE_PROPERTIES,
@@ -2533,8 +2728,11 @@ var import_canvas27 = require("@pixerate/editor/canvas");
   CanvasInstanceInspector,
   CanvasScenesStore,
   DEFAULT_ARRANGE_SHORTCUTS,
+  DiagramPresenceLayer,
   MAX_KEYFRAME_REFS,
   ManualClock,
+  MermaidDiagramGroup,
+  MermaidDiagramNode,
   RESIZE_HANDLES,
   SHAPE_DATA_KEY,
   SHAPE_KINDS,
@@ -2715,6 +2913,7 @@ var import_canvas27 = require("@pixerate/editor/canvas");
   measureSelection,
   measureToLine,
   mergeNodeUpdates,
+  mermaidNodeStyle,
   mixColorsOklab,
   moveKeyframes,
   moveLayoutChild,
@@ -2832,6 +3031,11 @@ var import_canvas27 = require("@pixerate/editor/canvas");
   useCanvasScenes,
   useCanvasShortcuts,
   useCanvasTokens,
+  useDiagramDirector,
+  useDiagramState,
+  useMermaidDiagram,
+  useMermaidStream,
+  usePresenceState,
   useStreamingCanvas,
   withNodeAnimation,
   withStyleSize,