@pixerate/editor-react 0.166.0 → 0.169.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -31,23 +31,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
31
31
  // src/canvas/index.ts
32
32
  var canvas_exports = {};
33
33
  __export(canvas_exports, {
34
- ANIMATABLE_PROPERTIES: () => import_canvas37.ANIMATABLE_PROPERTIES,
35
- ANIMATION_DATA_KEY: () => import_canvas37.ANIMATION_DATA_KEY,
36
- ANIMATION_EASING_LABELS: () => import_canvas37.ANIMATION_EASING_LABELS,
37
- ANIMATION_EASING_PRESETS: () => import_canvas37.ANIMATION_EASING_PRESETS,
38
- ANIMATION_TIME_EPSILON: () => import_canvas37.ANIMATION_TIME_EPSILON,
39
- AUTO_LAYOUT_DATA_KEY: () => import_canvas35.AUTO_LAYOUT_DATA_KEY,
34
+ ANIMATABLE_PROPERTIES: () => import_canvas38.ANIMATABLE_PROPERTIES,
35
+ ANIMATION_DATA_KEY: () => import_canvas38.ANIMATION_DATA_KEY,
36
+ ANIMATION_EASING_LABELS: () => import_canvas38.ANIMATION_EASING_LABELS,
37
+ ANIMATION_EASING_PRESETS: () => import_canvas38.ANIMATION_EASING_PRESETS,
38
+ ANIMATION_TIME_EPSILON: () => import_canvas38.ANIMATION_TIME_EPSILON,
39
+ AUTO_LAYOUT_DATA_KEY: () => import_canvas36.AUTO_LAYOUT_DATA_KEY,
40
40
  AgentPresenceLayer: () => AgentPresenceLayer,
41
- AnimationEditError: () => import_canvas37.AnimationEditError,
42
- AnimationPlayer: () => import_canvas37.AnimationPlayer,
41
+ AnimationEditError: () => import_canvas38.AnimationEditError,
42
+ AnimationPlayer: () => import_canvas38.AnimationPlayer,
43
43
  AnimationTimeline: () => AnimationTimeline,
44
- CANVAS_COMPONENT_DRAG_TYPE: () => import_canvas38.CANVAS_COMPONENT_DRAG_TYPE,
45
- CANVAS_GRADIENT_PRESETS: () => import_canvas38.CANVAS_GRADIENT_PRESETS,
46
- CANVAS_TOKEN_PROPERTIES: () => import_canvas36.CANVAS_TOKEN_PROPERTIES,
47
- CHILD_LAYOUT_DATA_KEY: () => import_canvas35.CHILD_LAYOUT_DATA_KEY,
48
- CONNECTION_LINE_TYPES: () => import_canvas31.CONNECTION_LINE_TYPES,
49
- CSS_ANIMATION_PROPERTIES: () => import_canvas37.CSS_ANIMATION_PROPERTIES,
50
- CUBIC_BEZIER_PRESETS: () => import_canvas37.CUBIC_BEZIER_PRESETS,
44
+ CANVAS_COMPONENT_DRAG_TYPE: () => import_canvas39.CANVAS_COMPONENT_DRAG_TYPE,
45
+ CANVAS_GRADIENT_PRESETS: () => import_canvas39.CANVAS_GRADIENT_PRESETS,
46
+ CANVAS_PROPOSAL_CLASS: () => import_canvas40.CANVAS_PROPOSAL_CLASS,
47
+ CANVAS_TOKEN_PROPERTIES: () => import_canvas37.CANVAS_TOKEN_PROPERTIES,
48
+ CHILD_LAYOUT_DATA_KEY: () => import_canvas36.CHILD_LAYOUT_DATA_KEY,
49
+ CONNECTION_LINE_TYPES: () => import_canvas32.CONNECTION_LINE_TYPES,
50
+ CSS_ANIMATION_PROPERTIES: () => import_canvas38.CSS_ANIMATION_PROPERTIES,
51
+ CUBIC_BEZIER_PRESETS: () => import_canvas38.CUBIC_BEZIER_PRESETS,
51
52
  CanvasComponentsPanel: () => CanvasComponentsPanel,
52
53
  CanvasDrawLayer: () => CanvasDrawLayer,
53
54
  CanvasEffectsPanel: () => CanvasEffectsPanel,
@@ -55,326 +56,330 @@ __export(canvas_exports, {
55
56
  CanvasGuidesLayer: () => CanvasGuidesLayer,
56
57
  CanvasInstanceInspector: () => CanvasInstanceInspector,
57
58
  CanvasNodeEffectLayer: () => CanvasNodeEffectLayer,
58
- CanvasScenesStore: () => import_canvas31.CanvasScenesStore,
59
- DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas31.DEFAULT_ARRANGE_SHORTCUTS,
59
+ CanvasScenesStore: () => import_canvas32.CanvasScenesStore,
60
+ DEFAULT_ARRANGE_SHORTCUTS: () => import_canvas32.DEFAULT_ARRANGE_SHORTCUTS,
60
61
  DiagramPresenceLayer: () => DiagramPresenceLayer,
61
- MAX_KEYFRAME_REFS: () => import_canvas37.MAX_KEYFRAME_REFS,
62
- ManualClock: () => import_canvas34.ManualClock,
62
+ MAX_KEYFRAME_REFS: () => import_canvas38.MAX_KEYFRAME_REFS,
63
+ ManualClock: () => import_canvas35.ManualClock,
63
64
  MermaidDiagramGroup: () => MermaidDiagramGroup,
64
65
  MermaidDiagramNode: () => MermaidDiagramNode,
65
66
  MermaidFamilyScene: () => MermaidFamilyScene,
66
67
  MermaidThumbnail: () => MermaidThumbnail,
67
68
  PresenceLayer: () => PresenceLayer,
68
- RESIZE_HANDLES: () => import_canvas30.RESIZE_HANDLES,
69
- SHAPE_DATA_KEY: () => import_canvas32.SHAPE_DATA_KEY,
70
- SHAPE_KINDS: () => import_canvas32.SHAPE_KINDS,
71
- SHAPE_NODE_TYPE: () => import_canvas32.SHAPE_NODE_TYPE,
72
- SHAPE_OPERATIONS: () => import_canvas32.SHAPE_OPERATIONS,
69
+ RESIZE_HANDLES: () => import_canvas31.RESIZE_HANDLES,
70
+ SHAPE_DATA_KEY: () => import_canvas33.SHAPE_DATA_KEY,
71
+ SHAPE_KINDS: () => import_canvas33.SHAPE_KINDS,
72
+ SHAPE_NODE_TYPE: () => import_canvas33.SHAPE_NODE_TYPE,
73
+ SHAPE_OPERATIONS: () => import_canvas33.SHAPE_OPERATIONS,
73
74
  ShapeNode: () => ShapeNode,
74
75
  ShapeNodeZoomContext: () => ShapeNodeZoomContext,
75
76
  ShapeNodeZoomProvider: () => ShapeNodeZoomProvider,
76
- TOKEN_BINDINGS_DATA_KEY: () => import_canvas36.TOKEN_BINDINGS_DATA_KEY,
77
- TOKEN_MODES_DATA_KEY: () => import_canvas36.TOKEN_MODES_DATA_KEY,
77
+ TOKEN_BINDINGS_DATA_KEY: () => import_canvas37.TOKEN_BINDINGS_DATA_KEY,
78
+ TOKEN_MODES_DATA_KEY: () => import_canvas37.TOKEN_MODES_DATA_KEY,
78
79
  TokenBindingPicker: () => TokenBindingPicker,
79
80
  TokenModeSwitcher: () => TokenModeSwitcher,
80
- addCanvasVariant: () => import_canvas38.addCanvasVariant,
81
- addKeyframesAtTime: () => import_canvas37.addKeyframesAtTime,
82
- alignNodes: () => import_canvas31.alignNodes,
83
- angleToSvgLinearCoords: () => import_canvas38.angleToSvgLinearCoords,
84
- animateNode: () => import_canvas37.animateNode,
85
- applyAnimation: () => import_canvas37.applyAnimation,
86
- applyAnimationOverrides: () => import_canvas37.applyAnimationOverrides,
87
- applyConstraints: () => import_canvas35.applyConstraints,
88
- applyNodeUpdates: () => import_canvas31.applyNodeUpdates,
89
- applyShapeCombination: () => import_canvas32.applyShapeCombination,
90
- applyShapeReplacement: () => import_canvas33.applyShapeReplacement,
91
- bezierPathArea: () => import_canvas33.bezierPathArea,
92
- bezierPathBounds: () => import_canvas33.bezierPathBounds,
93
- bezierPathLength: () => import_canvas33.bezierPathLength,
94
- bezierPathPointAtLength: () => import_canvas33.bezierPathPointAtLength,
95
- bezierPathSignedArea: () => import_canvas33.bezierPathSignedArea,
96
- bezierPathToSvg: () => import_canvas33.bezierPathToSvg,
97
- bindCanvasComponentProperty: () => import_canvas38.bindCanvasComponentProperty,
98
- bindCanvasToken: () => import_canvas36.bindCanvasToken,
99
- blendLayout: () => import_canvas34.blendLayout,
100
- boundsOf: () => import_canvas34.boundsOf,
101
- brushstrokeScaleBucket: () => import_canvas38.brushstrokeScaleBucket,
102
- brushstrokeSeed: () => import_canvas38.brushstrokeSeed,
103
- calculateDagreReflowDisplacement: () => import_canvas34.calculateDagreReflowDisplacement,
104
- calculateDirectionalDisplacement: () => import_canvas34.calculateDirectionalDisplacement,
105
- calculateReflowDisplacement: () => import_canvas34.calculateReflowDisplacement,
106
- canCombineShapeNodes: () => import_canvas32.canCombineShapeNodes,
107
- canOffsetShapeNodes: () => import_canvas33.canOffsetShapeNodes,
108
- canOutlineShapeNodeStrokes: () => import_canvas33.canOutlineShapeNodeStrokes,
109
- canvasExplosionToolTarget: () => import_canvas29.canvasExplosionToolTarget,
110
- canvasHeight: () => import_canvas34.canvasHeight,
111
- centerNodes: () => import_canvas34.centerNodes,
112
- centre: () => import_canvas34.centre,
113
- clampAnimationValue: () => import_canvas37.clampAnimationValue,
114
- clampLayoutSize: () => import_canvas35.clampLayoutSize,
115
- combineCanvasComponentsAsVariants: () => import_canvas38.combineCanvasComponentsAsVariants,
116
- combineShapeNodes: () => import_canvas32.combineShapeNodes,
117
- computeCanvasExplosionLayout: () => import_canvas29.computeCanvasExplosionLayout,
118
- computeNodesBoundingBox: () => import_canvas34.computeNodesBoundingBox,
119
- computeSnapGuides: () => import_canvas31.computeSnapGuides,
120
- connectedOnly: () => import_canvas34.connectedOnly,
121
- copyKeyframes: () => import_canvas37.copyKeyframes,
122
- countPathSegments: () => import_canvas33.countPathSegments,
123
- createAnimationPlayer: () => import_canvas37.createAnimationPlayer,
124
- createBezierTrajectory: () => import_canvas34.createBezierTrajectory,
125
- createCanvasAnimationController: () => import_canvas37.createCanvasAnimationController,
126
- createCanvasAutoLayoutController: () => import_canvas35.createCanvasAutoLayoutController,
127
- createCanvasComponent: () => import_canvas38.createCanvasComponent,
128
- createCanvasComponentsController: () => import_canvas38.createCanvasComponentsController,
129
- createCanvasDrawController: () => import_canvas38.createCanvasDrawController,
130
- createCanvasExplosionStateController: () => import_canvas29.createCanvasExplosionStateController,
131
- createCanvasExplosionToolProvider: () => import_canvas29.createCanvasExplosionToolProvider,
132
- createCanvasInstance: () => import_canvas38.createCanvasInstance,
133
- createCanvasScenesStore: () => import_canvas31.createCanvasScenesStore,
134
- createDefaultStrokeStyle: () => import_canvas38.createDefaultStrokeStyle,
135
- createFanOutTrajectory: () => import_canvas34.createFanOutTrajectory,
136
- createGuideIndex: () => import_canvas31.createGuideIndex,
137
- createNodeGuideIndex: () => import_canvas31.createNodeGuideIndex,
138
- cubicBezierAt: () => import_canvas37.cubicBezierAt,
139
- cubicPointAt: () => import_canvas30.cubicPointAt,
140
- cubicsToPathData: () => import_canvas30.cubicsToPathData,
141
- dashContours: () => import_canvas33.dashContours,
142
- defaultEasing: () => import_canvas34.defaultEasing,
143
- deleteKeyframes: () => import_canvas37.deleteKeyframes,
144
- detachCanvasInstance: () => import_canvas38.detachCanvasInstance,
145
- detachTokenBindings: () => import_canvas36.detachTokenBindings,
146
- distanceToBezierPath: () => import_canvas33.distanceToBezierPath,
147
- distributeNodes: () => import_canvas31.distributeNodes,
148
- dividePaths: () => import_canvas33.dividePaths,
149
- dividePolygons: () => import_canvas32.dividePolygons,
150
- easingFromInfluence: () => import_canvas37.easingFromInfluence,
151
- easingLabel: () => import_canvas37.easingLabel,
152
- easingToCss: () => import_canvas37.easingToCss,
153
- ensureLayout: () => import_canvas34.ensureLayout,
154
- estimateCanvasHeight: () => import_canvas34.estimateCanvasHeight,
155
- estimateNodeSize: () => import_canvas34.estimateNodeSize,
156
- evaluateAnimation: () => import_canvas37.evaluateAnimation,
157
- evaluateEasing: () => import_canvas37.evaluateEasing,
158
- evaluateTrack: () => import_canvas37.evaluateTrack,
159
- excludePaths: () => import_canvas33.excludePaths,
160
- explosionEdgeId: () => import_canvas29.explosionEdgeId,
161
- exportCssAnimation: () => import_canvas37.exportCssAnimation,
162
- findConnectorSnap: () => import_canvas31.findConnectorSnap,
163
- findStrokesAtPoint: () => import_canvas38.findStrokesAtPoint,
164
- fitCubicRun: () => import_canvas30.fitCubicRun,
165
- fitCubics: () => import_canvas30.fitCubics,
166
- fitFreehandPath: () => import_canvas30.fitFreehandPath,
167
- fitPathData: () => import_canvas30.fitPathData,
168
- fitViewportToNodes: () => import_canvas31.fitViewportToNodes,
169
- fitViewportToRect: () => import_canvas31.fitViewportToRect,
170
- flattenSvgPath: () => import_canvas32.flattenSvgPath,
171
- flowSide: () => import_canvas34.flowSide,
172
- formatAnimationTime: () => import_canvas37.formatAnimationTime,
173
- formatOklab: () => import_canvas37.formatOklab,
174
- freehandBrushstroke: () => import_canvas38.freehandBrushstroke,
175
- getAbsolutePosition: () => import_canvas31.getAbsolutePosition,
176
- getAnimatableProperty: () => import_canvas37.getAnimatableProperty,
177
- getAnimatedProperties: () => import_canvas37.getAnimatedProperties,
178
- getAnimatedValue: () => import_canvas37.getAnimatedValue,
179
- getAnimationDuration: () => import_canvas37.getAnimationDuration,
180
- getAnimationTrack: () => import_canvas37.getAnimationTrack,
181
- getAutoLayout: () => import_canvas35.getAutoLayout,
182
- getAutoLayoutGrid: () => import_canvas35.getAutoLayoutGrid,
183
- getAutoLayoutInsertTarget: () => import_canvas35.getAutoLayoutInsertTarget,
184
- getBindableTokenProperties: () => import_canvas36.getBindableTokenProperties,
185
- getBrushedShapeSvg: () => import_canvas38.getBrushedShapeSvg,
186
- getCanvasComponentDragId: () => import_canvas38.getCanvasComponentDragId,
187
- getCanvasTokenProperty: () => import_canvas36.getCanvasTokenProperty,
188
- getCenteredNodePosition: () => import_canvas34.getCenteredNodePosition,
189
- getChildLayout: () => import_canvas35.getChildLayout,
190
- getComponentSourceId: () => import_canvas38.getComponentSourceId,
191
- getCssPropertyAnimations: () => import_canvas37.getCssPropertyAnimations,
192
- getEffectiveTokenModes: () => import_canvas36.getEffectiveTokenModes,
193
- getFlowChildren: () => import_canvas35.getFlowChildren,
194
- getInstanceData: () => import_canvas38.getInstanceData,
195
- getInstanceStatus: () => import_canvas38.getInstanceStatus,
196
- getKeyframeTimes: () => import_canvas37.getKeyframeTimes,
197
- getLayoutParent: () => import_canvas35.getLayoutParent,
198
- getLayoutSizing: () => import_canvas35.getLayoutSizing,
199
- getLayoutedNodes: () => import_canvas34.getLayoutedNodes,
200
- getNextVariantValues: () => import_canvas38.getNextVariantValues,
201
- getNodeAnimation: () => import_canvas37.getNodeAnimation,
202
- getNodeOverrides: () => import_canvas38.getNodeOverrides,
203
- getNodeRect: () => import_canvas31.getNodeRect,
204
- getNodeShape: () => import_canvas32.getNodeShape,
205
- getNodeSize: () => import_canvas31.getNodeSize,
206
- getNodeTokenBindings: () => import_canvas36.getNodeTokenBindings,
207
- getNodeTokenModes: () => import_canvas36.getNodeTokenModes,
208
- getResizingNodeRect: () => import_canvas30.getResizingNodeRect,
209
- getShapeRenderData: () => import_canvas32.getShapeRenderData,
210
- getShapeSvg: () => import_canvas32.getShapeSvg,
211
- getTimelineRows: () => import_canvas37.getTimelineRows,
212
- getTimelineTicks: () => import_canvas37.getTimelineTicks,
213
- getTokenPropertyScope: () => import_canvas36.getTokenPropertyScope,
214
- getTokensForProperty: () => import_canvas36.getTokensForProperty,
215
- gradientToSvgDef: () => import_canvas38.gradientToSvgDef,
216
- handlePoint: () => import_canvas31.handlePoint,
217
- hasVisibleStroke: () => import_canvas33.hasVisibleStroke,
218
- inferResizeHandle: () => import_canvas30.inferResizeHandle,
219
- inspectCanvasInstance: () => import_canvas38.inspectCanvasInstance,
220
- inspectNodeTokens: () => import_canvas36.inspectNodeTokens,
221
- interpolateAnimationValue: () => import_canvas37.interpolateAnimationValue,
222
- intersectPaths: () => import_canvas33.intersectPaths,
223
- intersectPolygons: () => import_canvas32.intersectPolygons,
224
- invertNodeUpdates: () => import_canvas31.invertNodeUpdates,
225
- isAnimationEasing: () => import_canvas37.isAnimationEasing,
226
- isAnimationKeyframe: () => import_canvas37.isAnimationKeyframe,
227
- isAutoLayoutFrame: () => import_canvas35.isAutoLayoutFrame,
228
- isBrushedShape: () => import_canvas38.isBrushedShape,
229
- isCanvasComponent: () => import_canvas38.isCanvasComponent,
230
- isCanvasComponentSet: () => import_canvas38.isCanvasComponentSet,
231
- isCanvasGradient: () => import_canvas38.isCanvasGradient,
232
- isCanvasInstance: () => import_canvas38.isCanvasInstance,
233
- isCssExportExact: () => import_canvas37.isCssExportExact,
234
- isEventFromTextInput: () => import_canvas34.isEventFromTextInput,
235
- isKeyframeSelected: () => import_canvas37.isKeyframeSelected,
236
- isLocked: () => import_canvas31.isLocked,
237
- isMeasureModifierHeld: () => import_canvas30.isMeasureModifierHeld,
238
- isNodeAnimated: () => import_canvas37.isNodeAnimated,
239
- isShapeDescription: () => import_canvas32.isShapeDescription,
240
- isShapeNode: () => import_canvas32.isShapeNode,
241
- isStraightCubic: () => import_canvas30.isStraightCubic,
242
- isValidCanvasNode: () => import_canvas34.isValidCanvasNode,
243
- isValidUrl: () => import_canvas34.isValidUrl,
244
- layoutAll: () => import_canvas35.layoutAll,
245
- layoutBounds: () => import_canvas34.layoutBounds,
246
- layoutFrame: () => import_canvas35.layoutFrame,
247
- layoutUp: () => import_canvas35.layoutUp,
248
- layoutUpMany: () => import_canvas35.layoutUpMany,
249
- linearPositionTrajectory: () => import_canvas34.linearPositionTrajectory,
250
- linearTrajectory: () => import_canvas34.linearTrajectory,
251
- listCanvasBrushes: () => import_canvas38.listCanvasBrushes,
252
- listCanvasComponents: () => import_canvas38.listCanvasComponents,
253
- loadCanvasBrushstrokeRenderer: () => import_canvas38.loadCanvasBrushstrokeRenderer,
254
- lockNodes: () => import_canvas31.lockNodes,
255
- makeSizingCoherent: () => import_canvas35.makeSizingCoherent,
256
- matchArrangeShortcut: () => import_canvas31.matchArrangeShortcut,
257
- matchSize: () => import_canvas31.matchSize,
258
- measureBetween: () => import_canvas30.measureBetween,
259
- measureLabel: () => import_canvas30.measureLabel,
260
- measureSelection: () => import_canvas30.measureSelection,
261
- measureToLine: () => import_canvas30.measureToLine,
262
- mergeNodeUpdates: () => import_canvas35.mergeNodeUpdates,
81
+ addCanvasVariant: () => import_canvas39.addCanvasVariant,
82
+ addKeyframesAtTime: () => import_canvas38.addKeyframesAtTime,
83
+ alignNodes: () => import_canvas32.alignNodes,
84
+ angleToSvgLinearCoords: () => import_canvas39.angleToSvgLinearCoords,
85
+ animateNode: () => import_canvas38.animateNode,
86
+ applyAnimation: () => import_canvas38.applyAnimation,
87
+ applyAnimationOverrides: () => import_canvas38.applyAnimationOverrides,
88
+ applyConstraints: () => import_canvas36.applyConstraints,
89
+ applyNodeUpdates: () => import_canvas32.applyNodeUpdates,
90
+ applyShapeCombination: () => import_canvas33.applyShapeCombination,
91
+ applyShapeReplacement: () => import_canvas34.applyShapeReplacement,
92
+ bezierPathArea: () => import_canvas34.bezierPathArea,
93
+ bezierPathBounds: () => import_canvas34.bezierPathBounds,
94
+ bezierPathLength: () => import_canvas34.bezierPathLength,
95
+ bezierPathPointAtLength: () => import_canvas34.bezierPathPointAtLength,
96
+ bezierPathSignedArea: () => import_canvas34.bezierPathSignedArea,
97
+ bezierPathToSvg: () => import_canvas34.bezierPathToSvg,
98
+ bindCanvasComponentProperty: () => import_canvas39.bindCanvasComponentProperty,
99
+ bindCanvasToken: () => import_canvas37.bindCanvasToken,
100
+ blendLayout: () => import_canvas35.blendLayout,
101
+ boundsOf: () => import_canvas35.boundsOf,
102
+ brushstrokeScaleBucket: () => import_canvas39.brushstrokeScaleBucket,
103
+ brushstrokeSeed: () => import_canvas39.brushstrokeSeed,
104
+ calculateDagreReflowDisplacement: () => import_canvas35.calculateDagreReflowDisplacement,
105
+ calculateDirectionalDisplacement: () => import_canvas35.calculateDirectionalDisplacement,
106
+ calculateReflowDisplacement: () => import_canvas35.calculateReflowDisplacement,
107
+ canCombineShapeNodes: () => import_canvas33.canCombineShapeNodes,
108
+ canOffsetShapeNodes: () => import_canvas34.canOffsetShapeNodes,
109
+ canOutlineShapeNodeStrokes: () => import_canvas34.canOutlineShapeNodeStrokes,
110
+ canvasExplosionToolTarget: () => import_canvas30.canvasExplosionToolTarget,
111
+ canvasHeight: () => import_canvas35.canvasHeight,
112
+ centerNodes: () => import_canvas35.centerNodes,
113
+ centre: () => import_canvas35.centre,
114
+ clampAnimationValue: () => import_canvas38.clampAnimationValue,
115
+ clampLayoutSize: () => import_canvas36.clampLayoutSize,
116
+ combineCanvasComponentsAsVariants: () => import_canvas39.combineCanvasComponentsAsVariants,
117
+ combineShapeNodes: () => import_canvas33.combineShapeNodes,
118
+ computeCanvasExplosionLayout: () => import_canvas30.computeCanvasExplosionLayout,
119
+ computeNodesBoundingBox: () => import_canvas35.computeNodesBoundingBox,
120
+ computeSnapGuides: () => import_canvas32.computeSnapGuides,
121
+ connectedOnly: () => import_canvas35.connectedOnly,
122
+ copyKeyframes: () => import_canvas38.copyKeyframes,
123
+ countPathSegments: () => import_canvas34.countPathSegments,
124
+ createAnimationPlayer: () => import_canvas38.createAnimationPlayer,
125
+ createBezierTrajectory: () => import_canvas35.createBezierTrajectory,
126
+ createCanvasAnimationController: () => import_canvas38.createCanvasAnimationController,
127
+ createCanvasAutoLayoutController: () => import_canvas36.createCanvasAutoLayoutController,
128
+ createCanvasChangeFeed: () => import_canvas40.createCanvasChangeFeed,
129
+ createCanvasComponent: () => import_canvas39.createCanvasComponent,
130
+ createCanvasComponentsController: () => import_canvas39.createCanvasComponentsController,
131
+ createCanvasDrawController: () => import_canvas39.createCanvasDrawController,
132
+ createCanvasExplosionStateController: () => import_canvas30.createCanvasExplosionStateController,
133
+ createCanvasExplosionToolProvider: () => import_canvas30.createCanvasExplosionToolProvider,
134
+ createCanvasInstance: () => import_canvas39.createCanvasInstance,
135
+ createCanvasProposalToolProvider: () => import_canvas40.createCanvasProposalToolProvider,
136
+ createCanvasProposals: () => import_canvas40.createCanvasProposals,
137
+ createCanvasScenesStore: () => import_canvas32.createCanvasScenesStore,
138
+ createDefaultStrokeStyle: () => import_canvas39.createDefaultStrokeStyle,
139
+ createFanOutTrajectory: () => import_canvas35.createFanOutTrajectory,
140
+ createGuideIndex: () => import_canvas32.createGuideIndex,
141
+ createNodeGuideIndex: () => import_canvas32.createNodeGuideIndex,
142
+ cubicBezierAt: () => import_canvas38.cubicBezierAt,
143
+ cubicPointAt: () => import_canvas31.cubicPointAt,
144
+ cubicsToPathData: () => import_canvas31.cubicsToPathData,
145
+ dashContours: () => import_canvas34.dashContours,
146
+ defaultEasing: () => import_canvas35.defaultEasing,
147
+ deleteKeyframes: () => import_canvas38.deleteKeyframes,
148
+ detachCanvasInstance: () => import_canvas39.detachCanvasInstance,
149
+ detachTokenBindings: () => import_canvas37.detachTokenBindings,
150
+ distanceToBezierPath: () => import_canvas34.distanceToBezierPath,
151
+ distributeNodes: () => import_canvas32.distributeNodes,
152
+ dividePaths: () => import_canvas34.dividePaths,
153
+ dividePolygons: () => import_canvas33.dividePolygons,
154
+ easingFromInfluence: () => import_canvas38.easingFromInfluence,
155
+ easingLabel: () => import_canvas38.easingLabel,
156
+ easingToCss: () => import_canvas38.easingToCss,
157
+ ensureLayout: () => import_canvas35.ensureLayout,
158
+ estimateCanvasHeight: () => import_canvas35.estimateCanvasHeight,
159
+ estimateNodeSize: () => import_canvas35.estimateNodeSize,
160
+ evaluateAnimation: () => import_canvas38.evaluateAnimation,
161
+ evaluateEasing: () => import_canvas38.evaluateEasing,
162
+ evaluateTrack: () => import_canvas38.evaluateTrack,
163
+ excludePaths: () => import_canvas34.excludePaths,
164
+ explosionEdgeId: () => import_canvas30.explosionEdgeId,
165
+ exportCssAnimation: () => import_canvas38.exportCssAnimation,
166
+ findConnectorSnap: () => import_canvas32.findConnectorSnap,
167
+ findStrokesAtPoint: () => import_canvas39.findStrokesAtPoint,
168
+ fitCubicRun: () => import_canvas31.fitCubicRun,
169
+ fitCubics: () => import_canvas31.fitCubics,
170
+ fitFreehandPath: () => import_canvas31.fitFreehandPath,
171
+ fitPathData: () => import_canvas31.fitPathData,
172
+ fitViewportToNodes: () => import_canvas32.fitViewportToNodes,
173
+ fitViewportToRect: () => import_canvas32.fitViewportToRect,
174
+ flattenSvgPath: () => import_canvas33.flattenSvgPath,
175
+ flowSide: () => import_canvas35.flowSide,
176
+ formatAnimationTime: () => import_canvas38.formatAnimationTime,
177
+ formatOklab: () => import_canvas38.formatOklab,
178
+ freehandBrushstroke: () => import_canvas39.freehandBrushstroke,
179
+ getAbsolutePosition: () => import_canvas32.getAbsolutePosition,
180
+ getAnimatableProperty: () => import_canvas38.getAnimatableProperty,
181
+ getAnimatedProperties: () => import_canvas38.getAnimatedProperties,
182
+ getAnimatedValue: () => import_canvas38.getAnimatedValue,
183
+ getAnimationDuration: () => import_canvas38.getAnimationDuration,
184
+ getAnimationTrack: () => import_canvas38.getAnimationTrack,
185
+ getAutoLayout: () => import_canvas36.getAutoLayout,
186
+ getAutoLayoutGrid: () => import_canvas36.getAutoLayoutGrid,
187
+ getAutoLayoutInsertTarget: () => import_canvas36.getAutoLayoutInsertTarget,
188
+ getBindableTokenProperties: () => import_canvas37.getBindableTokenProperties,
189
+ getBrushedShapeSvg: () => import_canvas39.getBrushedShapeSvg,
190
+ getCanvasComponentDragId: () => import_canvas39.getCanvasComponentDragId,
191
+ getCanvasTokenProperty: () => import_canvas37.getCanvasTokenProperty,
192
+ getCenteredNodePosition: () => import_canvas35.getCenteredNodePosition,
193
+ getChildLayout: () => import_canvas36.getChildLayout,
194
+ getComponentSourceId: () => import_canvas39.getComponentSourceId,
195
+ getCssPropertyAnimations: () => import_canvas38.getCssPropertyAnimations,
196
+ getEffectiveTokenModes: () => import_canvas37.getEffectiveTokenModes,
197
+ getFlowChildren: () => import_canvas36.getFlowChildren,
198
+ getInstanceData: () => import_canvas39.getInstanceData,
199
+ getInstanceStatus: () => import_canvas39.getInstanceStatus,
200
+ getKeyframeTimes: () => import_canvas38.getKeyframeTimes,
201
+ getLayoutParent: () => import_canvas36.getLayoutParent,
202
+ getLayoutSizing: () => import_canvas36.getLayoutSizing,
203
+ getLayoutedNodes: () => import_canvas35.getLayoutedNodes,
204
+ getNextVariantValues: () => import_canvas39.getNextVariantValues,
205
+ getNodeAnimation: () => import_canvas38.getNodeAnimation,
206
+ getNodeOverrides: () => import_canvas39.getNodeOverrides,
207
+ getNodeRect: () => import_canvas32.getNodeRect,
208
+ getNodeShape: () => import_canvas33.getNodeShape,
209
+ getNodeSize: () => import_canvas32.getNodeSize,
210
+ getNodeTokenBindings: () => import_canvas37.getNodeTokenBindings,
211
+ getNodeTokenModes: () => import_canvas37.getNodeTokenModes,
212
+ getResizingNodeRect: () => import_canvas31.getResizingNodeRect,
213
+ getShapeRenderData: () => import_canvas33.getShapeRenderData,
214
+ getShapeSvg: () => import_canvas33.getShapeSvg,
215
+ getTimelineRows: () => import_canvas38.getTimelineRows,
216
+ getTimelineTicks: () => import_canvas38.getTimelineTicks,
217
+ getTokenPropertyScope: () => import_canvas37.getTokenPropertyScope,
218
+ getTokensForProperty: () => import_canvas37.getTokensForProperty,
219
+ gradientToSvgDef: () => import_canvas39.gradientToSvgDef,
220
+ handlePoint: () => import_canvas32.handlePoint,
221
+ hasVisibleStroke: () => import_canvas34.hasVisibleStroke,
222
+ inferResizeHandle: () => import_canvas31.inferResizeHandle,
223
+ inspectCanvasInstance: () => import_canvas39.inspectCanvasInstance,
224
+ inspectNodeTokens: () => import_canvas37.inspectNodeTokens,
225
+ interpolateAnimationValue: () => import_canvas38.interpolateAnimationValue,
226
+ intersectPaths: () => import_canvas34.intersectPaths,
227
+ intersectPolygons: () => import_canvas33.intersectPolygons,
228
+ invertNodeUpdates: () => import_canvas32.invertNodeUpdates,
229
+ isAnimationEasing: () => import_canvas38.isAnimationEasing,
230
+ isAnimationKeyframe: () => import_canvas38.isAnimationKeyframe,
231
+ isAutoLayoutFrame: () => import_canvas36.isAutoLayoutFrame,
232
+ isBrushedShape: () => import_canvas39.isBrushedShape,
233
+ isCanvasComponent: () => import_canvas39.isCanvasComponent,
234
+ isCanvasComponentSet: () => import_canvas39.isCanvasComponentSet,
235
+ isCanvasGradient: () => import_canvas39.isCanvasGradient,
236
+ isCanvasInstance: () => import_canvas39.isCanvasInstance,
237
+ isCssExportExact: () => import_canvas38.isCssExportExact,
238
+ isEventFromTextInput: () => import_canvas35.isEventFromTextInput,
239
+ isKeyframeSelected: () => import_canvas38.isKeyframeSelected,
240
+ isLocked: () => import_canvas32.isLocked,
241
+ isMeasureModifierHeld: () => import_canvas31.isMeasureModifierHeld,
242
+ isNodeAnimated: () => import_canvas38.isNodeAnimated,
243
+ isShapeDescription: () => import_canvas33.isShapeDescription,
244
+ isShapeNode: () => import_canvas33.isShapeNode,
245
+ isStraightCubic: () => import_canvas31.isStraightCubic,
246
+ isValidCanvasNode: () => import_canvas35.isValidCanvasNode,
247
+ isValidUrl: () => import_canvas35.isValidUrl,
248
+ layoutAll: () => import_canvas36.layoutAll,
249
+ layoutBounds: () => import_canvas35.layoutBounds,
250
+ layoutFrame: () => import_canvas36.layoutFrame,
251
+ layoutUp: () => import_canvas36.layoutUp,
252
+ layoutUpMany: () => import_canvas36.layoutUpMany,
253
+ linearPositionTrajectory: () => import_canvas35.linearPositionTrajectory,
254
+ linearTrajectory: () => import_canvas35.linearTrajectory,
255
+ listCanvasBrushes: () => import_canvas39.listCanvasBrushes,
256
+ listCanvasComponents: () => import_canvas39.listCanvasComponents,
257
+ loadCanvasBrushstrokeRenderer: () => import_canvas39.loadCanvasBrushstrokeRenderer,
258
+ lockNodes: () => import_canvas32.lockNodes,
259
+ makeSizingCoherent: () => import_canvas36.makeSizingCoherent,
260
+ matchArrangeShortcut: () => import_canvas32.matchArrangeShortcut,
261
+ matchSize: () => import_canvas32.matchSize,
262
+ measureBetween: () => import_canvas31.measureBetween,
263
+ measureLabel: () => import_canvas31.measureLabel,
264
+ measureSelection: () => import_canvas31.measureSelection,
265
+ measureToLine: () => import_canvas31.measureToLine,
266
+ mergeNodeUpdates: () => import_canvas36.mergeNodeUpdates,
263
267
  mermaidNodeStyle: () => mermaidNodeStyle,
264
- mixColorsOklab: () => import_canvas37.mixColorsOklab,
265
- moveKeyframes: () => import_canvas37.moveKeyframes,
266
- moveLayoutChild: () => import_canvas35.moveLayoutChild,
267
- multiPolygonArea: () => import_canvas32.multiPolygonArea,
268
- multiPolygonBounds: () => import_canvas32.multiPolygonBounds,
269
- nearestHandlePositions: () => import_canvas31.nearestHandlePositions,
270
- nodeSizeOf: () => import_canvas34.nodeSizeOf,
271
- normalizeBezierPath: () => import_canvas33.normalizeBezierPath,
272
- normalizeKeyframes: () => import_canvas37.normalizeKeyframes,
273
- offsetPath: () => import_canvas33.offsetPath,
274
- offsetShapeNodes: () => import_canvas33.offsetShapeNodes,
275
- oklabToRgb: () => import_canvas37.oklabToRgb,
276
- oppositePosition: () => import_canvas31.oppositePosition,
277
- outlineShapeNodeStrokes: () => import_canvas33.outlineShapeNodeStrokes,
278
- outlineStroke: () => import_canvas33.outlineStroke,
279
- overlaps: () => import_canvas34.overlaps,
280
- parseCanvasClipboardData: () => import_canvas34.parseCanvasClipboardData,
281
- parseCanvasScenes: () => import_canvas31.parseCanvasScenes,
282
- parseCssEasing: () => import_canvas37.parseCssEasing,
283
- parseCssGradient: () => import_canvas38.parseCssGradient,
284
- parseKeyframeClipboard: () => import_canvas37.parseKeyframeClipboard,
285
- parseOklab: () => import_canvas37.parseOklab,
286
- parseSvgPath: () => import_canvas32.parseSvgPath,
287
- pasteKeyframes: () => import_canvas37.pasteKeyframes,
288
- pathBoolean: () => import_canvas33.pathBoolean,
289
- pathDataToPolyline: () => import_canvas38.pathDataToPolyline,
290
- placeBeside: () => import_canvas34.placeBeside,
291
- playWebAnimations: () => import_canvas37.playWebAnimations,
292
- pointInBezierPath: () => import_canvas33.pointInBezierPath,
293
- pointInMultiPolygon: () => import_canvas32.pointInMultiPolygon,
294
- pointInRings: () => import_canvas32.pointInRings,
295
- pointerPenSample: () => import_canvas38.pointerPenSample,
296
- polygonArea: () => import_canvas32.polygonArea,
297
- polygonBoolean: () => import_canvas32.polygonBoolean,
298
- polygonToSvgPath: () => import_canvas32.polygonToSvgPath,
299
- positionToSide: () => import_canvas31.positionToSide,
300
- profileAlongPolyline: () => import_canvas38.profileAlongPolyline,
301
- pruneCanvasTokenModes: () => import_canvas36.pruneCanvasTokenModes,
302
- pushCanvasInstanceOverrides: () => import_canvas38.pushCanvasInstanceOverrides,
303
- readAnimatableValue: () => import_canvas37.readAnimatableValue,
304
- readNodeStyleProperty: () => import_canvas36.readNodeStyleProperty,
305
- readStyleSize: () => import_canvas31.readStyleSize,
306
- realClock: () => import_canvas34.realClock,
307
- recordAnimationChanges: () => import_canvas37.recordAnimationChanges,
308
- relayoutUpdates: () => import_canvas35.relayoutUpdates,
309
- remapPastedNodes: () => import_canvas34.remapPastedNodes,
310
- removeCanvasVariant: () => import_canvas38.removeCanvasVariant,
311
- removeTrack: () => import_canvas37.removeTrack,
312
- renameCanvasVariantProperty: () => import_canvas38.renameCanvasVariantProperty,
313
- renameCanvasVariantValue: () => import_canvas38.renameCanvasVariantValue,
314
- renderCanvasBrushSwatch: () => import_canvas38.renderCanvasBrushSwatch,
315
- renderShapeBrushstroke: () => import_canvas38.renderShapeBrushstroke,
316
- reorderNodes: () => import_canvas31.reorderNodes,
317
- repositionNodesTo: () => import_canvas34.repositionNodesTo,
318
- resetCanvasInstanceOverrides: () => import_canvas38.resetCanvasInstanceOverrides,
319
- resizeHandleAxes: () => import_canvas30.resizeHandleAxes,
320
- resolveCanvasGradient: () => import_canvas38.resolveCanvasGradient,
321
- resolveCanvasTokens: () => import_canvas36.resolveCanvasTokens,
322
- resolveEasing: () => import_canvas37.resolveEasing,
323
- resolvePadding: () => import_canvas35.resolvePadding,
324
- restoreCanvasMainComponent: () => import_canvas38.restoreCanvasMainComponent,
325
- revertShapeCombination: () => import_canvas32.revertShapeCombination,
326
- rgbToOklab: () => import_canvas37.rgbToOklab,
327
- ringSignedArea: () => import_canvas32.ringSignedArea,
328
- runMultiNodeTransition: () => import_canvas34.runMultiNodeTransition,
329
- sampleAnimationFrames: () => import_canvas37.sampleAnimationFrames,
330
- scaleKeyframes: () => import_canvas37.scaleKeyframes,
331
- serializeCanvasNodes: () => import_canvas34.serializeCanvasNodes,
332
- setCanvasComponentProperty: () => import_canvas38.setCanvasComponentProperty,
333
- setCanvasInstanceProperties: () => import_canvas38.setCanvasInstanceProperties,
334
- setCanvasTokenMode: () => import_canvas36.setCanvasTokenMode,
335
- setCanvasVariantProperties: () => import_canvas38.setCanvasVariantProperties,
336
- setKeyframe: () => import_canvas37.setKeyframe,
337
- setKeyframeEasing: () => import_canvas37.setKeyframeEasing,
338
- setMotionPath: () => import_canvas37.setMotionPath,
339
- setTrackEnabled: () => import_canvas37.setTrackEnabled,
340
- shapeNodeToBezierPath: () => import_canvas33.shapeNodeToBezierPath,
341
- shapeNodeToPolygon: () => import_canvas32.shapeNodeToPolygon,
342
- shapeToBezierPath: () => import_canvas33.shapeToBezierPath,
343
- shapeToPolygon: () => import_canvas32.shapeToPolygon,
344
- sideToPosition: () => import_canvas31.sideToPosition,
345
- simplifyRing: () => import_canvas32.simplifyRing,
346
- snapKeyframeDelta: () => import_canvas37.snapKeyframeDelta,
347
- snapNodeDrag: () => import_canvas31.snapNodeDrag,
348
- snapNodeResize: () => import_canvas30.snapNodeResize,
349
- snapResize: () => import_canvas30.snapResize,
350
- snapTimeToFrame: () => import_canvas37.snapTimeToFrame,
351
- snapToGrid: () => import_canvas30.snapToGrid,
352
- springAt: () => import_canvas37.springAt,
353
- streamlinePoints: () => import_canvas38.streamlinePoints,
354
- strokeOutlineRings: () => import_canvas33.strokeOutlineRings,
355
- strokePointsToPathData: () => import_canvas38.strokePointsToPathData,
356
- strokeToShapeNode: () => import_canvas38.strokeToShapeNode,
357
- subtractPaths: () => import_canvas33.subtractPaths,
358
- subtractPolygons: () => import_canvas32.subtractPolygons,
359
- swapCanvasInstance: () => import_canvas38.swapCanvasInstance,
360
- syncAllCanvasInstances: () => import_canvas38.syncAllCanvasInstances,
361
- syncCanvasComponents: () => import_canvas38.syncCanvasComponents,
362
- syncCanvasInstance: () => import_canvas38.syncCanvasInstance,
363
- timeToX: () => import_canvas37.timeToX,
364
- toBezierPath: () => import_canvas33.toBezierPath,
365
- toWebAnimations: () => import_canvas37.toWebAnimations,
366
- toggleLockNodes: () => import_canvas31.toggleLockNodes,
367
- transformBezierPath: () => import_canvas33.transformBezierPath,
368
- unionPolygons: () => import_canvas32.unionPolygons,
369
- unitePaths: () => import_canvas33.unitePaths,
370
- unlockNodes: () => import_canvas31.unlockNodes,
371
- updateKeyframe: () => import_canvas37.updateKeyframe,
268
+ mixColorsOklab: () => import_canvas38.mixColorsOklab,
269
+ moveKeyframes: () => import_canvas38.moveKeyframes,
270
+ moveLayoutChild: () => import_canvas36.moveLayoutChild,
271
+ multiPolygonArea: () => import_canvas33.multiPolygonArea,
272
+ multiPolygonBounds: () => import_canvas33.multiPolygonBounds,
273
+ nearestHandlePositions: () => import_canvas32.nearestHandlePositions,
274
+ nodeSizeOf: () => import_canvas35.nodeSizeOf,
275
+ normalizeBezierPath: () => import_canvas34.normalizeBezierPath,
276
+ normalizeKeyframes: () => import_canvas38.normalizeKeyframes,
277
+ offsetPath: () => import_canvas34.offsetPath,
278
+ offsetShapeNodes: () => import_canvas34.offsetShapeNodes,
279
+ oklabToRgb: () => import_canvas38.oklabToRgb,
280
+ oppositePosition: () => import_canvas32.oppositePosition,
281
+ outlineShapeNodeStrokes: () => import_canvas34.outlineShapeNodeStrokes,
282
+ outlineStroke: () => import_canvas34.outlineStroke,
283
+ overlaps: () => import_canvas35.overlaps,
284
+ parseCanvasClipboardData: () => import_canvas35.parseCanvasClipboardData,
285
+ parseCanvasScenes: () => import_canvas32.parseCanvasScenes,
286
+ parseCssEasing: () => import_canvas38.parseCssEasing,
287
+ parseCssGradient: () => import_canvas39.parseCssGradient,
288
+ parseKeyframeClipboard: () => import_canvas38.parseKeyframeClipboard,
289
+ parseOklab: () => import_canvas38.parseOklab,
290
+ parseSvgPath: () => import_canvas33.parseSvgPath,
291
+ pasteKeyframes: () => import_canvas38.pasteKeyframes,
292
+ pathBoolean: () => import_canvas34.pathBoolean,
293
+ pathDataToPolyline: () => import_canvas39.pathDataToPolyline,
294
+ placeBeside: () => import_canvas35.placeBeside,
295
+ playWebAnimations: () => import_canvas38.playWebAnimations,
296
+ pointInBezierPath: () => import_canvas34.pointInBezierPath,
297
+ pointInMultiPolygon: () => import_canvas33.pointInMultiPolygon,
298
+ pointInRings: () => import_canvas33.pointInRings,
299
+ pointerPenSample: () => import_canvas39.pointerPenSample,
300
+ polygonArea: () => import_canvas33.polygonArea,
301
+ polygonBoolean: () => import_canvas33.polygonBoolean,
302
+ polygonToSvgPath: () => import_canvas33.polygonToSvgPath,
303
+ positionToSide: () => import_canvas32.positionToSide,
304
+ profileAlongPolyline: () => import_canvas39.profileAlongPolyline,
305
+ pruneCanvasTokenModes: () => import_canvas37.pruneCanvasTokenModes,
306
+ pushCanvasInstanceOverrides: () => import_canvas39.pushCanvasInstanceOverrides,
307
+ readAnimatableValue: () => import_canvas38.readAnimatableValue,
308
+ readNodeStyleProperty: () => import_canvas37.readNodeStyleProperty,
309
+ readStyleSize: () => import_canvas32.readStyleSize,
310
+ realClock: () => import_canvas35.realClock,
311
+ recordAnimationChanges: () => import_canvas38.recordAnimationChanges,
312
+ relayoutUpdates: () => import_canvas36.relayoutUpdates,
313
+ remapPastedNodes: () => import_canvas35.remapPastedNodes,
314
+ removeCanvasVariant: () => import_canvas39.removeCanvasVariant,
315
+ removeTrack: () => import_canvas38.removeTrack,
316
+ renameCanvasVariantProperty: () => import_canvas39.renameCanvasVariantProperty,
317
+ renameCanvasVariantValue: () => import_canvas39.renameCanvasVariantValue,
318
+ renderCanvasBrushSwatch: () => import_canvas39.renderCanvasBrushSwatch,
319
+ renderShapeBrushstroke: () => import_canvas39.renderShapeBrushstroke,
320
+ reorderNodes: () => import_canvas32.reorderNodes,
321
+ repositionNodesTo: () => import_canvas35.repositionNodesTo,
322
+ resetCanvasInstanceOverrides: () => import_canvas39.resetCanvasInstanceOverrides,
323
+ resizeHandleAxes: () => import_canvas31.resizeHandleAxes,
324
+ resolveCanvasGradient: () => import_canvas39.resolveCanvasGradient,
325
+ resolveCanvasTokens: () => import_canvas37.resolveCanvasTokens,
326
+ resolveEasing: () => import_canvas38.resolveEasing,
327
+ resolvePadding: () => import_canvas36.resolvePadding,
328
+ restoreCanvasMainComponent: () => import_canvas39.restoreCanvasMainComponent,
329
+ revertShapeCombination: () => import_canvas33.revertShapeCombination,
330
+ rgbToOklab: () => import_canvas38.rgbToOklab,
331
+ ringSignedArea: () => import_canvas33.ringSignedArea,
332
+ runMultiNodeTransition: () => import_canvas35.runMultiNodeTransition,
333
+ sampleAnimationFrames: () => import_canvas38.sampleAnimationFrames,
334
+ scaleKeyframes: () => import_canvas38.scaleKeyframes,
335
+ serializeCanvasNodes: () => import_canvas35.serializeCanvasNodes,
336
+ setCanvasComponentProperty: () => import_canvas39.setCanvasComponentProperty,
337
+ setCanvasInstanceProperties: () => import_canvas39.setCanvasInstanceProperties,
338
+ setCanvasTokenMode: () => import_canvas37.setCanvasTokenMode,
339
+ setCanvasVariantProperties: () => import_canvas39.setCanvasVariantProperties,
340
+ setKeyframe: () => import_canvas38.setKeyframe,
341
+ setKeyframeEasing: () => import_canvas38.setKeyframeEasing,
342
+ setMotionPath: () => import_canvas38.setMotionPath,
343
+ setTrackEnabled: () => import_canvas38.setTrackEnabled,
344
+ shapeNodeToBezierPath: () => import_canvas34.shapeNodeToBezierPath,
345
+ shapeNodeToPolygon: () => import_canvas33.shapeNodeToPolygon,
346
+ shapeToBezierPath: () => import_canvas34.shapeToBezierPath,
347
+ shapeToPolygon: () => import_canvas33.shapeToPolygon,
348
+ sideToPosition: () => import_canvas32.sideToPosition,
349
+ simplifyRing: () => import_canvas33.simplifyRing,
350
+ snapKeyframeDelta: () => import_canvas38.snapKeyframeDelta,
351
+ snapNodeDrag: () => import_canvas32.snapNodeDrag,
352
+ snapNodeResize: () => import_canvas31.snapNodeResize,
353
+ snapResize: () => import_canvas31.snapResize,
354
+ snapTimeToFrame: () => import_canvas38.snapTimeToFrame,
355
+ snapToGrid: () => import_canvas31.snapToGrid,
356
+ springAt: () => import_canvas38.springAt,
357
+ streamlinePoints: () => import_canvas39.streamlinePoints,
358
+ strokeOutlineRings: () => import_canvas34.strokeOutlineRings,
359
+ strokePointsToPathData: () => import_canvas39.strokePointsToPathData,
360
+ strokeToShapeNode: () => import_canvas39.strokeToShapeNode,
361
+ subtractPaths: () => import_canvas34.subtractPaths,
362
+ subtractPolygons: () => import_canvas33.subtractPolygons,
363
+ swapCanvasInstance: () => import_canvas39.swapCanvasInstance,
364
+ syncAllCanvasInstances: () => import_canvas39.syncAllCanvasInstances,
365
+ syncCanvasComponents: () => import_canvas39.syncCanvasComponents,
366
+ syncCanvasInstance: () => import_canvas39.syncCanvasInstance,
367
+ timeToX: () => import_canvas38.timeToX,
368
+ toBezierPath: () => import_canvas34.toBezierPath,
369
+ toWebAnimations: () => import_canvas38.toWebAnimations,
370
+ toggleLockNodes: () => import_canvas32.toggleLockNodes,
371
+ transformBezierPath: () => import_canvas34.transformBezierPath,
372
+ unionPolygons: () => import_canvas33.unionPolygons,
373
+ unitePaths: () => import_canvas34.unitePaths,
374
+ unlockNodes: () => import_canvas32.unlockNodes,
375
+ updateKeyframe: () => import_canvas38.updateKeyframe,
372
376
  useCanvasAnimation: () => useCanvasAnimation,
373
377
  useCanvasArrange: () => useCanvasArrange,
374
378
  useCanvasArrangeShortcuts: () => useCanvasArrangeShortcuts,
375
379
  useCanvasAutoLayout: () => useCanvasAutoLayout,
376
380
  useCanvasBrushes: () => useCanvasBrushes,
377
381
  useCanvasCapture: () => useCanvasCapture,
382
+ useCanvasChangeFeed: () => useCanvasChangeFeed,
378
383
  useCanvasClipboard: () => useCanvasClipboard,
379
384
  useCanvasComponents: () => useCanvasComponents,
380
385
  useCanvasDocking: () => useCanvasDocking,
@@ -389,6 +394,7 @@ __export(canvas_exports, {
389
394
  useCanvasLayout: () => useCanvasLayout,
390
395
  useCanvasMeasure: () => useCanvasMeasure,
391
396
  useCanvasPlaybackSurface: () => useCanvasPlaybackSurface,
397
+ useCanvasProposals: () => useCanvasProposals,
392
398
  useCanvasScenes: () => useCanvasScenes,
393
399
  useCanvasShortcuts: () => useCanvasShortcuts,
394
400
  useCanvasTokens: () => useCanvasTokens,
@@ -399,15 +405,15 @@ __export(canvas_exports, {
399
405
  usePresenceState: () => usePresenceState,
400
406
  useShapeBrushstroke: () => useShapeBrushstroke,
401
407
  useStreamingCanvas: () => useStreamingCanvas,
402
- validateCanvasBrush: () => import_canvas38.validateCanvasBrush,
403
- validateCanvasBrushPaint: () => import_canvas38.validateCanvasBrushPaint,
404
- withNodeAnimation: () => import_canvas37.withNodeAnimation,
405
- withStyleSize: () => import_canvas31.withStyleSize,
406
- wouldCreateComponentCycle: () => import_canvas38.wouldCreateComponentCycle,
407
- wrapAnimationTime: () => import_canvas37.wrapAnimationTime,
408
- writeNodeStyleProperty: () => import_canvas36.writeNodeStyleProperty,
409
- xToTime: () => import_canvas37.xToTime,
410
- xorPolygons: () => import_canvas32.xorPolygons
408
+ validateCanvasBrush: () => import_canvas39.validateCanvasBrush,
409
+ validateCanvasBrushPaint: () => import_canvas39.validateCanvasBrushPaint,
410
+ withNodeAnimation: () => import_canvas38.withNodeAnimation,
411
+ withStyleSize: () => import_canvas32.withStyleSize,
412
+ wouldCreateComponentCycle: () => import_canvas39.wouldCreateComponentCycle,
413
+ wrapAnimationTime: () => import_canvas38.wrapAnimationTime,
414
+ writeNodeStyleProperty: () => import_canvas37.writeNodeStyleProperty,
415
+ xToTime: () => import_canvas38.xToTime,
416
+ xorPolygons: () => import_canvas33.xorPolygons
411
417
  });
412
418
  module.exports = __toCommonJS(canvas_exports);
413
419
 
@@ -1354,7 +1360,7 @@ function useCanvasExplosionState(options = {}) {
1354
1360
  }
1355
1361
 
1356
1362
  // src/canvas/index.ts
1357
- var import_canvas29 = require("@pixerate/editor/canvas");
1363
+ var import_canvas30 = require("@pixerate/editor/canvas");
1358
1364
 
1359
1365
  // src/canvas/useCanvasArrange.ts
1360
1366
  var import_react13 = require("react");
@@ -1909,8 +1915,8 @@ function useCanvasMeasure(options) {
1909
1915
  }
1910
1916
 
1911
1917
  // src/canvas/index.ts
1912
- var import_canvas30 = require("@pixerate/editor/canvas");
1913
1918
  var import_canvas31 = require("@pixerate/editor/canvas");
1919
+ var import_canvas32 = require("@pixerate/editor/canvas");
1914
1920
 
1915
1921
  // src/canvas/ShapeNode.tsx
1916
1922
  var import_canvas17 = require("@pixerate/editor/canvas");
@@ -3962,10 +3968,10 @@ function ShapeNode({ id, data, width, height, selected, className = "", children
3962
3968
  }
3963
3969
 
3964
3970
  // src/canvas/index.ts
3965
- var import_canvas32 = require("@pixerate/editor/canvas");
3966
3971
  var import_canvas33 = require("@pixerate/editor/canvas");
3967
3972
  var import_canvas34 = require("@pixerate/editor/canvas");
3968
3973
  var import_canvas35 = require("@pixerate/editor/canvas");
3974
+ var import_canvas36 = require("@pixerate/editor/canvas");
3969
3975
 
3970
3976
  // src/canvas/useCanvasAutoLayout.ts
3971
3977
  var import_react31 = require("react");
@@ -4177,7 +4183,7 @@ function TokenModeSwitcher({
4177
4183
  }
4178
4184
 
4179
4185
  // src/canvas/index.ts
4180
- var import_canvas36 = require("@pixerate/editor/canvas");
4186
+ var import_canvas37 = require("@pixerate/editor/canvas");
4181
4187
 
4182
4188
  // src/canvas/useCanvasAnimation.ts
4183
4189
  var import_react33 = require("react");
@@ -4431,7 +4437,7 @@ function AnimationTimeline({ animation, nodeIds, width = 360, snapThreshold = 8,
4431
4437
  }
4432
4438
 
4433
4439
  // src/canvas/index.ts
4434
- var import_canvas37 = require("@pixerate/editor/canvas");
4440
+ var import_canvas38 = require("@pixerate/editor/canvas");
4435
4441
 
4436
4442
  // src/canvas/useCanvasComponents.ts
4437
4443
  var import_react35 = require("react");
@@ -4842,7 +4848,7 @@ function CanvasInstanceInspector({
4842
4848
  }
4843
4849
 
4844
4850
  // src/canvas/index.ts
4845
- var import_canvas38 = require("@pixerate/editor/canvas");
4851
+ var import_canvas39 = require("@pixerate/editor/canvas");
4846
4852
 
4847
4853
  // src/canvas/MermaidFamilyScene.tsx
4848
4854
  var import_react37 = require("react");
@@ -5187,6 +5193,77 @@ function DiagramPresenceLayer({ presence, viewport, className = "" }) {
5187
5193
  /* @__PURE__ */ (0, import_jsx_runtime22.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 })
5188
5194
  ] }, a.id)) });
5189
5195
  }
5196
+
5197
+ // src/canvas/useCanvasProposals.ts
5198
+ var import_react41 = require("react");
5199
+ var import_canvas29 = require("@pixerate/editor/canvas");
5200
+ function useCanvasProposals(options) {
5201
+ const latest = (0, import_react41.useRef)(options);
5202
+ latest.current = options;
5203
+ const live = (0, import_react41.useRef)({ nodes: options.nodes, edges: options.edges });
5204
+ live.current = { nodes: options.nodes, edges: options.edges };
5205
+ const storeRef = (0, import_react41.useRef)(null);
5206
+ if (storeRef.current === null) {
5207
+ storeRef.current = (0, import_canvas29.createCanvasProposals)({
5208
+ getNodes: () => live.current.nodes,
5209
+ getEdges: () => live.current.edges,
5210
+ setNodes: (nodes) => {
5211
+ live.current = { ...live.current, nodes };
5212
+ latest.current.setNodes(nodes);
5213
+ },
5214
+ setEdges: (edges) => {
5215
+ live.current = { ...live.current, edges };
5216
+ latest.current.setEdges(edges);
5217
+ },
5218
+ history: options.history,
5219
+ origin: options.origin,
5220
+ readOnly: () => latest.current.readOnly?.() ?? false,
5221
+ defaultNodeSize: options.defaultNodeSize,
5222
+ visibleRect: () => latest.current.visibleRect?.(),
5223
+ defaultNodeType: options.defaultNodeType,
5224
+ idGenerator: options.idGenerator
5225
+ });
5226
+ }
5227
+ const store = storeRef.current;
5228
+ const state = (0, import_react41.useSyncExternalStore)(store.subscribe, store.getState, store.getState);
5229
+ const view = (0, import_react41.useMemo)(() => store.withGhosts(options.nodes, options.edges), [store, state, options.nodes, options.edges]);
5230
+ return (0, import_react41.useMemo)(
5231
+ () => ({
5232
+ store,
5233
+ proposals: state.proposals,
5234
+ view,
5235
+ propose: store.propose,
5236
+ accept: store.accept,
5237
+ reject: store.reject,
5238
+ clear: store.clear
5239
+ }),
5240
+ [store, state, view]
5241
+ );
5242
+ }
5243
+ function useCanvasChangeFeed(options) {
5244
+ const latest = (0, import_react41.useRef)(options);
5245
+ latest.current = options;
5246
+ const [last, setLast] = (0, import_react41.useState)(null);
5247
+ const feed = (0, import_react41.useMemo)(
5248
+ () => (0, import_canvas29.createCanvasChangeFeed)({
5249
+ getNodes: () => latest.current.nodes,
5250
+ getEdges: () => latest.current.edges,
5251
+ ignoreNodeKeys: options.ignoreNodeKeys
5252
+ }),
5253
+ []
5254
+ );
5255
+ (0, import_react41.useEffect)(() => options.history?.onCommit(feed.noteCommit), [feed, options.history]);
5256
+ (0, import_react41.useEffect)(() => {
5257
+ const change = feed.check();
5258
+ if (!change) return;
5259
+ setLast(change);
5260
+ latest.current.onChange?.(change);
5261
+ }, [feed, options.nodes, options.edges]);
5262
+ return { feed, last };
5263
+ }
5264
+
5265
+ // src/canvas/index.ts
5266
+ var import_canvas40 = require("@pixerate/editor/canvas");
5190
5267
  // Annotate the CommonJS export names for ESM import in node:
5191
5268
  0 && (module.exports = {
5192
5269
  ANIMATABLE_PROPERTIES,
@@ -5201,6 +5278,7 @@ function DiagramPresenceLayer({ presence, viewport, className = "" }) {
5201
5278
  AnimationTimeline,
5202
5279
  CANVAS_COMPONENT_DRAG_TYPE,
5203
5280
  CANVAS_GRADIENT_PRESETS,
5281
+ CANVAS_PROPOSAL_CLASS,
5204
5282
  CANVAS_TOKEN_PROPERTIES,
5205
5283
  CHILD_LAYOUT_DATA_KEY,
5206
5284
  CONNECTION_LINE_TYPES,
@@ -5282,12 +5360,15 @@ function DiagramPresenceLayer({ presence, viewport, className = "" }) {
5282
5360
  createBezierTrajectory,
5283
5361
  createCanvasAnimationController,
5284
5362
  createCanvasAutoLayoutController,
5363
+ createCanvasChangeFeed,
5285
5364
  createCanvasComponent,
5286
5365
  createCanvasComponentsController,
5287
5366
  createCanvasDrawController,
5288
5367
  createCanvasExplosionStateController,
5289
5368
  createCanvasExplosionToolProvider,
5290
5369
  createCanvasInstance,
5370
+ createCanvasProposalToolProvider,
5371
+ createCanvasProposals,
5291
5372
  createCanvasScenesStore,
5292
5373
  createDefaultStrokeStyle,
5293
5374
  createFanOutTrajectory,
@@ -5533,6 +5614,7 @@ function DiagramPresenceLayer({ presence, viewport, className = "" }) {
5533
5614
  useCanvasAutoLayout,
5534
5615
  useCanvasBrushes,
5535
5616
  useCanvasCapture,
5617
+ useCanvasChangeFeed,
5536
5618
  useCanvasClipboard,
5537
5619
  useCanvasComponents,
5538
5620
  useCanvasDocking,
@@ -5547,6 +5629,7 @@ function DiagramPresenceLayer({ presence, viewport, className = "" }) {
5547
5629
  useCanvasLayout,
5548
5630
  useCanvasMeasure,
5549
5631
  useCanvasPlaybackSurface,
5632
+ useCanvasProposals,
5550
5633
  useCanvasScenes,
5551
5634
  useCanvasShortcuts,
5552
5635
  useCanvasTokens,