@pixerate/editor 0.21.0 → 0.22.0

package/dist/canvas/index.d.ts

@@ -1,5 +1,5 @@
-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 } from '../types-DMe0vFB1.js';
-export { g as CanvasDockingCallbacks, h as CollapseNodeOptions, i as DisplacementDirection, j as DockStrategy, E as ExplodeNodeOptions, k as ExplosionSnapshot, G as GraphDifferences, l as Point, m as TrajectoryPoint } from '../types-DMe0vFB1.js';
+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.js';
+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.js';
 import { C as Command } from '../types-BZgcDsC5.js';
 
 declare const DEFAULT_NODE_WIDTH = 200;
@@ -765,6 +765,410 @@ declare const DEFAULT_ARRANGE_SHORTCUTS: readonly ArrangeShortcutBinding[];
  */
 declare function matchArrangeShortcut(event: KeyboardEvent, bindings?: readonly ArrangeShortcutBinding[]): CanvasArrangeAction | null;
 
+/**
+ * Polygon boolean operations (union, intersection, difference, xor and divide) on
+ * multi-polygons with holes.
+ *
+ * Algorithm (overlay + winding classification):
+ * 1. Every input edge is collected into one segment set. Vertices are merged through a
+ *    tolerance-aware point pool, so points closer than `epsilon` become one vertex.
+ * 2. Segments are split at every crossing, T-junction and collinear overlap until no two
+ *    segments cross (a planar arrangement). Splitting is repeated because snapping a new
+ *    vertex can move a segment by up to `epsilon`.
+ * 3. Coincident segments (shared edges) are merged, keeping for every operand the signed
+ *    number of its edges that run along the segment.
+ * 4. For every segment the winding number of each operand on its right side is computed
+ *    with a ray cast from the segment midpoint (the segment itself excluded), and the left
+ *    side follows from the signed multiplicities. The fill rule turns windings into
+ *    inside / outside flags and the operation decides whether each side is in the result.
+ * 5. Segments with the result on exactly one side are kept, oriented with the result on
+ *    their left, and traced into rings (taking the sharpest left turn at shared vertices,
+ *    so rings that touch at a vertex stay separate simple rings). Rings with a positive
+ *    signed area are outer rings; negative ones are holes, assigned to the smallest outer
+ *    ring that contains them.
+ *
+ * Handles shared edges, touching vertices, collinear overlaps, holes, nested and disjoint
+ * inputs and self-intersecting input rings (resolved by the operand's fill rule).
+ *
+ * Limits: the overlay is O(n²) in the number of edges (pruned by a sweep on x), which is
+ * comfortable for canvas shapes (thousands of edges) but not for GIS-scale data. Features
+ * narrower than `epsilon` collapse. Coordinates must be finite.
+ */
+
+/** A closed ring of points. The closing point may be repeated or omitted. */
+type PolygonRing = Point[];
+/** A polygon: the outer ring followed by its holes. */
+type PolygonWithHoles = PolygonRing[];
+/** A set of polygons. */
+type MultiPolygon = PolygonWithHoles[];
+/** SVG fill rule used to decide which areas of a ring set are inside. */
+type PolygonFillRule = 'nonzero' | 'evenodd';
+/** Boolean operations. `xor` is Freeform's Exclude. */
+type PolygonBooleanOperation = 'union' | 'intersection' | 'difference' | 'xor';
+/**
+ * A raw ring set with a fill rule (e.g. flattened SVG path data). Ring orientation is
+ * significant for `nonzero`.
+ */
+interface PolygonOperand {
+    rings: PolygonRing[];
+    fillRule?: PolygonFillRule;
+}
+type PolygonInput = MultiPolygon | PolygonOperand;
+interface PolygonBooleanOptions {
+    /**
+     * Distance below which points are treated as equal. Defaults to `1e-9` times the
+     * largest coordinate magnitude of the inputs (at least `1e-9`).
+     */
+    epsilon?: number;
+}
+/** One region of `dividePolygons`, with the indices of the operands that cover it. */
+interface PolygonPiece {
+    polygon: PolygonWithHoles;
+    operands: number[];
+}
+/** Signed shoelace area of a ring (positive when counter-clockwise in a y-up frame). */
+declare function ringSignedArea(ring: readonly Point[]): number;
+/** Area of a polygon (outer ring minus holes). */
+declare function polygonArea(polygon: PolygonWithHoles): number;
+/** Total area of a multi-polygon (holes subtracted). */
+declare function multiPolygonArea(multi: MultiPolygon): number;
+/** Axis-aligned bounds of a multi-polygon (or ring list), or `null` when empty. */
+declare function multiPolygonBounds(input: MultiPolygon | PolygonRing[]): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+} | null;
+/**
+ * Whether a point is inside a ring set under a fill rule. Points exactly on an edge may
+ * report either side.
+ */
+declare function pointInRings(point: Point, rings: readonly (readonly Point[])[], fillRule?: PolygonFillRule): boolean;
+/** Whether a point is inside a multi-polygon (holes excluded). */
+declare function pointInMultiPolygon(point: Point, multi: MultiPolygon): boolean;
+/**
+ * Applies a boolean operation to any number of operands.
+ * - `union`: covered by any operand.
+ * - `intersection`: covered by every operand.
+ * - `difference`: the first operand minus all others.
+ * - `xor`: covered by an odd number of operands (Exclude).
+ *
+ * Returns simple rings: outer rings have a positive signed area, holes a negative one.
+ * Rings may touch at vertices but never cross.
+ */
+declare function polygonBoolean(operation: PolygonBooleanOperation, operands: PolygonInput[], options?: PolygonBooleanOptions): MultiPolygon;
+declare const unionPolygons: (a: PolygonInput, b: PolygonInput, options?: PolygonBooleanOptions) => MultiPolygon;
+declare const intersectPolygons: (a: PolygonInput, b: PolygonInput, options?: PolygonBooleanOptions) => MultiPolygon;
+declare const subtractPolygons: (a: PolygonInput, b: PolygonInput, options?: PolygonBooleanOptions) => MultiPolygon;
+declare const xorPolygons: (a: PolygonInput, b: PolygonInput, options?: PolygonBooleanOptions) => MultiPolygon;
+/**
+ * Splits the overlay of the operands into its distinct regions (Freeform's Divide): every
+ * connected area covered by the same set of operands becomes one piece. Pieces are ordered
+ * by their operand set, then by size (largest first).
+ */
+declare function dividePolygons(operands: PolygonInput[], options?: PolygonBooleanOptions): PolygonPiece[];
+
+/**
+ * Shape geometry: shape descriptions (rect, rounded rect, ellipse, regular polygon, star and
+ * SVG path data) to polygons, SVG path parsing / flattening, and polygons back to path data.
+ */
+
+/** Paint shared by every shape kind. Colours are any CSS colour. */
+interface ShapePaint {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+}
+interface ShapeBase extends ShapePaint {
+    /** Clockwise rotation in degrees (on a y-down canvas) about the centre of the node box. */
+    rotation?: number;
+}
+/** Rectangle filling the node box, optionally with rounded corners. */
+interface RectShape extends ShapeBase {
+    kind: 'rect';
+    /** One radius, or `[topLeft, topRight, bottomRight, bottomLeft]`. Clamped to fit. */
+    cornerRadius?: number | readonly [number, number, number, number];
+}
+/** Ellipse (circle when the node is square) inscribed in the node box. */
+interface EllipseShape extends ShapeBase {
+    kind: 'ellipse';
+}
+/** Regular polygon, stretched so its bounding box fills the node box. */
+interface RegularPolygonShape extends ShapeBase {
+    kind: 'polygon';
+    /** Number of sides (at least 3, default 6). The first vertex points up. */
+    sides?: number;
+}
+/** Star, stretched so its bounding box fills the node box. */
+interface StarShape extends ShapeBase {
+    kind: 'star';
+    /** Number of points (at least 3, default 5). The first point points up. */
+    points?: number;
+    /** Inner radius as a fraction of the outer radius (default 0.5). */
+    innerRadius?: number;
+}
+/** Arbitrary SVG path data. */
+interface PathShape extends ShapeBase {
+    kind: 'path';
+    d: string;
+    /**
+     * `[minX, minY, width, height]` of the path's coordinate space, scaled to the node box.
+     * Without it the path coordinates are node-local pixels.
+     */
+    viewBox?: readonly [number, number, number, number];
+    /** Fill rule (default `nonzero`, as in SVG). */
+    fillRule?: PolygonFillRule;
+}
+/**
+ * Shape description stored on a node as `data.shape`. Geometry is relative to the node
+ * box (`0,0` to `width,height`), so resizing the node resizes the shape.
+ */
+type ShapeDescription = RectShape | EllipseShape | RegularPolygonShape | StarShape | PathShape;
+type ShapeKind = ShapeDescription['kind'];
+declare const SHAPE_KINDS: readonly ShapeKind[];
+/** Whether a value is a supported shape description. */
+declare function isShapeDescription(value: unknown): value is ShapeDescription;
+interface ShapeSize {
+    width: number;
+    height: number;
+}
+interface FlattenOptions {
+    /** Maximum distance between a curve and its polyline, in output units (default 0.25). */
+    tolerance?: number;
+    /** Upper bound on the segments one curve is split into (default 512). */
+    maxSegments?: number;
+}
+/** Normalised absolute path command produced by `parseSvgPath`. */
+type PathCommand = {
+    type: 'M';
+    x: number;
+    y: number;
+} | {
+    type: 'L';
+    x: number;
+    y: number;
+} | {
+    type: 'C';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: 'Q';
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+} | {
+    type: 'A';
+    rx: number;
+    ry: number;
+    rotation: number;
+    largeArc: boolean;
+    sweep: boolean;
+    x: number;
+    y: number;
+} | {
+    type: 'Z';
+};
+/**
+ * Parses SVG path data into absolute `M`, `L`, `C`, `Q`, `A` and `Z` commands. Relative
+ * commands, `H` / `V`, smooth curves (`S` / `T`) and implicit repeated commands are
+ * normalised. Parsing stops at the first malformed command (as browsers do).
+ */
+declare function parseSvgPath(d: string): PathCommand[];
+/**
+ * Flattens SVG path data into closed rings (one per subpath; open subpaths are closed the
+ * way SVG fills them). Curves are approximated within `tolerance`.
+ */
+declare function flattenSvgPath(d: string | PathCommand[], options?: FlattenOptions): PolygonRing[];
+/**
+ * SVG path data for a shape in node-local pixels (exact curves: arcs for rounded corners
+ * and ellipses), plus the fill rule and a `transform` for rotation / path view boxes.
+ * Use it to render a shape; use `shapeToPolygon` for geometry.
+ */
+declare function getShapeSvg(shape: ShapeDescription, size: ShapeSize): {
+    d: string;
+    transform?: string;
+    fillRule: PolygonFillRule;
+};
+/** Everything a renderer needs to draw a shape as one SVG `<path>`. */
+interface ShapeRenderData {
+    /** SVG `viewBox` (`0 0 width height`): node-local pixels. */
+    viewBox: string;
+    width: number;
+    height: number;
+    d: string;
+    transform?: string;
+    fillRule: PolygonFillRule;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    opacity?: number;
+}
+/**
+ * Resolves the SVG drawing of a shape for a node size. Without a size, a path's view box
+ * size (or 100x100) is used. Paint defaults: `fill: currentColor`, `stroke: none`,
+ * `strokeWidth: 1`.
+ */
+declare function getShapeRenderData(shape: ShapeDescription, size?: Partial<ShapeSize>): ShapeRenderData;
+/**
+ * Converts a shape to rings in node-local pixels (rotation applied), flattening curves at
+ * `tolerance`. Returns the rings with the fill rule they must be read with.
+ */
+declare function shapeToPolygon(shape: ShapeDescription, size: ShapeSize, options?: FlattenOptions): {
+    rings: PolygonRing[];
+    fillRule: PolygonFillRule;
+};
+/** Formats a number with at most `precision` decimals, without trailing zeros. */
+declare function formatNumber(value: number, precision?: number): string;
+/**
+ * Simplifies a closed ring with Ramer–Douglas–Peucker at `tolerance`. Returns an empty
+ * ring when fewer than three points survive.
+ */
+declare function simplifyRing(ring: readonly Point[], tolerance: number): Point[];
+interface PolygonToPathOptions {
+    /** Decimal places in the output (default 3). */
+    precision?: number;
+    /** Ramer–Douglas–Peucker tolerance; `0` (default) keeps every vertex. */
+    simplify?: number;
+    /** Added to every point before formatting (e.g. to make coordinates node-local). */
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Converts a multi-polygon (or a list of rings) to SVG path data using `M`/`L`/`Z`. Holes
+ * keep their opposite orientation, so the path fills correctly with either fill rule.
+ */
+declare function polygonToSvgPath(input: MultiPolygon | PolygonRing[], options?: PolygonToPathOptions): string;
+
+/**
+ * Shape nodes and Freeform-style shape boolean operations (Unite / Intersect / Subtract /
+ * Exclude / Divide) on canvas nodes.
+ *
+ * A shape node is any node whose `data.shape` is a `ShapeDescription`. Its geometry is
+ * relative to the node box, so moving or resizing the node moves / resizes the shape.
+ */
+
+/** Data key holding a node's shape description. */
+declare const SHAPE_DATA_KEY = "shape";
+/** Node type suggested for shape nodes (register `ShapeNode` under it). */
+declare const SHAPE_NODE_TYPE = "shape";
+/** Freeform's shape operations. `exclude` is xor; `divide` splits into every region. */
+type ShapeOperation = 'unite' | 'intersect' | 'subtract' | 'exclude' | 'divide';
+declare const SHAPE_OPERATIONS: readonly ShapeOperation[];
+/** Whether a node carries a supported `data.shape`. */
+declare function isShapeNode(node: CanvasNode | undefined | null): boolean;
+/** The node's shape description, or `null`. */
+declare function getNodeShape(node: CanvasNode | undefined | null): ShapeDescription | null;
+interface ShapeNodePolygonOptions extends NodeRectOptions {
+    /** Curve flattening tolerance in flow units (default 0.25). */
+    tolerance?: number;
+}
+/**
+ * A shape node's outline in absolute flow coordinates (parent offsets, size and rotation
+ * applied), or `null` for non-shape nodes.
+ */
+declare function shapeNodeToPolygon(node: CanvasNode, lookup?: ReadonlyMap<string, CanvasNode>, options?: ShapeNodePolygonOptions): {
+    rings: PolygonRing[];
+    fillRule: PolygonFillRule;
+} | null;
+/** Why `combineShapeNodes` refused. */
+type CombineShapeNodesRefusal = 
+/** A selected shape is locked; locked shapes are never consumed. */
+'locked'
+/** Fewer than two shape nodes were selected. */
+ | 'too-few'
+/** The operation leaves nothing (e.g. intersecting shapes that do not overlap). */
+ | 'empty';
+interface CombineShapeNodesOptions extends ShapeNodePolygonOptions {
+    /**
+     * Which shape's node style and data the result inherits: `bottom` (default, like
+     * Freeform: the back-most shape), `top`, `first` (first id passed), or a node id.
+     * Divide pieces always take the style of the top-most shape covering them.
+     */
+    styleFrom?: 'bottom' | 'top' | 'first' | {
+        id: string;
+    };
+    /** Id factory for new nodes (default `crypto.randomUUID`, with a counter fallback). */
+    createId?: (index: number) => string;
+    /** Node `type` for the new nodes (default: the style source's type). */
+    nodeType?: string;
+    /** Decimal places in the path data (default 3). */
+    precision?: number;
+    /** Ramer–Douglas–Peucker simplification tolerance for the result (default 0, off). */
+    simplify?: number;
+    /** Point-merge tolerance passed to the boolean engine. */
+    epsilon?: number;
+    /** Select the new nodes (default `true`). */
+    select?: boolean;
+}
+type CombineShapeNodesResult<TNode extends CanvasNode = CanvasNode> = {
+    ok: true;
+    operation: ShapeOperation;
+    /** Ids of the shape nodes consumed by the operation. */
+    removeIds: string[];
+    /** New path shape node(s): one, or one per region for `divide`. */
+    nodes: TNode[];
+} | {
+    ok: false;
+    operation: ShapeOperation;
+    reason: CombineShapeNodesRefusal;
+};
+/**
+ * Checks whether `combineShapeNodes` can run, without computing geometry (it cannot
+ * predict an `empty` result). Use it to enable menu items.
+ */
+declare function canCombineShapeNodes(nodes: CanvasNode[], ids: Iterable<string>): {
+    ok: true;
+    shapeIds: string[];
+} | {
+    ok: false;
+    reason: Exclude<CombineShapeNodesRefusal, 'empty'>;
+};
+/**
+ * Freeform-style shape operations on canvas nodes.
+ *
+ * - Only shape nodes (`data.shape`) among `ids` take part; other selected nodes are ignored.
+ * - Refuses (`ok: false`) when a selected shape is locked, when fewer than two shapes are
+ *   selected, or when the result is empty. Nothing should be changed on refusal.
+ * - `subtract` removes every other shape from the back-most one; the other operations are
+ *   symmetric. `divide` returns one node per distinct region of the overlay.
+ * - Each new node is a `path` shape: its position / size is the result's bounding box and
+ *   its path data is node-local with `viewBox = [0, 0, width, height]`, so it scales with
+ *   the node. Rotation is baked into the path. Node fields and `data` (other than the
+ *   shape geometry, lock state and size) come from the style source.
+ * - When all shapes share a parent, the new nodes keep it; otherwise they are top-level.
+ *
+ * Pure: returns the change; apply it with `applyShapeCombination` (or the arrange
+ * controller's `combineShapes`, which also records one undo step).
+ */
+declare function combineShapeNodes<TNode extends CanvasNode>(nodes: TNode[], ids: Iterable<string>, operation: ShapeOperation, options?: CombineShapeNodesOptions): CombineShapeNodesResult<TNode>;
+/**
+ * Applies a successful `combineShapeNodes` result: removes the consumed nodes and inserts
+ * the new ones at the array index of the first consumed node.
+ * With `deselect` (default `true`) other nodes are deselected when the result is selected.
+ */
+declare function applyShapeCombination<TNode extends CanvasNode>(nodes: TNode[], change: {
+    removeIds: Iterable<string>;
+    nodes: TNode[];
+}, options?: {
+    deselect?: boolean;
+}): TNode[];
+/**
+ * Reverses `applyShapeCombination`: removes the created nodes and puts the consumed nodes
+ * back at their original array indices (`previous` is the node array before the change).
+ */
+declare function revertShapeCombination<TNode extends CanvasNode>(nodes: TNode[], change: {
+    removeIds: Iterable<string>;
+    nodes: TNode[];
+}, previous: TNode[]): TNode[];
+
 /** Minimal history surface (`HistoryManager` satisfies it). */
 interface ArrangeHistoryTarget {
     execute(command: Command): void;
@@ -787,10 +1191,14 @@ interface CanvasArrangeControllerOptions<TNode extends CanvasNode = CanvasNode>
     /** Called whenever the guide segments change (set while dragging, cleared on drop). */
     onGuidesChange?: (guides: GuideLine[]) => void;
 }
-/** A React Flow / SvelteFlow style node change; only `position` changes are inspected. */
+/**
+ * A React Flow / SvelteFlow style node change; only `position` changes are inspected.
+ * `id` is optional because a batch can contain changes without one (React Flow's
+ * `add` change carries an `item` instead), so `NodeChange[]` must be accepted as is.
+ */
 interface PositionChangeLike {
     type: string;
-    id: string;
+    id?: string;
     position?: XYPosition;
     dragging?: boolean;
     [key: string]: any;
@@ -815,6 +1223,20 @@ declare function createCanvasArrangeController<TNode extends CanvasNode = Canvas
     unlock: (ids?: Iterable<string>) => string[];
     toggleLock(ids?: Iterable<string>): string[];
     isLocked: (id: string) => boolean;
+    /**
+     * Freeform shape operation (Unite / Intersect / Subtract / Exclude / Divide) on the
+     * shape nodes among `ids` (default: the selection). Replaces them with the result as
+     * one undoable step. Refuses without changing anything when a selected shape is
+     * locked, fewer than two shapes are selected, or the result is empty.
+     */
+    combineShapes(operation: ShapeOperation, ids?: Iterable<string>, combineOptions?: CombineShapeNodesOptions): CombineShapeNodesResult<TNode>;
+    unite: (ids?: Iterable<string>, o?: CombineShapeNodesOptions) => CombineShapeNodesResult<TNode>;
+    intersect: (ids?: Iterable<string>, o?: CombineShapeNodesOptions) => CombineShapeNodesResult<TNode>;
+    subtract: (ids?: Iterable<string>, o?: CombineShapeNodesOptions) => CombineShapeNodesResult<TNode>;
+    exclude: (ids?: Iterable<string>, o?: CombineShapeNodesOptions) => CombineShapeNodesResult<TNode>;
+    divide: (ids?: Iterable<string>, o?: CombineShapeNodesOptions) => CombineShapeNodesResult<TNode>;
+    /** Whether the shape operations can run on `ids` (default: the selection). */
+    canCombineShapes: (ids?: Iterable<string>) => boolean;
     /**
      * Runs a shortcut action. Scene actions are not handled here (see the scenes store);
      * returns `false` for them and for unknown actions.
@@ -834,9 +1256,13 @@ 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[];
-    /** Clears guides and the cached snap targets. */
+    /**
+     * 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
+     * last snapped positions from `drag` are written back here.
+     */
     endDrag(): void;
 };
 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 ConnectorSnap, type ConnectorSnapOptions, type ConnectorSnapTarget, DEFAULT_ARRANGE_SHORTCUTS, DEFAULT_NODE_HEIGHT, DEFAULT_NODE_WIDTH, DEFAULT_PLACEMENT_GAP, DirectionalDisplacementOptions, type DistributeAxis, type DistributeMode, type DistributeNodesOptions, FanOutTrajectoryOptions, type FitViewportOptions, type GuideIndex, type GuideLine, IncrementalLayoutOptions, LOCKED_DATA_KEY, LOCKED_PREVIOUS_FLAGS_KEY, ManualClock, type MatchSizeOptions, type MultiNodeTransitionOptions, type NodeRectOptions, NodeTransition, PlaceBesideOptions, Position, type PositionChangeLike, Rect, ReflowDisplacementOptions, type SerializedCanvasScenes, Side, type SizeDimension, type SnapGuidesOptions, type SnapNodeDragOptions, type SnapNodeDragResult, type SnapResult, StreamingLayoutManager, type StreamingLayoutManagerOptions, TrajectoryFunction, XYPosition, type ZOrderOperation, alignNodes, applyNodeUpdates, blendLayout, boundsOf, calculateDagreReflowDisplacement, calculateDirectionalDisplacement, canvasHeight, centerNodes, centre, collectDescendantIds, computeNodesBoundingBox, computeSnapGuides, connectedOnly, createBezierTrajectory, createCanvasArrangeController, createCanvasScenesStore, createFanOutTrajectory, createGuideIndex, createNodeGuideIndex, createNodeLookup, defaultEasing, distributeNodes, ensureLayout, estimateCanvasHeight, estimateNodeSize, findConnectorSnap, fitViewportToNodes, fitViewportToRect, flowSide, getAbsolutePosition, getCenteredNodePosition, getLayoutedNodes, getNodeRect, getNodeSize, handlePoint, invertNodeUpdates, isEventFromTextInput, isLocked, isValidCanvasEdge, isValidCanvasNode, isValidCanvasScene, isValidUrl, layoutBounds, linearPositionTrajectory, linearTrajectory, lockNodes, matchArrangeShortcut, matchSize, nearestHandlePositions, oppositePosition, overlaps, pageHidden, parseCanvasClipboardData, parseCanvasScenes, placeBeside, positionToSide, readStyleSize, realClock, remapPastedNodes, reorderNodes, repositionNodesTo, runMultiNodeTransition, serializeCanvasNodes, sideToPosition, snapNodeDrag, toggleLockNodes, unlockNodes, withStyleOpacity, withStyleSize };
+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 };