@pixerate/editor 0.41.0 → 0.42.0

package/dist/vector/index.d.ts

@@ -138,6 +138,17 @@ interface VectorNodeBase {
      * the blend options change, and are locked (clicks select the blend group).
      */
     blendStep?: boolean;
+    /**
+     * Live path effects, applied top to bottom: each acts on every path above it (the node's own
+     * outline, or a group's children, then the result of the effects before it), and effects after a
+     * repeater act on its copies. The stored anchors and children never change.
+     */
+    effects?: VectorEffect[] | null;
+    /**
+     * As an operand of a live boolean group: how it combines with the result of the operands below
+     * it. Absent: the group's `liveBoolean` operation.
+     */
+    booleanOperation?: VectorBooleanOperation | null;
 }
 /** A shape made of one or more subpaths (holes and compound shapes included). */
 interface VectorPathNode extends VectorNodeBase, VectorStyle {
@@ -183,6 +194,12 @@ interface VectorGroupNode extends VectorNodeBase {
      * stacking order, and the steps between them are regenerated whenever a key changes.
      */
     blend?: VectorBlend | null;
+    /**
+     * Makes the group a live boolean: its children stay editable operands, folded bottom to top
+     * (each by its own `booleanOperation` or this one), and the group draws as the result in the
+     * bottom operand's style.
+     */
+    liveBoolean?: VectorBooleanOperation | null;
 }
 type VectorNode = VectorPathNode | VectorGroupNode;
 /** A vector drawing: an artboard and its nodes, bottom to top. */
@@ -265,6 +282,109 @@ declare const VECTOR_PATHFINDER_OPERATIONS: readonly VectorPathfinderOperation[]
 type VectorArrange = 'front' | 'forward' | 'backward' | 'back';
 /** Average: line anchors up on a horizontal line (same y), a vertical one (same x), or both. */
 type VectorAverageAxis = 'horizontal' | 'vertical' | 'both';
+/**
+ * Live path effects (After Effects' path operators): `trim` (Trim Paths), `roundCorners`,
+ * `puckerBloat`, `twist`, `zigzag`, `wiggle` (Wiggle Paths), `offset` (Offset Paths), `merge`
+ * (Merge Paths) and `repeater`.
+ */
+type VectorEffectType = 'trim' | 'roundCorners' | 'puckerBloat' | 'twist' | 'zigzag' | 'wiggle' | 'offset' | 'merge' | 'repeater';
+declare const VECTOR_EFFECT_TYPES: readonly VectorEffectType[];
+/** Merge Paths modes: a compound path (no boolean), union, the first minus the others, intersection or exclusion. */
+type VectorMergeMode = 'merge' | 'add' | 'subtract' | 'intersect' | 'exclude';
+declare const VECTOR_MERGE_MODES: readonly VectorMergeMode[];
+/** Parameters of each effect type. Lengths are in the node's own units, angles in degrees, percentages 0–100. */
+interface VectorEffectParamsMap {
+    trim: {
+        /** Start and end of the kept part, percent of the length (swapped when start > end). */
+        start: number;
+        end: number;
+        /** Shifts both, in degrees (360° = once round). */
+        offset: number;
+        /**
+         * `simultaneous`: every path trimmed by the same fractions of its own length;
+         * `individual`: the paths laid end to end in stacking order and trimmed as one length.
+         */
+        mode: 'simultaneous' | 'individual';
+    };
+    roundCorners: {
+        radius: number;
+    };
+    /** Percent, −100 (pucker: spiky) to 100 (bloat: bulging). */
+    puckerBloat: {
+        amount: number;
+    };
+    twist: {
+        /** Turn at the farthest point from the centre (none at the centre). */
+        angle: number;
+        /** The centre as an offset from the middle of the paths' bounds. */
+        center: Vec2;
+    };
+    zigzag: {
+        /** How far the points move to either side. */
+        size: number;
+        /** Ridges per segment. */
+        ridges: number;
+        /** Rounded waves instead of sharp zig zags. */
+        smooth: boolean;
+    };
+    wiggle: {
+        /** Largest displacement. */
+        size: number;
+        /** Points added per segment. */
+        detail: number;
+        smooth: boolean;
+        /** Wiggles per second. */
+        speed: number;
+        /** Percent: how much neighbouring points move together. */
+        correlation: number;
+        /** Degrees (360° = one wiggle). */
+        phase: number;
+        /** The same seed (and time) always gives the same wiggle. */
+        seed: number;
+        /** Seconds: where along the wiggle's motion it is drawn. */
+        time: number;
+    };
+    offset: {
+        /** Grows (positive) or shrinks (negative) the shapes. */
+        amount: number;
+        join: VectorLineJoin;
+        miterLimit: number;
+        /** Copies, copy i offset by `amount · (i + 1 + copyOffset)`. */
+        copies: number;
+        copyOffset: number;
+    };
+    merge: {
+        mode: VectorMergeMode;
+    };
+    repeater: {
+        /** Copies, the original included; a fraction fades the last copy. */
+        copies: number;
+        /** Shifts the copies along: copy i is transformed `i + offset` times. */
+        offset: number;
+        /** Each step: move, about `anchor` turn by `rotation` and scale by `scale` percent. */
+        position: Vec2;
+        /** Offset from the middle of the paths' bounds. */
+        anchor: Vec2;
+        rotation: number;
+        scale: Vec2;
+        /** Percent opacity of the first and last copies (in between interpolated). */
+        startOpacity: number;
+        endOpacity: number;
+        /** `below`: each copy draws under the one before it; `above`: over it. */
+        composite: 'below' | 'above';
+    };
+}
+/** One entry of an effect stack. */
+type VectorEffect = {
+    [K in VectorEffectType]: {
+        /** Unique within the node. */
+        id: string;
+        type: K;
+        /** Disabled effects are skipped. Default true. */
+        enabled?: boolean;
+        params: VectorEffectParamsMap[K];
+    };
+}[VectorEffectType];
 /** Identifies one segment of a path node: from anchor `segment` to the next. */
 interface VectorSegmentRef {
     nodeId: string;
@@ -295,7 +415,7 @@ declare function subpathSegment(sp: VectorSubpath, i: number): Point[];
 declare function subpathsToBezier(subpaths: readonly VectorSubpath[], options?: {
     corners?: boolean;
 }): BezierPath;
-/** The node's outline as Bézier commands. Groups have none. */
+/** The node's outline as Bézier commands, as drawn (path effects applied). Groups have none. */
 declare function vectorNodeToBezier(node: VectorNode): BezierPath;
 /** SVG path data (`d`) of a path node or subpaths. */
 declare function vectorPathData(input: VectorPathNode | readonly VectorSubpath[], precision?: number): string;
@@ -321,8 +441,13 @@ declare function locateVectorNode(nodes: VectorNode[], id: string): {
 declare function collectPathNodes(node: VectorNode): VectorPathNode[];
 /** The node's local → parent matrix (identity when it has no `transform`). */
 declare function nodeMatrix(node: VectorNode): AffineMatrix;
-/** A path node's outline in the space `parent` maps to (default: its parent's space). */
-declare function vectorPathWorldBezier(node: VectorPathNode, parent?: AffineMatrix): BezierPath;
+/**
+ * A path node's outline in the space `parent` maps to (default: its parent's space), as drawn:
+ * live corners cut and path effects applied (`{ effects: false }`: the stored path only).
+ */
+declare function vectorPathWorldBezier(node: VectorPathNode, parent?: AffineMatrix, options?: {
+    effects?: boolean;
+}): BezierPath;
 /**
  * Geometric bounds of a node (stroke width not included) in the space `parent` maps to —
  * by default the node's parent space, which for top-level nodes is the document. Null when
@@ -335,19 +460,27 @@ declare function unionBounds(list: readonly (VectorBounds | null | undefined)[])
 declare function boundsIntersect(a: VectorBounds, b: VectorBounds): boolean;
 /** A box from two corners in any order. */
 declare function boundsFromPoints(a: Vec2, b: Vec2): VectorBounds;
+/** Options of `hitTestVectorNode`. */
+interface VectorHitTestOptions {
+    /**
+     * Live groups (live booleans or groups with effects) hit by their children as stored rather
+     * than by what they draw: the groups being edited.
+     */
+    entered?: ReadonlySet<string>;
+}
 /**
- * Whether `p` hits a node: inside its fill (when it has one), on its stroke as drawn (its
- * alignment and arrowheads respected) or within `tolerance` of either. A group is hit when
- * any visible child is.
+ * Whether `p` hits a node as drawn (path effects and live booleans applied): inside its fill
+ * (when it has one), on its stroke (its alignment and arrowheads respected) or within
+ * `tolerance` of either. A group is hit when any visible child is.
  */
-declare function hitTestVectorNode(node: VectorNode, p: Vec2, tolerance?: number, parent?: AffineMatrix): boolean;
+declare function hitTestVectorNode(node: VectorNode, p: Vec2, tolerance?: number, parent?: AffineMatrix, options?: VectorHitTestOptions): boolean;
 /**
  * The area a path node's stroke paints (alignment, caps, joins, dashes and arrowheads
  * included), as a filled path in the space `parent` maps to. Empty without a stroke.
  */
 declare function vectorStrokeOutline(node: VectorPathNode, parent?: AffineMatrix): BezierPath;
 /** The topmost node hit by `p` (skipping hidden and locked ones), or null. */
-declare function hitTestVectorNodes(nodes: readonly VectorNode[], p: Vec2, tolerance?: number): VectorNode | null;
+declare function hitTestVectorNodes(nodes: readonly VectorNode[], p: Vec2, tolerance?: number, options?: VectorHitTestOptions): VectorNode | null;
 interface NearestSegment {
     subpath: number;
     segment: number;
@@ -1424,10 +1557,15 @@ declare class VectorEditorController {
     private cursorFor;
     private snapshot;
     private restore;
-    /** Records the change from `before` to the current state as one undo step. */
+    /**
+     * Records the change from `before` to the current state as one undo step. Consecutive
+     * changes with the same `merge` key (a slider drag) fold into one step.
+     */
     private commit;
-    /** Runs `fn` (which updates fields) and records it as one undo step. */
+    /** Runs `fn` (which updates fields) and records it as one undo step (merged by `merge` key). */
     private change;
+    /** Ends a merged edit (a slider released): the next change starts a new undo step. */
+    endMergedEdit(): void;
     private setDoc;
     private replaceNode;
     private freshIds;
@@ -1588,6 +1726,43 @@ declare class VectorEditorController {
     outlineStroke(options?: {
         ids?: readonly string[];
     }): string[];
+    /** Selected (or given) nodes that can carry effects: the roots of the selection. */
+    private effectTargets;
+    /**
+     * Adds an effect of `type` to the selected (or given) nodes, at the bottom of each stack (or
+     * at `index`), with default parameters merged with `params`. A repeater's copies start one
+     * shape width apart. One undo step; returns the new effect ids (one per node, in order).
+     */
+    addEffect(type: VectorEffectType, options?: {
+        ids?: readonly string[];
+        params?: Record<string, unknown>;
+        index?: number;
+    }): string[];
+    private editEffects;
+    /**
+     * Turns an effect on or off and changes its parameters (unknown or invalid values are
+     * ignored). With `merge` (true, or a key of your own), consecutive updates of the same effect
+     * fold into one undo step, as a slider drag should; call `endMergedEdit` when it ends.
+     */
+    updateEffect(nodeId: string, effectId: string, patch: {
+        enabled?: boolean;
+        params?: Record<string, unknown>;
+    }, options?: {
+        merge?: boolean | string;
+    }): VectorActionResult;
+    /** Removes an effect from a node's stack. */
+    removeEffect(nodeId: string, effectId: string): VectorActionResult;
+    /** Moves an effect to position `index` of its stack (0 is applied first). */
+    moveEffect(nodeId: string, effectId: string, index: number): VectorActionResult;
+    /**
+     * Expand Appearance: bakes the path effects and live booleans of the selected (or given)
+     * nodes, and of everything inside them, into plain paths. A node keeps its id (a group when
+     * it draws as several shapes); the shapes it made get new ids. Returns the ids of the expanded
+     * nodes (empty when none was live).
+     */
+    expandAppearance(options?: {
+        ids?: readonly string[];
+    }): string[];
     rename(id: string, name: string): VectorActionResult;
     setVisible(id: string, visible: boolean): VectorActionResult;
     setLocked(id: string, locked: boolean): VectorActionResult;
@@ -1675,11 +1850,20 @@ declare class VectorEditorController {
     /**
      * Combines the selected paths (two or more) into one with a boolean operation. `subtract`
      * removes the upper shapes from the lowest one. The result takes the lowest shape's style
-     * and place.
+     * and place. Shapes take part as drawn (path effects and live booleans applied).
+     *
+     * With `live`, the operands stay editable instead: a lone live boolean group gets the
+     * operation (its operands follow it again), operands of live boolean groups get it as their
+     * own, and anything else (two or more nodes with one parent) is wrapped in a new live boolean
+     * group. Returns the result's (or the live group's) id, or null.
      */
     booleanOp(op: VectorBooleanOperation, options?: {
         ids?: readonly string[];
+        live?: boolean;
     }): string | null;
+    /** Whether stored node `rootId` holds `id` as drawn (`id` may be an expanded path inside it). */
+    private holds;
+    private liveBooleanOp;
     /** Joins the selected paths into one compound path (subpaths kept, lowest style). */
     combine(options?: {
         ids?: readonly string[];
@@ -1922,6 +2106,8 @@ declare class VectorEditorController {
     private hitCornerWidget;
     private hitAnchor;
     /** Deepest unlocked visible path under `p`. */
+    /** Live groups being edited (selected, or holding the selection or the edited path): their children are hit as stored. */
+    private enteredGroups;
     private hitPath;
     /** Endpoints of open subpaths of unlocked visible paths (pen tool resumes from them). */
     private openEndpoints;
@@ -1986,6 +2172,153 @@ declare function scaleFor(handle: VectorTransformHandle, b: VectorBounds, p: Vec
     origin: Vec2;
 };
 
+/**
+ * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
+ * stored anchors and children stay editable.
+ *
+ * `expandVectorAppearance` is the one place the effected geometry is made (cached per node
+ * object, so an edit recomputes only the nodes it replaced). Rendering, hit-testing, bounds,
+ * snapping, booleans, the Pathfinder, the Shape Builder and SVG export all read it, the way they
+ * read live corners through `subpathsToBezier`; Expand Appearance stores it.
+ *
+ * Stacking follows After Effects' shape layers (effectcraft `crates/render/src/shapes.rs`): an
+ * effect acts on every path above it — the node's own outline, or for a group every path of its
+ * children (nested groups included, as drawn by their own effects) — in the order of the stack,
+ * and effects placed after a repeater act on its copies. The result paints with the style of the
+ * path each shape came from; Merge Paths and live booleans paint with the bottom one's.
+ *
+ * Live booleans fold their operands bottom to top, each combined with the result below it by its
+ * own operation or the group's, and every prefix of the fold is cached under a rolling hash of the
+ * operands it covers, so editing one operand recombines only the operands from it up; the cache
+ * drops its least recently used half when full. Live groups are hit by their result except while
+ * they are being edited (`vectorEnteredGroups`).
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): the stacking rule of effectcraft `crates/render/src/shapes.rs`
+ * (`collect()`); figcraft `crates/render/src/boolean.rs` (`fold_cached`, `PathCache`) and
+ * `crates/engine/src/booleans.rs` (`operand_op`, `result_outline`); and the live-object model of
+ * vectorcraft `crates/doc/src/live.rs` (`expand_live`, `expanded_group`, `subtree_has_live`).
+ */
+
+/** One shape of a node's appearance: a path in the node's own space, painted in `source`'s style. */
+interface VectorAppearanceShape {
+    /** The path whose style paints it. */
+    source: VectorPathNode;
+    path: BezierPath;
+    /** Opacity factor relative to the node (its own opacity not included). */
+    opacity: number;
+    /** Draw-order key (compared element by element). */
+    order: number[];
+}
+/** Default parameters of each effect type. */
+declare const VECTOR_EFFECT_DEFAULTS: {
+    readonly [K in VectorEffectType]: VectorEffectParamsMap[K];
+};
+declare const VECTOR_EFFECT_LABELS: Record<VectorEffectType, string>;
+/** How a panel edits one effect parameter. */
+type VectorEffectParamSpec = {
+    key: string;
+    label: string;
+    kind: 'number';
+    min?: number;
+    max?: number;
+    step: number;
+    slider?: boolean;
+} | {
+    key: string;
+    label: string;
+    kind: 'vec2';
+    step: number;
+} | {
+    key: string;
+    label: string;
+    kind: 'boolean';
+} | {
+    key: string;
+    label: string;
+    kind: 'select';
+    options: {
+        value: string;
+        label: string;
+    }[];
+};
+/** The editable parameters of each effect type, in panel order. */
+declare const VECTOR_EFFECT_PARAM_SPECS: Record<VectorEffectType, VectorEffectParamSpec[]>;
+/**
+ * Effect parameters with defaults filled in and invalid values dropped (unknown keys go too).
+ * Returns null for an unknown type.
+ */
+declare function normalizeVectorEffectParams<K extends VectorEffectType>(type: K, params: Record<string, unknown> | null | undefined, base?: VectorEffectParamsMap[K]): VectorEffectParamsMap[K] | null;
+/** A new effect of `type` (defaults merged with `params`), or null for an unknown type. */
+declare function createVectorEffect<K extends VectorEffectType>(type: K, id: string, params?: Partial<VectorEffectParamsMap[K]> | Record<string, unknown>): Extract<VectorEffect, {
+    type: K;
+}> | null;
+/** The node's effects that take part (enabled, of a known type). */
+declare function activeVectorEffects(node: VectorNode): VectorEffect[];
+/** Whether the node itself draws differently from its stored geometry (effects or a live boolean). */
+declare function hasOwnVectorAppearance(node: VectorNode): boolean;
+/** Whether the node or anything inside it has a live appearance. */
+declare function hasVectorAppearance(node: VectorNode): boolean;
+/** A live boolean group (its children are operands). */
+declare function isVectorLiveBoolean(node: VectorNode | null | undefined): node is VectorGroupNode & {
+    liveBoolean: VectorBooleanOperation;
+};
+/** How operand `child` of a live boolean group combines with the operands below it. */
+declare function vectorOperandOperation(group: VectorGroupNode, child: VectorNode): VectorBooleanOperation;
+/** How many boolean steps (one operand combined with the result below it) live booleans have computed: what a cache miss costs. */
+declare function vectorLiveBooleanSteps(): number;
+/** Empties the live boolean prefix cache. */
+declare function clearVectorLiveBooleanCache(): void;
+/** One operand of a live boolean: its outline (group space), fill rule and operation (unused for the bottom one). */
+interface VectorBooleanOperand {
+    path: BezierPath;
+    fillRule: VectorFillRule;
+    operation: VectorBooleanOperation;
+}
+/**
+ * The result of folding `operands` bottom to top, reusing the longest cached prefix: only the
+ * operands above it are combined. Invalid geometry gives an empty path.
+ */
+declare function foldVectorBooleanOperands(operands: readonly VectorBooleanOperand[]): BezierPath;
+/** Applies an effect stack to shapes, top to bottom (disabled effects skipped). */
+declare function applyVectorEffects(shapes: readonly VectorAppearanceShape[], effects: readonly VectorEffect[] | null | undefined): VectorAppearanceShape[];
+/**
+ * What a node draws as: shapes in its own space (its `transform` and opacity not applied),
+ * bottom to top, with its effects and those of everything inside it applied. Cached per node
+ * object.
+ */
+declare function vectorAppearanceShapes(node: VectorNode): VectorAppearanceShape[];
+/** Everything a node draws as one path in its own space (live corners cut, effects applied). */
+declare function vectorAppearanceOutline(node: VectorNode): BezierPath;
+/** What a node draws as, one plain path per shape (ids `<id>~fx<n>`, opacity relative to the node). */
+declare function vectorAppearanceNodes(node: VectorNode): VectorPathNode[];
+/**
+ * The node as plain geometry: path effects and live booleans evaluated into paths (the node
+ * itself when nothing inside it is live). A path keeps its id when it draws as one shape;
+ * otherwise, like any live group, it becomes a group with that id holding one path per shape
+ * (ids `<id>~fx<n>`). Groups without effects of their own keep their structure. Cached per node.
+ */
+declare function expandVectorAppearance(node: VectorNode): VectorNode;
+/** Every node of a list expanded (the same array when nothing in it is live). */
+declare function expandVectorAppearances(nodes: readonly VectorNode[]): VectorNode[];
+/**
+ * Reads effects from untrusted data (JSON, agent input): unknown types and malformed entries are
+ * dropped, parameters normalized, ids made unique.
+ */
+declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
+/**
+ * Effect parameters carried through a linear map baked into a node's geometry (scaling or
+ * flipping it): offsets and positions move with it, angles turn the other way when it mirrors.
+ * Lengths such as sizes and radii are kept, like stroke widths.
+ */
+declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix): VectorEffect[];
+/**
+ * The live groups (live booleans and groups with effects) being edited: those in `ids` and those
+ * holding a node in `ids`. Their children are hit and outlined as stored instead of as drawn, so
+ * each operand can be picked (figcraft `crates/engine/src/booleans.rs`, `result_outline`).
+ */
+declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
+
 interface VectorRenderPath {
     kind: 'path';
     id: string;
@@ -2207,6 +2540,8 @@ declare const VECTOR_BUILDER_HATCH_GAP = 6;
 declare function getVectorSceneRenderData(state: Pick<VectorEditorState, 'document' | 'viewport'>, options?: {
     idPrefix?: string;
 }): VectorSceneRenderData;
+/** Live groups being edited in `state` (see `vectorEnteredGroups`). */
+declare function getVectorEnteredGroups(state: Pick<VectorEditorState, 'document' | 'selection' | 'editingId'>): Set<string>;
 /** 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. */
@@ -2374,6 +2709,33 @@ declare const VECTOR_EDIT_TOGGLES: readonly {
     label: string;
     title: string;
 }[];
+/** One effect of the listed stack, with what a panel needs to edit it. */
+interface VectorEffectsPanelItem {
+    id: string;
+    type: VectorEffectType;
+    label: string;
+    enabled: boolean;
+    params: Record<string, unknown>;
+    specs: readonly VectorEffectParamSpec[];
+}
+/** What an Effects panel shows for the selection. */
+interface VectorEffectsPanelData {
+    /** The node whose stack is listed (when one node is selected), else null. */
+    nodeId: string | null;
+    /** Selected nodes an added effect goes to. */
+    count: number;
+    /** The listed stack, applied top to bottom. */
+    effects: VectorEffectsPanelItem[];
+    /** Something selected is live (Expand Appearance applies). */
+    expandable: boolean;
+}
+/** Effect types in menu order, with their names. */
+declare const VECTOR_EFFECT_MENU: readonly {
+    type: VectorEffectType;
+    label: string;
+}[];
+/** The Effects panel of the selection, or null when nothing that takes effects is selected. */
+declare function getVectorEffectsPanel(state: Pick<VectorEditorState, 'document' | 'selection'>): VectorEffectsPanelData | null;
 
 interface VectorCommandOptions {
     /** Id prefix (default `vector.`); use one per editor when several are registered. */
@@ -2419,6 +2781,12 @@ interface VectorNodeListing {
     };
     /** An in-between generated by a blend (locked; changes come from its keys). */
     blendStep?: boolean;
+    /** The node's live path effects, applied in order. */
+    effects?: VectorEffect[];
+    /** A live boolean group's operation (its children are the operands). */
+    liveBoolean?: VectorBooleanOperation;
+    /** An operand's own operation in a live boolean group. */
+    booleanOperation?: VectorBooleanOperation;
 }
 /**
  * Palette and agent commands for a vector editor: list, select, add shapes and paths, style,
@@ -2756,10 +3124,13 @@ interface VectorPathEntry {
 }
 /**
  * The path nodes inside `roots` (or every node when `roots` is null), bottom to top, with their
- * parent matrices. Hidden nodes are skipped, and locked ones unless `locked` is true.
+ * parent matrices. Hidden nodes are skipped, and locked ones unless `locked` is true. Live nodes
+ * (path effects, live booleans) take part as drawn (`expandVectorAppearance`: their entries are
+ * the expanded paths, whose ids may not be in the document) unless `expand` is false.
  */
 declare function vectorPathEntries(doc: VectorDocument, roots: readonly string[] | null, options?: {
     locked?: boolean;
+    expand?: boolean;
 }): VectorPathEntry[];
 /** Whether a subpath, closed, encloses an area (rather than retracing itself). */
 declare function subpathEnclosesArea(sp: VectorSubpath): boolean;
@@ -3115,4 +3486,79 @@ declare function expandVectorBlend(group: VectorGroupNode, newId: () => string):
  */
 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 };
+/** Total arc length of a path (closing lines included). */
+declare function effectPathLength(path: BezierPath): number;
+/** Number of on-curve points of a path (a closed subpath's start counted once). */
+declare function effectPathVertexCount(path: BezierPath): number;
+/** The fractions of the length a trim keeps, or null when it keeps everything. */
+declare function trimIntervals(start: number, end: number, offsetDegrees: number): [number, number][] | null;
+/**
+ * Trim Paths, simultaneously: every path is trimmed by the same fractions of its own length.
+ * `start` / `end` in percent, `offset` in degrees. Paths trimmed away entirely come back empty.
+ */
+declare function trimPaths(paths: readonly BezierPath[], start: number, end: number, offsetDegrees?: number): BezierPath[];
+/**
+ * Trim Paths, individually: the paths are laid end to end in stacking order and trimmed as one
+ * length, so they draw on one after another.
+ */
+declare function trimPathsIndividually(paths: readonly BezierPath[], start: number, end: number, offsetDegrees?: number): BezierPath[];
+/**
+ * Pucker & Bloat (`amount` in percent, −100 to 100). Positive (bloat) moves the points towards
+ * the mean of a path's points and pushes the handles away from it, so the segments bulge
+ * outwards; negative (pucker) does the opposite, giving spiky shapes.
+ */
+declare function puckerBloatPaths(paths: readonly BezierPath[], amount: number): BezierPath[];
+/**
+ * Round Corners: every corner (where the direction jumps) gets a circular arc of `radius`,
+ * shrunk to fit where the sides are short. Smooth points and the ends of open paths are kept.
+ */
+declare function roundCornerPaths(paths: readonly BezierPath[], radius: number): BezierPath[];
+/**
+ * Offset Paths: grows (positive `amount`) or shrinks (negative) every path with the given join.
+ * `copies` copies are made, copy i offset by `amount · (i + 1 + copyOffset)`, all in one path.
+ */
+declare function offsetPaths(paths: readonly BezierPath[], amount: number, join?: VectorLineJoin, miterLimit?: number, copies?: number, copyOffset?: number): BezierPath[];
+/**
+ * Twist: turns the paths about `center` by an angle growing with the distance from it, from 0
+ * at the centre to `angle` degrees at the farthest point. Segments are subdivided and their
+ * handles mapped through the warp's derivative, which keeps the result smooth.
+ */
+declare function twistPaths(paths: readonly BezierPath[], angle: number, center: Vec2): BezierPath[];
+/**
+ * Zig Zag: every segment gets `ridges` ridges: it is split into `ridges + 1` equal pieces and the
+ * points (original ones included) are pushed alternately `size` to either side of the path.
+ * `smooth` makes rounded waves. A closed path of n segments ends up with `n · (ridges + 1)` points
+ * (an open one, one more).
+ */
+declare function zigzagPaths(paths: readonly BezierPath[], size: number, ridges: number, smooth?: boolean): BezierPath[];
+/**
+ * Wiggle Paths: subdivides the paths (`detail` points per segment) and moves every point by
+ * smooth noise of up to `size` that evolves over `time` seconds at `speed` wiggles per second.
+ * The same parameters always give the same result.
+ */
+declare function wigglePaths(paths: readonly BezierPath[], w: VectorEffectParamsMap['wiggle']): BezierPath[];
+/** Merge Paths: the paths (in stacking order, each filled non-zero) combined into one path. */
+declare function mergePaths(paths: readonly BezierPath[], mode?: VectorMergeMode): BezierPath;
+/** One copy a repeater makes: its transform (node space) and opacity factor. */
+interface VectorRepeaterCopy {
+    /** Copy number (0 is the original). */
+    index: number;
+    matrix: AffineMatrix;
+    opacity: number;
+}
+/**
+ * The copies of a repeater around `pivot` (the anchor point in node space), in copy order.
+ * Copy i is moved by `translate(position·k) · rotate(rotation·k) · scale^k` about the pivot with
+ * `k = i + offset`; opacity runs from the start to the end opacity across the copies, and a
+ * fractional copy count fades the last copy by its fraction.
+ */
+declare function vectorRepeaterCopies(r: VectorEffectParamsMap['repeater'], pivot: Vec2): VectorRepeaterCopy[];
+/** Each path repeated by `vectorRepeaterCopies` (copy order, the original first). */
+declare function repeatPaths(paths: readonly BezierPath[], r: VectorEffectParamsMap['repeater'], pivot: Vec2): {
+    copy: VectorRepeaterCopy;
+    paths: BezierPath[];
+}[];
+/** The middle of the paths' bounds (the origin when they are empty). */
+declare function pathsCenter(paths: readonly BezierPath[]): Vec2;
+
+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_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_EFFECT_TYPES, VECTOR_FILL_GAP, VECTOR_INK_MAX_CORNERS, VECTOR_MERGE_MODES, 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 VectorAppearanceShape, 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 VectorBooleanOperand, 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 VectorEffect, type VectorEffectParamSpec, type VectorEffectParamsMap, type VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorFillRule, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHitTestOptions, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorMergeMode, 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 VectorRepeaterCopy, 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, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, applyVectorEffects, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, clearVectorLiveBooleanCache, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorEffect, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorBlendGroup, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, parseSvgTransform, parseVectorSvg, pathsCenter, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, repeatPaths, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePolyline, sanitizeVectorEffects, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorEffects, transformVectorNode, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorAppearanceNodes, vectorAppearanceOutline, vectorAppearanceShapes, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDocumentToSvg, vectorEnteredGroups, vectorFillMap, vectorInkShapeName, vectorLiveBooleanSteps, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute, wigglePaths, zigzagPaths };