@pixerate/editor 0.21.0 → 0.23.0

package/dist/canvas/index.d.ts

@@ -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 } 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 { C as Command } from '../types-BZgcDsC5.js';
+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.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-DX4Mh4SL.js';
+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-sLlD2rSX.js';
+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-sLlD2rSX.js';
+import { C as Command } from '../types-GT5a5YAX.js';
 
 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;
 }
@@ -739,31 +607,498 @@ declare function fitViewportToNodes(nodes: CanvasNode[], size: {
 }, ids?: Iterable<string>, options?: FitViewportOptions & NodeRectOptions): CanvasViewport | null;
 
 /**
- * Canvas arrangement actions that have keyboard shortcuts.
+ * 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.
  */
-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;
+
+/** 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;
 /**
- * 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.
+ * 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 const DEFAULT_ARRANGE_SHORTCUTS: readonly ArrangeShortcutBinding[];
+declare function dividePolygons(operands: PolygonInput[], options?: PolygonBooleanOptions): PolygonPiece[];
+
 /**
- * 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.
+ * 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.
  */
-declare function matchArrangeShortcut(event: KeyboardEvent, bindings?: readonly ArrangeShortcutBinding[]): CanvasArrangeAction | null;
+
+/** 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;
+    };
+    /**
+     * `'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
+ * 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;
+    /**
+     * 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`). */
+    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[];
+
+/** 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 {
@@ -782,15 +1117,27 @@ 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). */
     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 +1162,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 +1195,179 @@ 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. */
+    /**
+     * 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
+     * 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 };
+/**
+ * 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 };