@pixerate/editor 0.22.0 → 0.23.0

package/dist/canvas/index.d.cts

@@ -1,6 +1,8 @@
-import { R as Rect, C as CanvasNode, X as XYPosition, a as CanvasEdge, I as IncrementalLayoutOptions, S as Side, b as CanvasLayoutOptions, P as PlaceBesideOptions, T as TrajectoryFunction, F as FanOutTrajectoryOptions, N as NodeTransition, c as CanvasNodeStyle, d as ReflowDisplacementOptions, D as DirectionalDisplacementOptions, e as CanvasClipboardPayload, f as Position, g as Point } from '../types-CJ4U-HHI.cjs';
-export { h as CanvasDockingCallbacks, i as CollapseNodeOptions, j as DisplacementDirection, k as DockStrategy, E as ExplodeNodeOptions, l as ExplosionSnapshot, G as GraphDifferences, m as TrajectoryPoint } from '../types-CJ4U-HHI.cjs';
-import { C as Command } from '../types-BZgcDsC5.cjs';
+import { R as Rect, C as CanvasNode, X as XYPosition, b as CanvasEdge, I as IncrementalLayoutOptions, S as Side, c as CanvasLayoutOptions, P as PlaceBesideOptions, T as TrajectoryFunction, F as FanOutTrajectoryOptions, N as NodeTransition, a as CanvasNodeStyle, d as ReflowDisplacementOptions, D as DirectionalDisplacementOptions, e as CanvasClipboardPayload, f as Position, g as Point } from '../types-DX4Mh4SL.cjs';
+export { h as CanvasDockingCallbacks, i as CollapseNodeOptions, j as DisplacementDirection, k as DockStrategy, E as ExplodeNodeOptions, l as ExplosionSnapshot, G as GraphDifferences, m as TrajectoryPoint } from '../types-DX4Mh4SL.cjs';
+import { b as CanvasNodeUpdate, N as NodeRectOptions, A as AlignEdge, c as AlignNodesOptions, D as DistributeAxis, a as DistributeMode, d as DistributeNodesOptions, S as SizeDimension, M as MatchSizeOptions, Z as ZOrderOperation, C as CanvasArrangeAction } from '../arrangeShortcuts-B8O3f8-P.cjs';
+export { e as ArrangeShortcutBinding, f as DEFAULT_ARRANGE_SHORTCUTS, L as LOCKED_DATA_KEY, g as LOCKED_PREVIOUS_FLAGS_KEY, h as alignNodes, i as applyNodeUpdates, j as createNodeLookup, k as distributeNodes, l as getAbsolutePosition, m as getNodeRect, n as getNodeSize, o as invertNodeUpdates, p as isLocked, q as lockNodes, r as matchArrangeShortcut, s as matchSize, t as readStyleSize, u as reorderNodes, v as toggleLockNodes, w as unlockNodes, x as withStyleSize } from '../arrangeShortcuts-B8O3f8-P.cjs';
+import { C as Command } from '../types-GT5a5YAX.cjs';
 
 declare const DEFAULT_NODE_WIDTH = 200;
 declare const DEFAULT_NODE_HEIGHT = 60;
@@ -328,172 +330,30 @@ declare function blendLayout<TNode extends CanvasNode = CanvasNode>(from: TNode[
  */
 declare function connectedOnly<TNode extends CanvasNode = CanvasNode, TEdge extends CanvasEdge = CanvasEdge>(nodes: TNode[], edges: TEdge[]): TNode[];
 
-/**
- * Edge (or centre line) used by `alignNodes`.
- * `center` aligns horizontal centres (a vertical line); `middle` aligns vertical centres.
- */
-type AlignEdge = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
-/** Axis used by `distributeNodes`. `both` distributes horizontally and vertically. */
-type DistributeAxis = 'horizontal' | 'vertical' | 'both';
-/**
- * `gaps` leaves equal space between neighbouring nodes, `centres` spaces their centres equally.
- */
-type DistributeMode = 'gaps' | 'centres';
-/** Dimension(s) copied by `matchSize`. */
-type SizeDimension = 'width' | 'height' | 'both';
-/**
- * Partial node change produced by the arrange helpers. `position` is in the node's own
- * coordinate space (relative to its `parentId` parent when it has one).
- */
-interface CanvasNodeUpdate {
-    id: string;
-    position?: XYPosition;
-    width?: number;
-    height?: number;
-    zIndex?: number;
-}
-interface NodeRectOptions {
-    /** Width used when a node has no measured, explicit or style size and estimation is off. */
-    defaultWidth?: number;
-    /** Height used when a node has no measured, explicit or style size and estimation is off. */
-    defaultHeight?: number;
-    /** Estimate unmeasured node sizes from their label via `estimateNodeSize` (default `true`). */
-    estimate?: boolean;
-}
-/** Data key marking a node as locked. See `lockNodes`. */
-declare const LOCKED_DATA_KEY = "locked";
-/** Data key holding the interaction flags a node had before it was locked. */
-declare const LOCKED_PREVIOUS_FLAGS_KEY = "lockedPrevious";
-/**
- * Reads a pixel `width` / `height` from a node style, which may be a CSS string (SvelteFlow)
- * or a style object (React Flow). Non-pixel values (`%`, `auto`, ...) are ignored.
- */
-declare function readStyleSize(style: CanvasNodeStyle | undefined | null): {
-    width?: number;
-    height?: number;
-};
-/**
- * Returns `style` with its pixel `width` / `height` replaced, keeping its representation
- * (string or object). Only dimensions already present in the style are rewritten, because
- * xyflow applies the node's own `width` / `height` props otherwise.
- */
-declare function withStyleSize(style: CanvasNodeStyle | undefined | null, size: {
-    width?: number;
-    height?: number;
-}): CanvasNodeStyle | undefined;
-/**
- * Resolves a node's size: measured DOM size, then explicit `width` / `height`, then a pixel
- * size in `style`, then a label-based estimate (or the defaults when `estimate` is `false`).
- */
-declare function getNodeSize(node: CanvasNode, options?: NodeRectOptions): {
-    width: number;
-    height: number;
-};
-/**
- * Absolute (flow-space) position of a node, following its `parentId` chain.
- * Cycles and missing parents are tolerated.
- */
-declare function getAbsolutePosition(node: CanvasNode, lookup: ReadonlyMap<string, CanvasNode>): XYPosition;
-/** Builds an id lookup for a node array. */
-declare function createNodeLookup<TNode extends CanvasNode>(nodes: TNode[]): Map<string, TNode>;
-/** Absolute flow-space rectangle of a node. */
-declare function getNodeRect(node: CanvasNode, lookup?: ReadonlyMap<string, CanvasNode>, options?: NodeRectOptions): Rect;
-/**
- * Whether a node has been locked with `lockNodes`.
- */
-declare function isLocked(node: CanvasNode | undefined | null): boolean;
-/**
- * Locks nodes: marks `data.locked = true` and sets `draggable: false` and `deletable: false`
- * so both SvelteFlow and React Flow stop dragging and deleting them. Nodes stay `selectable`
- * so they can be unlocked again. The previous flags are kept in `data.lockedPrevious` and
- * restored by `unlockNodes`. Returns a new array; untouched nodes keep their identity.
- */
-declare function lockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
-/**
- * Reverses `lockNodes`, restoring the `draggable` / `deletable` flags the node had before.
- */
-declare function unlockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
-/** Locks the given nodes if any of them is unlocked, otherwise unlocks them all. */
-declare function toggleLockNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>): TNode[];
-interface AlignNodesOptions extends NodeRectOptions {
-    /**
-     * What to align to: the selection bounding box (default) or a fixed rectangle.
-     * Locked nodes never move but still count towards the selection bounds, so they act as anchors.
-     */
-    to?: 'selection' | Rect;
-}
-/**
- * Aligns nodes to a shared edge or centre line of their bounding box (Freeform's
- * Align Left / Center / Right / Top / Middle / Bottom). Needs at least two nodes unless
- * `options.to` is a rectangle. Locked nodes are not moved.
- */
-declare function alignNodes(nodes: CanvasNode[], ids: Iterable<string>, edge: AlignEdge, options?: AlignNodesOptions): CanvasNodeUpdate[];
-interface DistributeNodesOptions extends NodeRectOptions {
-    /** Explicit gap between neighbours for `gaps` mode. Default: spread evenly between the outer nodes. */
-    gap?: number;
-}
-/**
- * Distributes nodes along an axis (Freeform's Distribute Horizontally / Vertically / Evenly).
- * The outermost nodes stay put and the others are spaced with equal gaps (`gaps`, default)
- * or equally spaced centres (`centres`). Needs at least three nodes (two with an explicit
- * `gap`). Locked nodes keep their place in the order but are not moved.
- */
-declare function distributeNodes(nodes: CanvasNode[], ids: Iterable<string>, axis: DistributeAxis, mode?: DistributeMode, options?: DistributeNodesOptions): CanvasNodeUpdate[];
-interface MatchSizeOptions extends NodeRectOptions {
-    /**
-     * Size source: the `largest` (default) or `smallest` node, the `first` id given,
-     * or a specific node id.
-     */
-    reference?: 'largest' | 'smallest' | 'first' | {
-        id: string;
-    };
-    /** Keep each node's centre in place instead of its top-left corner (default `false`). */
-    keepCentre?: boolean;
-}
-/**
- * Makes nodes the same width, height or both (Freeform's Make Same Size). Returns size
- * updates (plus position updates with `keepCentre`). Locked nodes are not resized but can
- * be the reference.
- */
-declare function matchSize(nodes: CanvasNode[], ids: Iterable<string>, dimension: SizeDimension, options?: MatchSizeOptions): CanvasNodeUpdate[];
-/** Z-order operation. */
-type ZOrderOperation = 'bringForward' | 'sendBackward' | 'bringToFront' | 'sendToBack';
-/**
- * Restacks nodes (Bring Forward / Send Backward / Bring to Front / Send to Back).
- *
- * Both SvelteFlow and React Flow stack nodes by `zIndex` (missing = 0) and, for equal
- * `zIndex`, by array order. This computes that effective order for the siblings that share
- * the targets' parent, applies the operation, and returns `zIndex` updates assigning each
- * sibling its new rank. The array order is left alone, because xyflow requires parents to
- * precede their children. Locked nodes are not restacked. "Forward" moves past the next
- * sibling the node overlaps, falling back to the next sibling when nothing overlaps.
- */
-declare function reorderNodes(nodes: CanvasNode[], ids: Iterable<string>, operation: ZOrderOperation, options?: NodeRectOptions): CanvasNodeUpdate[];
-/**
- * Applies `CanvasNodeUpdate`s to a node array, returning a new array. Unchanged nodes keep
- * their identity. Size updates set `width` / `height` and rewrite pixel sizes already present
- * in `style` (string or object). An existing `measured` size is updated too, so geometry
- * helpers see the new size before xyflow re-measures the node.
- */
-declare function applyNodeUpdates<TNode extends CanvasNode>(nodes: TNode[], updates: CanvasNodeUpdate[]): TNode[];
-/**
- * Inverse of a set of updates against the current nodes, for undo. Restores the previous
- * position / size / zIndex of every node an update touches.
- */
-declare function invertNodeUpdates(nodes: CanvasNode[], updates: CanvasNodeUpdate[]): CanvasNodeUpdate[];
-
 /**
  * A guide line to render while dragging, in flow coordinates.
  * `edge` and `centre` guides are alignment lines; `spacing` guides mark equal gaps.
+ * `measure` lines (with a distance `label`) and dashed `extension` lines come from the
+ * distance measuring helpers (`measureBetween`, `measureSelection`).
  */
 interface GuideLine {
     orientation: 'vertical' | 'horizontal';
-    kind: 'edge' | 'centre' | 'spacing';
+    kind: 'edge' | 'centre' | 'spacing' | 'measure' | 'extension';
     x1: number;
     y1: number;
     x2: number;
     y2: number;
+    /** Text drawn at the middle of the line (measuring distances). */
+    label?: string;
 }
+/**
+ * Snaps `value` to a grid with the given `spacing` and `origin`. A spacing of 0 or less
+ * (or a non-finite one) leaves the value unchanged.
+ *
+ * Ported from vectorcraft-main/crates/geom/src/snap.rs (MIT OR Apache-2.0, © ArtCraft Team
+ * and contributors). See THIRD_PARTY_NOTICES.md.
+ */
+declare function snapToGrid(value: number, spacing: number, origin?: number): number;
 interface SnapGuidesOptions {
     /** Current viewport zoom; the threshold is in screen pixels and divided by it (default 1). */
     zoom?: number;
@@ -505,6 +365,13 @@ interface SnapGuidesOptions {
     centres?: boolean;
     /** Snap to equal spacing between neighbouring shapes in the same row / column (default `true`). */
     spacing?: boolean;
+    /**
+     * Grid spacing in flow units (default 0, off). An axis that does not snap to a shape snaps
+     * its top-left (drag) or moving edge (resize) to the grid; grid snaps draw no guides.
+     */
+    gridSize?: number;
+    /** Grid origin in flow units (default `{ x: 0, y: 0 }`). */
+    gridOrigin?: XYPosition;
 }
 interface SnapResult {
     /** Snapped top-left of the moving rectangle. */
@@ -513,6 +380,7 @@ interface SnapResult {
     offset: XYPosition;
     /** Guide segments to draw for the snap that was applied. */
     guides: GuideLine[];
+    /** Whether x snapped to a shape (grid snaps do not count). */
     snappedX: boolean;
     snappedY: boolean;
 }
@@ -738,33 +606,6 @@ declare function fitViewportToNodes(nodes: CanvasNode[], size: {
     height: number;
 }, ids?: Iterable<string>, options?: FitViewportOptions & NodeRectOptions): CanvasViewport | null;
 
-/**
- * Canvas arrangement actions that have keyboard shortcuts.
- */
-type CanvasArrangeAction = 'alignLeft' | 'alignCenter' | 'alignRight' | 'alignTop' | 'alignMiddle' | 'alignBottom' | 'distributeHorizontal' | 'distributeVertical' | 'lock' | 'unlock' | 'bringForward' | 'sendBackward' | 'bringToFront' | 'sendToBack' | 'nextScene' | 'previousScene';
-interface ArrangeShortcutBinding {
-    action: CanvasArrangeAction;
-    /** `KeyboardEvent.code` (layout- and Option-independent, e.g. `KeyA`, `BracketRight`). */
-    code: string;
-    mod?: boolean;
-    alt?: boolean;
-    shift?: boolean;
-    /** Human readable label, e.g. for menus. `Mod` is ⌘ on macOS and Ctrl elsewhere. */
-    label: string;
-}
-/**
- * Default bindings. Align/distribute follow Figma (Option/Alt + letter), layer order follows
- * the common `Mod+]` / `Mod+[` convention, lock follows Keynote/Freeform (`Mod+L`,
- * `Mod+Alt+L` to unlock) and scenes step with PageDown / PageUp.
- */
-declare const DEFAULT_ARRANGE_SHORTCUTS: readonly ArrangeShortcutBinding[];
-/**
- * Resolves a keydown event to an arrange action, or `null`. Events from text inputs,
- * textareas, selects, contenteditable and ProseMirror are ignored (see `isEventFromTextInput`).
- * `Mod` is ⌘ or Ctrl.
- */
-declare function matchArrangeShortcut(event: KeyboardEvent, bindings?: readonly ArrangeShortcutBinding[]): CanvasArrangeAction | null;
-
 /**
  * Polygon boolean operations (union, intersection, difference, xor and divide) on
  * multi-polygons with holes.
@@ -1040,6 +881,16 @@ interface PolygonToPathOptions {
         x: number;
         y: number;
     };
+    /**
+     * `'lines'` (default) writes every ring as `M`/`L`/`Z`. `'fit'` fits cubic Béziers to each
+     * ring (`fitPathData`), so flattened curves come back as smooth `C` curves while sharp
+     * corners (turning more than `cornerAngleDeg`) and straight edges stay as they are.
+     */
+    curves?: 'lines' | 'fit';
+    /** Curve-fitting tolerance in path units for `curves: 'fit'` (default 0.25). */
+    curveTolerance?: number;
+    /** Corner threshold in degrees for `curves: 'fit'` (default 30). */
+    cornerAngleDeg?: number;
 }
 /**
  * Converts a multi-polygon (or a list of rings) to SVG path data using `M`/`L`/`Z`. Holes
@@ -1103,6 +954,16 @@ interface CombineShapeNodesOptions extends ShapeNodePolygonOptions {
     precision?: number;
     /** Ramer–Douglas–Peucker simplification tolerance for the result (default 0, off). */
     simplify?: number;
+    /**
+     * How the result's outline is written: `'fit'` (default) fits smooth cubic curves to the
+     * flattened result, so booleans of curved shapes stay curved (sharp corners and straight
+     * edges are kept); `'lines'` writes the polygon as straight segments.
+     */
+    curves?: 'lines' | 'fit';
+    /** Curve-fitting tolerance in flow units for `curves: 'fit'` (default: `tolerance`, 0.25). */
+    curveTolerance?: number;
+    /** Corner threshold in degrees for `curves: 'fit'` (default 30). */
+    cornerAngleDeg?: number;
     /** Point-merge tolerance passed to the boolean engine. */
     epsilon?: number;
     /** Select the new nodes (default `true`). */
@@ -1169,6 +1030,76 @@ declare function revertShapeCombination<TNode extends CanvasNode>(nodes: TNode[]
     nodes: TNode[];
 }, previous: TNode[]): TNode[];
 
+/** A resize handle, named like xyflow's `ControlPosition`. */
+type ResizeHandle = 'top-left' | 'top' | 'top-right' | 'right' | 'bottom-right' | 'bottom' | 'bottom-left' | 'left';
+declare const RESIZE_HANDLES: readonly ResizeHandle[];
+/** Which edge of each axis a handle moves: -1 the start (left / top), 1 the end, 0 none. */
+declare function resizeHandleAxes(handle: ResizeHandle): {
+    x: -1 | 0 | 1;
+    y: -1 | 0 | 1;
+};
+/**
+ * The handle a resize from `start` to `next` was made with, from the edges that moved, or
+ * `null` when no edge moved.
+ */
+declare function inferResizeHandle(start: Rect, next: Rect, eps?: number): ResizeHandle | null;
+interface SnapResizeOptions extends Omit<SnapGuidesOptions, 'spacing'> {
+    /**
+     * Keep the input box's aspect ratio. A corner snaps whichever axis is closer to a target
+     * and the other follows; a side scales the other axis about its centre.
+     */
+    keepAspectRatio?: boolean;
+    /** Smallest width a snap may leave (default: anything above 0). */
+    minWidth?: number;
+    /** Smallest height a snap may leave (default: anything above 0). */
+    minHeight?: number;
+}
+interface SnapResizeResult {
+    /** The snapped box. */
+    rect: Rect;
+    /** Guide segments for the shape snaps that were applied (grid snaps draw none). */
+    guides: GuideLine[];
+    /** Whether the moving x edge snapped to a shape. */
+    snappedX: boolean;
+    /** Whether the moving y edge snapped to a shape. */
+    snappedY: boolean;
+    /** Whether `rect` differs from the input. */
+    changed: boolean;
+}
+/**
+ * Snaps a resize of the axis-aligned box `rect` made with `handle` against `targets`. The
+ * opposite edge (side handles) or corner (corner handles) stays fixed:
+ *
+ * - A **side** handle snaps its one moving edge to the nearest target edge or centre within
+ *   `threshold` screen pixels.
+ * - A **corner** handle snaps x and y independently (unless `keepAspectRatio`).
+ * - A snap that would collapse or flip the box (or go below `minWidth` / `minHeight`) is
+ *   rejected; the next nearest target is tried, else the edge stays where it was dragged.
+ * - With `gridSize`, an axis without a shape snap snaps its moving edge to the grid.
+ *
+ * Returns the snapped box and the guides to draw (same shape as drag snapping).
+ */
+declare function snapResize(rect: Rect, handle: ResizeHandle, targets: Rect[] | GuideIndex, options?: SnapResizeOptions): SnapResizeResult;
+interface SnapNodeResizeOptions extends SnapResizeOptions, NodeRectOptions {
+    /** Index from `createNodeGuideIndex(nodes, [id])`, reused across resize frames. */
+    index?: GuideIndex;
+}
+interface SnapNodeResizeResult extends SnapResizeResult {
+    /** Position / size update for the node (parent-relative position), or none. */
+    updates: CanvasNodeUpdate[];
+}
+/**
+ * Snaps a node that is being resized. `rect` is the node's proposed absolute box (e.g. from
+ * a resize event) and `handle` the handle being dragged. Locked nodes are never snapped.
+ * The node itself and its descendants are not snap targets.
+ */
+declare function snapNodeResize(nodes: CanvasNode[], id: string, rect: Rect, handle: ResizeHandle, options?: SnapNodeResizeOptions): SnapNodeResizeResult;
+/**
+ * Absolute box of a node while it is being resized: flow libraries write the new size to
+ * `width` / `height` before the DOM is re-measured, so those win over `measured` here.
+ */
+declare function getResizingNodeRect(node: CanvasNode, lookup: ReadonlyMap<string, CanvasNode>, options?: NodeRectOptions): Rect;
+
 /** Minimal history surface (`HistoryManager` satisfies it). */
 interface ArrangeHistoryTarget {
     execute(command: Command): void;
@@ -1186,6 +1117,14 @@ interface CanvasArrangeControllerOptions<TNode extends CanvasNode = CanvasNode>
     guides?: Omit<SnapGuidesOptions, 'zoom'>;
     /** Turns drag snapping off while keeping the arrange actions (default `true`). */
     snapping?: boolean;
+    /** Turns resize snapping off (default: follows `snapping`). */
+    resizeSnapping?: boolean;
+    /** Resize options passed to `snapResize` (`keepAspectRatio`, `minWidth`, `minHeight`). */
+    resize?: {
+        keepAspectRatio?: boolean;
+        minWidth?: number;
+        minHeight?: number;
+    };
     /** Size resolution for unmeasured nodes. */
     rectOptions?: NodeRectOptions;
     /** Called whenever the guide segments change (set while dragging, cleared on drop). */
@@ -1256,6 +1195,31 @@ declare function createCanvasArrangeController<TNode extends CanvasNode = Canvas
      * A batch without a dragging position change ends the drag and clears the guides.
      */
     snapPositionChanges<TChange extends PositionChangeLike>(changes: TChange[]): TChange[];
+    /**
+     * Starts resize snapping for node `id`: records its box (to tell which handle is
+     * dragged) and caches the snap targets. Optional: `resize` starts lazily.
+     */
+    beginResize(id: string): void;
+    /**
+     * Snaps node `id` as currently sized in `getNodes()` (call it after the flow wrote the
+     * new size, e.g. SvelteFlow's `NodeResizer` `onResize`, deferred by a microtask) and
+     * writes the snapped box back through `setNodes` (not recorded in history). `handle`
+     * defaults to the one inferred from the edges that moved since `beginResize`. A locked
+     * node is restored to its starting box.
+     */
+    resize(id: string, handle?: ResizeHandle): SnapNodeResizeResult | null;
+    /**
+     * Ends resize snapping: clears guides and re-applies the last snapped box if the flow
+     * wrote the raw pointer size afterwards.
+     */
+    endResize(): void;
+    /**
+     * React Flow style: snaps the `dimensions` (and matching `position`) changes a
+     * `NodeResizer` emits in an `onNodesChange` batch and updates `guides`. The resize-end
+     * change (`resizing: false`) carries the raw pointer size, so the last snapped size is
+     * kept. Resize changes of locked nodes are dropped. Returns the (possibly new) changes.
+     */
+    snapResizeChanges<TChange extends PositionChangeLike>(changes: TChange[]): TChange[];
     /**
      * Clears guides and the cached snap targets. Call it from the flow's drag-stop
      * handler: flow libraries write the raw pointer position when a drag ends, so the
@@ -1265,4 +1229,145 @@ declare function createCanvasArrangeController<TNode extends CanvasNode = Canvas
 };
 type CanvasArrangeController<TNode extends CanvasNode = CanvasNode> = ReturnType<typeof createCanvasArrangeController<TNode>>;
 
-export { type AlignEdge, type AlignNodesOptions, type ArrangeHistoryTarget, type ArrangeShortcutBinding, CONNECTION_LINE_TYPES, type CanvasArrangeAction, type CanvasArrangeController, type CanvasArrangeControllerOptions, CanvasClipboardPayload, type CanvasConnectionLineType, CanvasEdge, type CanvasHeightOptions, CanvasLayoutOptions, CanvasNode, CanvasNodeStyle, type CanvasNodeUpdate, type CanvasScene, type CanvasScenesOptions, type CanvasScenesState, CanvasScenesStore, type CanvasViewport, type Clock, type CombineShapeNodesOptions, type CombineShapeNodesRefusal, type CombineShapeNodesResult, type ConnectorSnap, type ConnectorSnapOptions, type ConnectorSnapTarget, DEFAULT_ARRANGE_SHORTCUTS, DEFAULT_NODE_HEIGHT, DEFAULT_NODE_WIDTH, DEFAULT_PLACEMENT_GAP, DirectionalDisplacementOptions, type DistributeAxis, type DistributeMode, type DistributeNodesOptions, type EllipseShape, FanOutTrajectoryOptions, type FitViewportOptions, type FlattenOptions, type GuideIndex, type GuideLine, IncrementalLayoutOptions, LOCKED_DATA_KEY, LOCKED_PREVIOUS_FLAGS_KEY, ManualClock, type MatchSizeOptions, type MultiNodeTransitionOptions, type MultiPolygon, type NodeRectOptions, NodeTransition, type PathCommand, type PathShape, PlaceBesideOptions, Point, type PolygonBooleanOperation, type PolygonBooleanOptions, type PolygonFillRule, type PolygonInput, type PolygonOperand, type PolygonPiece, type PolygonRing, type PolygonToPathOptions, type PolygonWithHoles, Position, type PositionChangeLike, Rect, type RectShape, ReflowDisplacementOptions, type RegularPolygonShape, SHAPE_DATA_KEY, SHAPE_KINDS, SHAPE_NODE_TYPE, SHAPE_OPERATIONS, type SerializedCanvasScenes, type ShapeDescription, type ShapeKind, type ShapeNodePolygonOptions, type ShapeOperation, type ShapePaint, type ShapeRenderData, type ShapeSize, Side, type SizeDimension, type SnapGuidesOptions, type SnapNodeDragOptions, type SnapNodeDragResult, type SnapResult, type StarShape, StreamingLayoutManager, type StreamingLayoutManagerOptions, TrajectoryFunction, XYPosition, type ZOrderOperation, alignNodes, applyNodeUpdates, applyShapeCombination, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canCombineShapeNodes, canvasHeight, centerNodes, centre, collectDescendantIds, combineShapeNodes, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasArrangeController, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, createNodeLookup, defaultEasing, distributeNodes, dividePolygons, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitViewportToNodes, fitViewportToRect, flattenSvgPath, flowSide, formatNumber, getAbsolutePosition, getCenteredNodePosition, getLayoutedNodes, getNodeRect, getNodeShape, getNodeSize, getShapeRenderData, getShapeSvg, handlePoint, intersectPolygons, invertNodeUpdates, isEventFromTextInput, isLocked, isShapeDescription, isShapeNode, isValidCanvasEdge, isValidCanvasNode, isValidCanvasScene, isValidUrl, layoutBounds, linearPositionTrajectory, linearTrajectory, lockNodes, matchArrangeShortcut, matchSize, multiPolygonArea, multiPolygonBounds, nearestHandlePositions, oppositePosition, overlaps, pageHidden, parseCanvasClipboardData, parseCanvasScenes, parseSvgPath, placeBeside, pointInMultiPolygon, pointInRings, polygonArea, polygonBoolean, polygonToSvgPath, positionToSide, readStyleSize, realClock, remapPastedNodes, reorderNodes, repositionNodesTo, revertShapeCombination, ringSignedArea, runMultiNodeTransition, serializeCanvasNodes, shapeNodeToPolygon, shapeToPolygon, sideToPosition, simplifyRing, snapNodeDrag, subtractPolygons, toggleLockNodes, unionPolygons, unlockNodes, withStyleOpacity, withStyleSize, xorPolygons };
+/**
+ * A measuring line in flow coordinates. `measure` lines carry a `label` (the distance);
+ * `extension` lines are dashed, unlabelled lines that carry a gap over to the measured box
+ * when the gap line passes beside it.
+ */
+interface MeasureGuide extends GuideLine {
+    kind: 'measure' | 'extension';
+    /** The distance as shown on the label (`measure` lines only). */
+    label?: string;
+}
+/** A distance as shown on a label: absolute value, up to two decimals, no trailing zeros. */
+declare function measureLabel(distance: number): string;
+/**
+ * Distance lines from box `a` (the selection) to box `b` (the hovered shape):
+ *
+ * - **One inside the other**: from the inner box to each edge of the outer one, along the
+ *   inner box's centre lines (the same lines either way round).
+ * - **Overlapping**: between the matching edges (left to left, right to right, ...).
+ * - **Apart**: the horizontal and/or vertical gap, across the shared rows / columns, or from
+ *   the middle of `a` with a dashed `extension` line to `b` when the gap line passes beside it.
+ *   Touching boxes have no gap to draw.
+ */
+declare function measureBetween(a: Rect, b: Rect): MeasureGuide[];
+/**
+ * Distance lines from box `a` to an infinite guide line (`vertical` at x = `at`, otherwise
+ * horizontal at y = `at`): to the nearer side, or to both sides when the line crosses the box.
+ */
+declare function measureToLine(a: Rect, orientation: 'vertical' | 'horizontal', at: number): MeasureGuide[];
+interface MeasureSelectionResult {
+    /** Measuring lines in flow coordinates. */
+    guides: MeasureGuide[];
+    /** The box measured to (to outline), or `null` when nothing is measured. */
+    target: Rect | null;
+    /** The selection's bounding box, or `null` without a selection. */
+    selection: Rect | null;
+}
+interface MeasureSelectionOptions extends NodeRectOptions {
+}
+/**
+ * Alt-hover measuring on canvas nodes: from the bounding box of `selectedIds` (absolute,
+ * union of several nodes) to the hovered node. Hovering the selection itself, or nothing
+ * (`hoveredId` null), measures to the selection's parent (`parentId`) when it has one;
+ * a top-level selection then measures nothing. Hidden nodes are ignored.
+ */
+declare function measureSelection(nodes: CanvasNode[], selectedIds: Iterable<string>, hoveredId: string | null | undefined, options?: MeasureSelectionOptions): MeasureSelectionResult;
+/**
+ * Whether the measuring modifier (Alt / Option) is held after a keyboard or pointer event.
+ * `keyup` of Alt releases it; `keydown` of Alt or any event with `altKey` holds it.
+ */
+declare function isMeasureModifierHeld(event: {
+    type?: string;
+    key?: string;
+    altKey?: boolean;
+} | null | undefined): boolean;
+
+/**
+ * Least-squares cubic Bézier fitting of point sequences (Schneider-style: fit one cubic with
+ * fixed end tangents, reparameterise with Newton steps, split at the worst point), with
+ * corner preservation by a turning-angle test.
+ *
+ * Portions ported from vectorcraft-main/crates/pathops/src/fit.rs and
+ * vectorcraft-main/crates/pathops/src/edit.rs (MIT OR Apache-2.0, © ArtCraft Team and
+ * contributors). See THIRD_PARTY_NOTICES.md.
+ */
+
+/** One cubic Bézier segment. */
+interface CubicSegment {
+    p0: Point;
+    p1: Point;
+    p2: Point;
+    p3: Point;
+}
+interface FitCubicsOptions {
+    /**
+     * Vertices where the polyline turns by more than this many degrees stay sharp corners
+     * (default 30). Use 180 to smooth through every vertex.
+     */
+    cornerAngleDeg?: number;
+    /** Treat the points as a closed ring (the last point connects back to the first). */
+    closed?: boolean;
+}
+/** Evaluates a cubic segment at `t` ∈ [0, 1]. */
+declare function cubicPointAt(c: CubicSegment, t: number): Point;
+/**
+ * Fits a G1-continuous chain of cubics through `points` (an open run) with the unit
+ * tangents `t0` (leaving the first point) and `t1` (arriving at the last point, forward);
+ * both are estimated from the end points when omitted. Every point lies within `tolerance`
+ * of the curve at its fitted parameter.
+ */
+declare function fitCubicRun(points: readonly Point[], tolerance: number, t0?: Point, t1?: Point): CubicSegment[];
+/**
+ * Fits cubic Bézier segments to a polyline (`closed` for a ring), keeping vertices that turn
+ * by more than `cornerAngleDeg` (default 30°) as sharp corners. Each stretch between corners
+ * is fitted Schneider-style so that every input point is within `tolerance` of the result.
+ *
+ * Returns the segments in order (consecutive segments share end points; a closed result ends
+ * where it starts). Fewer than two distinct points give an empty array.
+ */
+declare function fitCubics(points: readonly Point[], tolerance: number, options?: FitCubicsOptions): CubicSegment[];
+/** Whether a cubic is (within `tol`) the straight line from `p0` to `p3`. */
+declare function isStraightCubic(c: CubicSegment, tol: number): boolean;
+interface FitPathDataOptions extends FitCubicsOptions {
+    /** Fitting tolerance in path units (default 0.5). */
+    tolerance?: number;
+    /** Decimal places (default 3). */
+    precision?: number;
+    /** Added to every point before formatting. */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Keep the original polyline when fitting would need more segments than it has edges
+     * (default `true`), so fitting never makes a path heavier.
+     */
+    noWorse?: boolean;
+}
+/** SVG `d` for fitted segments (`L` for straight ones, `C` otherwise). */
+declare function cubicsToPathData(segments: readonly CubicSegment[], options?: {
+    precision?: number;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    closed?: boolean;
+    straightTolerance?: number;
+}): string;
+/**
+ * Fits smooth curves to a polygon ring (closed by default) and returns SVG path data with
+ * `C` curves for smooth stretches, `L` lines for straight ones and sharp corners kept.
+ * Use it for boolean results of curved shapes or to smooth freehand strokes
+ * (`{ closed: false }`, see `fitFreehandPath`).
+ */
+declare function fitPathData(ring: readonly Point[], options?: FitPathDataOptions): string;
+/**
+ * Smooths a freehand stroke (pointer samples) into an open SVG path of cubic curves.
+ * `tolerance` is the largest distance (in the points' units) a sample may be from the
+ * curve (default 1); sharp turns above `cornerAngleDeg` (default 30) stay corners.
+ */
+declare function fitFreehandPath(points: readonly Point[], options?: Omit<FitPathDataOptions, 'closed'>): string;
+
+export { AlignEdge, AlignNodesOptions, type ArrangeHistoryTarget, CONNECTION_LINE_TYPES, CanvasArrangeAction, type CanvasArrangeController, type CanvasArrangeControllerOptions, CanvasClipboardPayload, type CanvasConnectionLineType, CanvasEdge, type CanvasHeightOptions, CanvasLayoutOptions, CanvasNode, CanvasNodeStyle, CanvasNodeUpdate, type CanvasScene, type CanvasScenesOptions, type CanvasScenesState, CanvasScenesStore, type CanvasViewport, type Clock, type CombineShapeNodesOptions, type CombineShapeNodesRefusal, type CombineShapeNodesResult, type ConnectorSnap, type ConnectorSnapOptions, type ConnectorSnapTarget, type CubicSegment, DEFAULT_NODE_HEIGHT, DEFAULT_NODE_WIDTH, DEFAULT_PLACEMENT_GAP, DirectionalDisplacementOptions, DistributeAxis, DistributeMode, DistributeNodesOptions, type EllipseShape, FanOutTrajectoryOptions, type FitCubicsOptions, type FitPathDataOptions, type FitViewportOptions, type FlattenOptions, type GuideIndex, type GuideLine, IncrementalLayoutOptions, ManualClock, MatchSizeOptions, type MeasureGuide, type MeasureSelectionOptions, type MeasureSelectionResult, type MultiNodeTransitionOptions, type MultiPolygon, NodeRectOptions, NodeTransition, type PathCommand, type PathShape, PlaceBesideOptions, Point, type PolygonBooleanOperation, type PolygonBooleanOptions, type PolygonFillRule, type PolygonInput, type PolygonOperand, type PolygonPiece, type PolygonRing, type PolygonToPathOptions, type PolygonWithHoles, Position, type PositionChangeLike, RESIZE_HANDLES, Rect, type RectShape, ReflowDisplacementOptions, type RegularPolygonShape, type ResizeHandle, SHAPE_DATA_KEY, SHAPE_KINDS, SHAPE_NODE_TYPE, SHAPE_OPERATIONS, type SerializedCanvasScenes, type ShapeDescription, type ShapeKind, type ShapeNodePolygonOptions, type ShapeOperation, type ShapePaint, type ShapeRenderData, type ShapeSize, Side, SizeDimension, type SnapGuidesOptions, type SnapNodeDragOptions, type SnapNodeDragResult, type SnapNodeResizeOptions, type SnapNodeResizeResult, type SnapResizeOptions, type SnapResizeResult, type SnapResult, type StarShape, StreamingLayoutManager, type StreamingLayoutManagerOptions, TrajectoryFunction, XYPosition, ZOrderOperation, applyShapeCombination, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canCombineShapeNodes, canvasHeight, centerNodes, centre, collectDescendantIds, combineShapeNodes, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasArrangeController, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, cubicPointAt, cubicsToPathData, defaultEasing, dividePolygons, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitCubicRun, fitCubics, fitFreehandPath, fitPathData, fitViewportToNodes, fitViewportToRect, flattenSvgPath, flowSide, formatNumber, getCenteredNodePosition, getLayoutedNodes, getNodeShape, getResizingNodeRect, getShapeRenderData, getShapeSvg, handlePoint, inferResizeHandle, intersectPolygons, isEventFromTextInput, isMeasureModifierHeld, isShapeDescription, isShapeNode, isStraightCubic, isValidCanvasEdge, isValidCanvasNode, isValidCanvasScene, isValidUrl, layoutBounds, linearPositionTrajectory, linearTrajectory, measureBetween, measureLabel, measureSelection, measureToLine, multiPolygonArea, multiPolygonBounds, nearestHandlePositions, oppositePosition, overlaps, pageHidden, parseCanvasClipboardData, parseCanvasScenes, parseSvgPath, placeBeside, pointInMultiPolygon, pointInRings, polygonArea, polygonBoolean, polygonToSvgPath, positionToSide, realClock, remapPastedNodes, repositionNodesTo, resizeHandleAxes, revertShapeCombination, ringSignedArea, runMultiNodeTransition, serializeCanvasNodes, shapeNodeToPolygon, shapeToPolygon, sideToPosition, simplifyRing, snapNodeDrag, snapNodeResize, snapResize, snapToGrid, subtractPolygons, unionPolygons, withStyleOpacity, xorPolygons };