@pixerate/editor 0.39.0 → 0.41.0

package/dist/vector/index.d.ts

@@ -1,7 +1,8 @@
-import { C as CanvasGradientDef, A as AffineMatrix, B as BezierPathInput, a as BezierPath, S as SvgGradientDef, b as StrokeJoin, c as StrokeCap, d as BezierSegment, P as PlanarMap, e as PathfinderOperation, f as PathfinderShape } from '../pathfinder-D98S2lV5.js';
+import { C as CanvasGradientDef, A as AffineMatrix, B as BezierPathInput, a as BezierPath, S as SvgGradientDef, b as StrokeJoin, c as StrokeCap, d as BezierSegment, P as PlanarMap, e as PathfinderOperation, f as PathfinderShape, G as GradientStop } from '../pathfinder-D7hXenzu.js';
 import { P as Point } from '../types-BFkYA4eF.js';
 import { H as HistoryManager } from '../HistoryManager-DWSLd6Tf.js';
 import { C as CommandSpec } from '../registry-DhVUZioj.js';
+import { A as AnimationEasing } from '../easing-DTmX99QG.js';
 import '../types-DsiXGmjo.js';
 import '../schema-DYDGdYL9.js';
 
@@ -132,16 +133,56 @@ interface VectorNodeBase {
      * them into the geometry, so stroke widths and the rotated selection box stay exact.
      */
     transform?: VectorMatrix;
+    /**
+     * An in-between a blend group generated from its keys. Steps are rebuilt whenever a key or
+     * the blend options change, and are locked (clicks select the blend group).
+     */
+    blendStep?: boolean;
 }
 /** A shape made of one or more subpaths (holes and compound shapes included). */
 interface VectorPathNode extends VectorNodeBase, VectorStyle {
     type: 'path';
     subpaths: VectorSubpath[];
 }
+/**
+ * How a blend spaces its in-betweens: a number of `steps` between each pair of keys, a fixed
+ * `distance` between steps along the spine, or `smoothColor` (as many steps as the colours
+ * need for a smooth ramp; by distance when the colours match).
+ */
+type VectorBlendSpacing = 'steps' | 'distance' | 'smoothColor';
+declare const VECTOR_BLEND_SPACINGS: readonly VectorBlendSpacing[];
+/** Settings of a blend. */
+interface VectorBlendOptions {
+    /** Default `steps`. */
+    spacing?: VectorBlendSpacing;
+    /** Steps between each pair of keys with `steps` spacing (default 5). */
+    steps?: number;
+    /** Distance between steps along the spine with `distance` spacing (default 20). */
+    distance?: number;
+    /** Turn the steps with the spine's direction (default `false`: they keep the keys' orientation). */
+    orientToSpine?: boolean;
+    /** Move anchors in straight lines instead of the rotation-aware morph (default `false`). */
+    linear?: boolean;
+}
+/** A live blend: the group's keys plus how the in-betweens are made and laid out. */
+interface VectorBlend extends VectorBlendOptions {
+    /**
+     * A replaced spine in the group's space: the steps follow it instead of the straight lines
+     * between the keys' centres (the keys sit along it, spread evenly by arc length).
+     */
+    spine?: VectorSubpath | null;
+    /** The anchor of each key's first subpath its blend starts from, by key id (the Blend tool's clicks). */
+    starts?: Record<string, number>;
+}
 /** A group of nodes that select and transform together. */
 interface VectorGroupNode extends VectorNodeBase {
     type: 'group';
     children: VectorNode[];
+    /**
+     * Makes the group a live blend: its children that are not `blendStep`s are the keys, in
+     * stacking order, and the steps between them are regenerated whenever a key changes.
+     */
+    blend?: VectorBlend | null;
 }
 type VectorNode = VectorPathNode | VectorGroupNode;
 /** A vector drawing: an artboard and its nodes, bottom to top. */
@@ -174,9 +215,11 @@ interface VectorHandleRef extends VectorAnchorRef {
  * shape; `scissors` cuts a path at a point, `knife` cuts filled shapes along a freehand stroke,
  * `eraser` rubs out the area under one and `width` drags a stroke's width at a point.
  * `shapeBuilder` merges (Alt: deletes) the faces the selected shapes make, and `paintBucket`
- * fills the region the visible outlines enclose around a click with a new shape.
+ * fills the region the visible outlines enclose around a click with a new shape. `blend`
+ * blends the shape clicked first into the one clicked next (clicking an anchor of a closed path
+ * starts the blend there).
  */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket';
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -952,6 +995,21 @@ interface VectorStrokeSpot {
     left: Vec2;
     right: Vec2;
 }
+/**
+ * The width point being edited numerically (double-click with the width tool): `index` is the
+ * point's, or null for a new point at `t` (a double-click on a stroke away from its points).
+ * `left` / `right` are side widths in document units (how far the stroke reaches on each side),
+ * `point` is where it sits on the path, in document space.
+ */
+interface VectorWidthPointEdit {
+    nodeId: string;
+    subpath: number;
+    index: number | null;
+    t: number;
+    left: number;
+    right: number;
+    point: Vec2;
+}
 /** A key press as the controller needs it. */
 interface VectorKeyInput extends VectorModifiers {
     /** `KeyboardEvent.key`. */
@@ -1028,7 +1086,7 @@ type VectorInteraction = {
 } | {
     type: 'width';
     ref: VectorWidthPointRef;
-    mode: 'width' | 'move';
+    mode: 'width' | 'move' | 'copy';
     width: number;
 } | {
     type: 'pen';
@@ -1044,8 +1102,10 @@ interface VectorEditorState {
     selection: readonly string[];
     /** Selected anchors (direct tool). */
     selectedAnchors: readonly VectorAnchorRef[];
-    /** The selected width point (width tool); Delete removes it. */
-    selectedWidthPoint: VectorWidthPointRef | null;
+    /** The selected width points (width tool, all on one path); Delete removes them. */
+    selectedWidthPoints: readonly VectorWidthPointRef[];
+    /** The width point open for numeric editing (double-click with the width tool), if any. */
+    widthPointEdit: VectorWidthPointEdit | null;
     /** The path whose anchors are being edited, if any. */
     editingId: string | null;
     /** Axis-aligned bounds of the selected nodes in document units. */
@@ -1072,6 +1132,10 @@ interface VectorEditorState {
     pointer: Vec2 | null;
     /** Shape Builder and paint bucket highlight: faces, line pieces and the gesture's trail. */
     builder: VectorBuilderPreview | null;
+    /** The Blend tool's first click: the shape (and anchor of its first subpath) the next click blends from. */
+    blendStart: VectorBlendStart | null;
+    /** Options new blends get. */
+    blendDefaults: VectorBlendOptions;
     canUndo: boolean;
     canRedo: boolean;
     undoLabel: string;
@@ -1085,6 +1149,22 @@ type VectorActionResult = {
     ok: false;
     message: string;
 };
+/** The shape the Blend tool blends from (its first click). */
+interface VectorBlendStart {
+    nodeId: string;
+    /** The clicked anchor of its first subpath, or null for the shape as a whole. */
+    anchor: number | null;
+}
+/** Blend settings and options of `VectorEditorController.blend`. */
+interface VectorBlendInput extends VectorBlendOptions {
+    /** Nodes to blend (default: the selection), in stacking order unless `keepOrder`. */
+    ids?: readonly string[];
+    /** Blend in the order given instead of stacking order. */
+    keepOrder?: boolean;
+    /** Start anchor of each key's first subpath, by key id. */
+    starts?: Record<string, number>;
+    name?: string;
+}
 /**
  * What the Shape Builder or paint bucket highlights, in document units: the faces (filled paths
  * as SVG path data) under the pointer or touched by the drag, the line pieces an erase would
@@ -1211,7 +1291,7 @@ interface VectorWidthHandle {
  * vectorcraft `crates/tools/src/distort/width.rs` (MIT OR Apache-2.0, see
  * THIRD_PARTY_NOTICES.md), as are the `width` drag and hover below.
  */
-declare function getVectorWidthHandles(state: Pick<VectorEditorState, 'document' | 'selection' | 'tool' | 'hover' | 'interaction' | 'selectedWidthPoint'>): VectorWidthHandle[];
+declare function getVectorWidthHandles(state: Pick<VectorEditorState, 'document' | 'selection' | 'tool' | 'hover' | 'interaction' | 'selectedWidthPoints'>): VectorWidthHandle[];
 /** Looks up an anchor (positions in its node's own space). */
 declare function getAnchor(doc: VectorDocument, ref: VectorAnchorRef): VectorAnchor | undefined;
 /** An anchor with its position and handles in document space (its node's transforms applied). */
@@ -1282,7 +1362,8 @@ declare class VectorEditorController {
     private doc;
     private selection;
     private anchors;
-    private widthPoint;
+    private widthPoints;
+    private widthEdit;
     private editingId;
     private pen;
     private tool;
@@ -1307,6 +1388,9 @@ declare class VectorEditorController {
     /** Paint bucket map of the visible outlines. */
     private fillCache;
     private builderPreview;
+    private blendStart;
+    /** Options new blends get (the toolbars edit them along with the selected blend's). */
+    private blendDefaults;
     /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
     private builderHoverKey;
     private readonly createId;
@@ -1328,6 +1412,8 @@ declare class VectorEditorController {
     getDocument(): VectorDocument;
     getNode(id: string): VectorNode | undefined;
     private computeState;
+    /** `doc` with its blends' steps brought up to date (the same object when they already are). */
+    private refreshed;
     private notify;
     private boundsOf;
     private frameOf;
@@ -1434,8 +1520,49 @@ declare class VectorEditorController {
     } | null, options?: {
         ids?: readonly string[];
     }): VectorActionResult;
-    /** Removes one width point of a path's profile (the width tool's Delete). */
+    /** Removes one width point of a path's profile. */
     removeWidthPoint(ref: Pick<VectorWidthPointRef, 'nodeId' | 'index'>): VectorActionResult;
+    /** Removes width points (default: the selected ones — the width tool's Delete), as one undo step. */
+    removeWidthPoints(refs?: readonly Pick<VectorWidthPointRef, 'nodeId' | 'index'>[]): VectorActionResult;
+    /** Selects width points (width tool); points on other paths than the first are dropped. */
+    selectWidthPoints(refs: readonly VectorWidthPointRef[]): void;
+    /**
+     * Sets one width point numerically: `index` names an existing point of path `nodeId`, null
+     * (or left out) adds one at `values.t`. `left` / `right` are side widths in document units
+     * (how far the stroke reaches on each side of the path), `t` the position along each subpath
+     * (0–1). A point moved onto another one's `t` makes a step there. Selects the point and
+     * refreshes an open width-point editor; one undo step. Ported from ArtCraft vectorcraft's
+     * Width Point Edit dialog (`crates/tools/src/distort/width.rs`, MIT OR Apache-2.0).
+     */
+    setWidthPoint(target: {
+        nodeId: string;
+        index?: number | null;
+    }, values: {
+        t?: number;
+        left?: number;
+        right?: number;
+    }): VectorActionResult;
+    /**
+     * Opens the width-point editor (what a double-click with the width tool does) on a width
+     * point, or on a spot of a stroke (`t` without `index`: applying it adds a point there).
+     * Returns false when the path has no visible stroke.
+     */
+    openWidthPointEdit(target: {
+        nodeId: string;
+        subpath?: number;
+        index?: number | null;
+        t?: number;
+    }): boolean;
+    /** Closes the width-point editor without changing anything. */
+    closeWidthPointEdit(): void;
+    /** Applies `values` to the width point being edited (see `setWidthPoint`) and closes the editor. */
+    commitWidthPointEdit(values: {
+        t?: number;
+        left?: number;
+        right?: number;
+    }): VectorActionResult;
+    /** The editor's view of point `index` (or of the stroke at `t` when index is null) of `nodeId`. */
+    private widthEditFor;
     /**
      * Sets the live corner radius (and optionally the kind) of anchors: `refs`, else the selected
      * anchors (direct tool), else every anchor of the `ids` / selected paths. Radius 0 makes the
@@ -1575,6 +1702,44 @@ declare class VectorEditorController {
         ids?: readonly string[];
     }): string[];
     /** The Shape Builder map of the selected (or given) paths, cached per document and selection. */
+    /** Selected (or given) blend groups; a selected key or step counts as its blend. */
+    private blendTargets;
+    /**
+     * Blends two or more selected (or given) paths or groups: they become the keys of a live
+     * blend group (bottom to top, or in the order given with `keepOrder`) whose in-betweens are
+     * regenerated whenever a key or the options change. The keys must share a parent. Returns
+     * the blend group's id, or null.
+     */
+    blend(input?: VectorBlendInput): string | null;
+    /** Sets the options new blends get (spacing, steps, distance, orientation, morph). */
+    setBlendDefaults(patch: Partial<VectorBlendOptions>): void;
+    /**
+     * Adds a node as the last key of a blend (it must share the blend's parent); `start` is the
+     * anchor of its first subpath the blend starts from. One undo step.
+     */
+    addBlendKey(blendId: string, nodeId: string, options?: {
+        start?: number | null;
+    }): VectorActionResult;
+    /** Changes the spacing, steps, distance, orientation or morph of the selected (or given) blends. */
+    setBlendOptions(patch: Partial<VectorBlendOptions>, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Expand: turns the selected (or given) blends into plain groups of their keys and steps. Returns their ids. */
+    expandBlend(options?: {
+        ids?: readonly string[];
+    }): string[];
+    /** Release: replaces the selected (or given) blends with their keys (and a replaced spine as a path). */
+    releaseBlend(options?: {
+        ids?: readonly string[];
+    }): string[];
+    /**
+     * Replace Spine: the selected blend's steps follow the selected path instead of the straight
+     * lines between its keys. The path's first subpath becomes the spine (the path is removed)
+     * and the keys move onto it, spread evenly by arc length.
+     */
+    replaceBlendSpine(options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
     private shapeBuilderMap;
     /** The faces the Shape Builder offers for the selected (or given) paths (document units). */
     getShapeBuilderFaces(options?: {
@@ -1764,14 +1929,25 @@ declare class VectorEditorController {
     private widthView;
     /** The width point centre or side end under `screen` (width tool). */
     private hitWidthHandle;
+    private hitWidthHandleIn;
     /** The nearest stroked, unlocked visible path whose stroke is under document point `p` (width tool). */
     private strokeSpotAt;
     private downWidth;
+    /**
+     * A width-tool slide to `t` on the dragged point's subpath lands exactly on another width
+     * point (not `skip`) within the pick distance on screen: dropping a point onto another makes
+     * a discontinuous point (two points at one `t`, the width steps there).
+     */
+    private snapWidthT;
     /** The nearest outline point of any visible, unlocked path within the pick distance of document point `p`. */
     private nearestOutline;
     private sameHover;
     /** Primary button down on the canvas at `screen` (pixels relative to the canvas). */
     pointerDown(screen: Vec2, input?: VectorPointerInput): void;
+    /** The shape under the pointer for the Blend tool, and the anchor of its first subpath under it. */
+    private blendHit;
+    /** Blend tool: the first click picks the shape to blend from, the next one blends it into the shape clicked. */
+    private downBlend;
     private downSelect;
     private downDirect;
     private downPen;
@@ -1791,7 +1967,10 @@ declare class VectorEditorController {
     pointerLeave(): void;
     /** Abandons the drag in progress (Escape, lost capture). */
     cancelDrag(): void;
-    /** Double click: select tool enters path editing, direct tool toggles an anchor or adds one. */
+    /**
+     * Double click: select tool enters path editing, direct tool toggles an anchor or adds one,
+     * width tool opens the width-point editor (`widthPointEdit`).
+     */
     doubleClick(screen: Vec2): void;
     /**
      * Handles editor shortcuts. Returns true when the key was used (call `preventDefault`).
@@ -1993,6 +2172,29 @@ interface VectorOverlayRenderData {
         lines: string[];
         trail: string | null;
     } | null;
+    /**
+     * Blends (screen space): the spine of each selected blend (`d`, draw it dashed; `keys` are
+     * where its keys sit on it; `replaced` when it is a replaced spine) and, with the Blend tool,
+     * the outline of the shape it blends from (`start`, with the clicked anchor) and the anchors
+     * of the first subpath under the pointer (click one to start the blend there).
+     */
+    blend: {
+        spines: {
+            id: string;
+            d: string;
+            keys: Vec2[];
+            replaced: boolean;
+        }[];
+        start: {
+            d: string;
+            anchor: Vec2 | null;
+        } | null;
+        anchors: {
+            x: number;
+            y: number;
+            hovered: boolean;
+        }[];
+    };
     /** A short status, e.g. "W 120 × H 80" or "45°". */
     status: string | null;
 }
@@ -2007,6 +2209,28 @@ declare function getVectorSceneRenderData(state: Pick<VectorEditorState, 'docume
 }): VectorSceneRenderData;
 /** The editing overlay in screen pixels. Render it on top of the scene, untransformed. */
 declare function getVectorOverlayRenderData(state: VectorEditorState): VectorOverlayRenderData;
+/** What the Blend controls of a toolbar or style panel show. */
+interface VectorBlendControls {
+    /** Ids of the selected blends (a selected key counts as its blend). */
+    ids: string[];
+    /** The first selected blend's options, or the options new blends get. */
+    options: Required<VectorBlendOptions>;
+    /** Two or more shapes that share a parent are selected: Blend can run. */
+    canBlend: boolean;
+    /** One blend and one path are selected: Replace Spine can run. */
+    canReplaceSpine: boolean;
+    /** The first selected blend follows a replaced spine. */
+    hasSpine: boolean;
+}
+/** State of the Blend controls for the current selection. */
+declare function getVectorBlendControls(state: Pick<VectorEditorState, 'document' | 'selection' | 'blendDefaults'>): VectorBlendControls;
+/**
+ * Applies blend options from a toolbar: to the selected blends (one undo step) and to the
+ * options new blends get, so the controls keep showing what was picked.
+ */
+declare function applyVectorBlendOptions(controller: VectorEditorController, patch: Partial<VectorBlendOptions>): void;
+/** Labels of the blend spacing modes, for toolbars. */
+declare const VECTOR_BLEND_SPACING_LABELS: Readonly<Record<VectorBlendSpacing, string>>;
 /** Colours and sizes (screen pixels) the bundled canvases draw the overlay with. */
 declare const VECTOR_OVERLAY_THEME: {
     readonly accent: "#0ea5e9";
@@ -2183,6 +2407,18 @@ interface VectorNodeListing {
     /** SVG path data (paths only). */
     d?: string;
     children?: number;
+    /** A blend group's options (its steps are listed as children with `blendStep`). */
+    blend?: {
+        spacing: string;
+        steps: number;
+        distance: number;
+        orientToSpine: boolean;
+        linear: boolean;
+        spine: boolean;
+        keys: string[];
+    };
+    /** An in-between generated by a blend (locked; changes come from its keys). */
+    blendStep?: boolean;
 }
 /**
  * Palette and agent commands for a vector editor: list, select, add shapes and paths, style,
@@ -2404,7 +2640,12 @@ declare function hasStrokeExtras(style: VectorStyle): boolean;
  * uniform width, the variable-width outline (`variableStrokeOutline`) for a profiled one.
  */
 declare function vectorStrokeLineArea(parts: Pick<VectorStrokeParts, 'line' | 'drawWidth'>, style: VectorStyle, tolerance?: number): BezierPath;
-/** The weight of a head: the stroke width times its scale (at least 0.25). A head is 4 weights long and wide. */
+/**
+ * The weight of a head: the stroke's width just before it times the head's scale (at least
+ * 0.25). A head is 4 weights long and wide. On a variable-width stroke the width there is the
+ * profile's (the mean of its two sides at that end), floored at the stroke width, so a stroke
+ * that tapers to nothing still gets a full-size head and one that swells gets a bigger one.
+ */
 declare function arrowheadWeight(style: VectorStyle, end: 'start' | 'end'): number;
 /** Distance from the tip where the stroke ends, for a stroke whose cap reaches `cap` past its end. */
 declare function arrowheadInset(kind: VectorArrowhead, hw: number, cap: number): number;
@@ -2638,4 +2879,240 @@ declare function planShapeBuilder(m: VectorShapeBuilderMap, touched: VectorBuild
  */
 declare function vectorFillMap(doc: VectorDocument, gap?: number): PlanarMap | null;
 
-export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type NearestSegment, type RecognizeInkOptions, SvgGradientDef, VECTOR_ARROWHEADS, VECTOR_ARROWHEAD_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_EDIT_TOGGLES, VECTOR_FILL_GAP, VECTOR_INK_MAX_CORNERS, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATHFINDER_OPERATIONS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, type Vec2, type VectorActionResult, type VectorAlign, type VectorAnchor, type VectorAnchorRef, type VectorAnchorType, type VectorArrange, type VectorArrowAlign, type VectorArrowhead, type VectorArrowheadShape, type VectorAverageAxis, type VectorBooleanOperation, type VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCorner, type VectorCornerInfo, type VectorCornerKind, type VectorCornerWidget, type VectorDefaults, type VectorDistribute, type VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, type VectorFillRule, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorModifiers, type VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathNode, type VectorPathfinderAction, type VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, type VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeParts, type VectorStrokeSpot, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorTaperOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, type VectorWaveOptions, type VectorWidthHandle, type VectorWidthPoint, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorCornersAttribute, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, createVectorCommands, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorCornerWidgets, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasPaint, hasStrokeExtras, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, insertWidthPoint, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mirrorWidthProfile, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, parseSvgTransform, parseVectorSvg, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, recognizeInkShape, rectSubpath, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, reverseSubpath, reverseWidthProfile, rotateMatrix, roundSubpaths, samplePolyline, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, unionBounds, variableStrokeOutline, variableStrokeRings, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDocumentToSvg, vectorFillMap, vectorInkShapeName, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute };
+/**
+ * Morphing between vector paths: bring two shapes to matching anchors, then compute in-betweens.
+ *
+ * - **Contours** pair up in order. A contour without a partner grows out of (or shrinks into) a
+ *   point at the same place relative to the other shape's box. Straight segments become cubics
+ *   with handles at a third of the way, so a line bends smoothly into a curve.
+ * - **Anchors** are inserted by arc length with de Casteljau splits, so both contours of a pair
+ *   keep their exact outline and get the same number of segments, spread over the segments in
+ *   proportion to their length.
+ * - **Correspondence**: the closed side of each pair is turned to the cyclic start that costs
+ *   least — the position differences left after the best-fit rotation (both shapes centred and
+ *   scaled to unit size), a little for the turn, plus the χ² distance of log-polar
+ *   shape-context histograms (Belongie, Malik & Puzicha, PAMI 2002; angles taken from the
+ *   contour's direction) — and the winding is chosen once for all contours (the first closed
+ *   pair turns the same way), so a nonzero fill keeps its holes.
+ * - **In-betweens** follow the shapes' best-fit rotation and scale (Procrustes), with the
+ *   leftover difference blended in linearly, so a turning shape turns instead of collapsing.
+ * - **Paint**: colours mix in OKLab, gradients of one kind resample their stops to a common
+ *   set, a missing paint fades from transparent; stroke width, opacity, dashes, arrowhead
+ *   scales and width profiles interpolate, and the rest switches halfway.
+ * - **Transforms**: both shapes are blended in their parent's space; the in-between's rigid
+ *   `transform` interpolates as a rotation (the short way round) plus a translation.
+ *
+ * Live corners are cut into the geometry first, so rounded corners morph as curves.
+ */
+
+interface VectorMorphOptions {
+    /**
+     * Move anchors in straight lines instead of following the shapes' best-fit rotation and
+     * scale. Default `false`.
+     */
+    linear?: boolean;
+    /** 0–1: how much the rotation-aware path outweighs the straight one (default 1). */
+    rigidity?: number;
+    /** Fewest segments each contour pair gets (default 16). */
+    minSegments?: number;
+    /** At most this far apart (document units) along the longer contour, when set. */
+    spacing?: number | null;
+    /** Most segments a contour pair gets (default 400). */
+    maxSegments?: number;
+    /** Search the start anchor of closed contours (default `true`); off keeps the stored starts. */
+    matchStart?: boolean;
+    /** Compare shape-context histograms when choosing starts (default `true`). */
+    shapeContext?: boolean;
+    /**
+     * The anchor each shape's first subpath starts from (the Blend tool's clicks). A closed
+     * subpath turns round to it; an open one clicked at its last anchor runs backwards.
+     */
+    starts?: readonly [number | null | undefined, number | null | undefined];
+    /** Id of the in-between (default: the first shape's id). */
+    id?: string;
+}
+/** Two shapes prepared once; `at(t)` interpolates (0 = `a`, 1 = `b`). */
+interface VectorMorph {
+    at(t: number): VectorNode;
+}
+/** A subpath as cubics. A closed contour's last point repeats its first. */
+interface VectorMorphContour {
+    closed: boolean;
+    pts: Point[];
+}
+/** A subpath mapped by `m` as cubics (lines with handles at thirds), or null when empty. */
+declare function subpathToMorphContour(sp: VectorSubpath, m?: AffineMatrix): VectorMorphContour | null;
+/** A contour back to a subpath (`m` maps it out of the morph's space). Straight cubics become lines. */
+declare function morphContourToSubpath(c: VectorMorphContour, m?: AffineMatrix, closed?: boolean): VectorSubpath;
+/**
+ * Exactly the same outline with `segments` cubics (at least as many as it has), the new
+ * anchors spread over its segments in proportion to their arc length (largest remainder)
+ * and each segment split into pieces of equal arc length. Also returns where each original
+ * anchor went.
+ */
+declare function refineMorphContour(c: VectorMorphContour, segments: number): {
+    contour: VectorMorphContour;
+    anchors: number[];
+};
+/** The same contour run backwards (a closed one keeps its start anchor). */
+declare function reverseMorphContour(c: VectorMorphContour): VectorMorphContour;
+/** A closed contour starting at anchor `s` (deckcraft's `turn`). */
+declare function turnMorphContour(c: VectorMorphContour, s: number): VectorMorphContour;
+/** Two shapes' contours with matching structure: same count, and per pair the same segments. */
+interface VectorMorphCorrespondence {
+    a: VectorMorphContour[];
+    b: VectorMorphContour[];
+    /** Whether `b` runs backwards relative to its stored direction. */
+    reversed: boolean;
+}
+/**
+ * Gives two lists of contours the same structure with matching anchors (see the module notes).
+ * Contours pair in order; one without a partner meets a point.
+ */
+declare function correspondMorphContours(a: readonly VectorMorphContour[], b: readonly VectorMorphContour[], options?: VectorMorphOptions): VectorMorphCorrespondence;
+/**
+ * How many pairs of straight anchor paths (from `a`'s anchor i to `b`'s anchor i) cross: a
+ * sanity measure of a correspondence — good matches don't make anchors pass through each other.
+ */
+declare function morphPathsCross(a: readonly VectorMorphContour[], b: readonly VectorMorphContour[]): number;
+/** The similarity (rotation θ, scale s, centroids) that best maps `a`'s anchors onto `b`'s. */
+interface Similarity {
+    ca: Point;
+    cb: Point;
+    theta: number;
+    s: number;
+}
+/**
+ * Corresponded contours at `u`: each point carried by the similarity interpolated to `u`
+ * (rotation θu, scale sᵘ, centroid moving straight), plus `u` of what the full similarity
+ * leaves over, blended with the straight path by `rigidity`.
+ */
+declare function interpolateMorphContours(a: readonly VectorMorphContour[], b: readonly VectorMorphContour[], u: number, options?: Pick<VectorMorphOptions, 'linear' | 'rigidity'> & {
+    similarity?: Similarity;
+}): VectorMorphContour[];
+/**
+ * Interpolates two rigid matrices as a rotation (the shorter way round) plus a translation.
+ * Any scale or skew is interpolated linearly in the rotated frame.
+ */
+declare function interpolateRigidMatrix(a: AffineMatrix, b: AffineMatrix, t: number): AffineMatrix;
+/** Two colours mixed in OKLab (premultiplied alpha); unreadable colours switch halfway. */
+declare function interpolateVectorColor(a: string, b: string, t: number): string;
+/** A gradient's stops resampled at `offsets`, each painting what the gradient paints there. */
+declare function resampleGradientStops(g: CanvasGradientDef, offsets: readonly number[]): GradientStop[];
+/**
+ * Interpolates paints: colours in OKLab, gradients of one kind with their stops resampled to a
+ * common set, a colour and a gradient through a gradient of that colour, and a missing paint
+ * fading from transparent. Gradients of different kinds switch halfway.
+ */
+declare function interpolateVectorPaint(a: VectorPaint | undefined, b: VectorPaint | undefined, t: number): VectorPaint | undefined;
+/** Width profiles at every position either has a point (no profile is uniform). */
+declare function interpolateWidthProfiles(a: readonly VectorWidthPoint[] | null | undefined, b: readonly VectorWidthPoint[] | null | undefined, t: number): VectorWidthPoint[] | null;
+/**
+ * Interpolated style of two paths: paints, stroke width, dashes, arrowhead scales and width
+ * profiles mix; caps, joins, the fill rule, alignment and arrowheads switch halfway.
+ */
+declare function interpolateVectorStyle(a: VectorStyle, b: VectorStyle, t: number): VectorStyle;
+/**
+ * Prepares two shapes for interpolation. Two paths morph directly; with a group on either side
+ * the paths inside pair up in stacking order and those without a partner grow out of a point.
+ * Shapes are blended in their parent's space.
+ */
+declare function createVectorMorph(a: VectorNode, b: VectorNode, options?: VectorMorphOptions): VectorMorph;
+/**
+ * The in-between of two shapes at `t` (0 = `a`, 1 = `b`). Prepare once with
+ * `createVectorMorph` when interpolating the same pair at many `t`.
+ */
+declare function interpolateVectorPaths(a: VectorNode, b: VectorNode, t: number, options?: VectorMorphOptions): VectorNode;
+/** A keyframe of a path track: a shape at a time (ms), with the easing of the segment leaving it. */
+interface VectorPathKeyframe {
+    time: number;
+    value: VectorNode;
+    easing?: AnimationEasing;
+}
+/**
+ * A path track's shape at `time`: before the first keyframe its shape, after the last the
+ * last; in between the two keyframes morph (prepared once per pair and cached) at the eased
+ * fraction. Easings that overshoot are clamped to the keys. `null` without keyframes.
+ */
+declare function evaluateVectorPathKeyframes(keyframes: readonly VectorPathKeyframe[], time: number, options?: VectorMorphOptions): VectorNode | null;
+
+/**
+ * Live blend groups: a group whose `blend` is set keeps its key shapes as children and
+ * regenerates the in-betweens (`blendStep` children, locked) whenever a key or the options
+ * change. Steps follow the straight lines between the keys' centres, or a replaced spine.
+ *
+ * - **Spacing** (`vectorBlendStepCount`): a number of steps per pair of keys, a fixed distance
+ *   along the spine, or smooth colour — one step per two levels of the largest colour channel
+ *   difference, by distance when the colours match.
+ * - **Spine**: with a replaced spine the keys sit along it, spread evenly by arc length; each
+ *   step is moved by how far the spine bends away from the chord between its keys, so a step
+ *   lands on the spine and the keys stay where they are. Orient to spine also turns the steps
+ *   by how much the spine's direction differs from the keys' (keys keep their orientation);
+ *   without a replaced spine the steps run straight and keep their orientation.
+ */
+
+declare const DEFAULT_VECTOR_BLEND_STEPS = 5;
+declare const DEFAULT_VECTOR_BLEND_DISTANCE = 20;
+/** Most steps between two keys. */
+declare const VECTOR_BLEND_MAX_STEPS = 1000;
+/** Most steps smooth colour makes between two keys. */
+declare const VECTOR_BLEND_MAX_SMOOTH_STEPS = 256;
+/** Whether a node is a live blend group. */
+declare function isVectorBlendGroup(node: VectorNode | null | undefined): node is VectorGroupNode & {
+    blend: VectorBlend;
+};
+/** The keys of a blend group (its children that are not generated steps), in stacking order. */
+declare function vectorBlendKeys(group: VectorGroupNode): VectorNode[];
+/** The full options of a blend, defaults filled in. */
+declare function resolveVectorBlendOptions(options: VectorBlendOptions | null | undefined): Required<VectorBlendOptions>;
+/** Largest channel difference (0–1) between the colours of two shapes' fills and strokes. */
+declare function vectorBlendColorDistance(a: VectorNode, b: VectorNode): number;
+/** Number of in-betweens between two keys `length` apart along the spine. */
+declare function vectorBlendStepCount(a: VectorNode, b: VectorNode, options: VectorBlendOptions | null | undefined, length: number): number;
+/** A subpath flattened to a polyline with cumulative arc lengths and tangent angles. */
+interface VectorBlendRail {
+    pts: Point[];
+    cum: number[];
+    angles: number[];
+    total: number;
+    closed: boolean;
+}
+/** Flattens a spine subpath (32 samples per curve). Null with fewer than two distinct points. */
+declare function vectorBlendRail(sp: VectorSubpath): VectorBlendRail | null;
+/** Point and direction (radians) at arc length `s` (clamped; a closed rail wraps). */
+declare function vectorBlendRailAt(rail: VectorBlendRail, s: number): {
+    point: Point;
+    angle: number;
+};
+/**
+ * The spine of a blend in the group's space and where along it each key sits: the replaced
+ * spine (keys spread evenly by arc length) or the straight lines between the keys' centres.
+ */
+declare function vectorBlendSpine(group: VectorGroupNode): {
+    spine: VectorSubpath;
+    rail: VectorBlendRail;
+    stops: number[];
+    replaced: boolean;
+} | null;
+/** Where key `i` of a blend with spine `spine` should sit: its stop on the spine. */
+declare function vectorBlendKeyTargets(group: VectorGroupNode): Point[];
+/**
+ * A blend group's children with fresh steps: each key followed by the in-betweens to the next,
+ * bottom to top. Groups with fewer than two keys keep just their keys.
+ */
+declare function generateVectorBlendChildren(group: VectorGroupNode): VectorNode[];
+/**
+ * Nodes with every blend group's steps brought up to date (nested blends first). Returns the
+ * same array when nothing changed; steps are cached per set of keys, so calling this after
+ * every edit is cheap.
+ */
+declare function refreshVectorBlends(nodes: readonly VectorNode[]): VectorNode[];
+/** Expand: the blend as a plain group of its keys and steps (steps get fresh ids). */
+declare function expandVectorBlend(group: VectorGroupNode, newId: () => string): VectorGroupNode;
+/**
+ * Release: the blend's keys in the group's parent space (the group's transform and opacity
+ * applied), followed by the replaced spine as an unpainted path when there is one.
+ */
+declare function releaseVectorBlend(group: VectorGroupNode, newId: () => string): VectorNode[];
+
+export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type NearestSegment, type RecognizeInkOptions, SvgGradientDef, VECTOR_ARROWHEADS, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACINGS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_EDIT_TOGGLES, VECTOR_FILL_GAP, VECTOR_INK_MAX_CORNERS, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATHFINDER_OPERATIONS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, type Vec2, type VectorActionResult, type VectorAlign, type VectorAnchor, type VectorAnchorRef, type VectorAnchorType, type VectorArrange, type VectorArrowAlign, type VectorArrowhead, type VectorArrowheadShape, type VectorAverageAxis, type VectorBlend, type VectorBlendControls, type VectorBlendInput, type VectorBlendOptions, type VectorBlendRail, type VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperation, type VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCorner, type VectorCornerInfo, type VectorCornerKind, type VectorCornerWidget, type VectorDefaults, type VectorDistribute, type VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, type VectorFillRule, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, type VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, type VectorPathNode, type VectorPathfinderAction, type VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, type VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeParts, type VectorStrokeSpot, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorTaperOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, type VectorWaveOptions, type VectorWidthHandle, type VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasPaint, hasStrokeExtras, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorBlendGroup, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, parseSvgTransform, parseVectorSvg, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundSubpaths, samplePolyline, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, turnMorphContour, unionBounds, variableStrokeOutline, variableStrokeRings, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDocumentToSvg, vectorFillMap, vectorInkShapeName, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute };