@pixerate/editor 0.36.0 → 0.38.0

package/dist/vector/index.d.cts

@@ -1,4 +1,4 @@
-import { C as CanvasGradientDef, A as AffineMatrix, B as BezierPathInput, a as BezierPath, S as SvgGradientDef } from '../bezier-D8bsO-L0.cjs';
+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-Bd87_lsQ.cjs';
 import { P as Point } from '../types-BFkYA4eF.cjs';
 import { H as HistoryManager } from '../HistoryManager-DeQQMBCj.cjs';
 import { C as CommandSpec } from '../registry-D0GADKc7.cjs';
@@ -75,6 +75,17 @@ declare const VECTOR_ARROWHEADS: readonly VectorArrowhead[];
  * tip sits on the end point and the stroke is shortened under the head.
  */
 type VectorArrowAlign = 'extend' | 'tip';
+/**
+ * One point of a variable-width stroke profile. `t` is the position along the subpath by
+ * length (0 at its start, 1 at its end); `left` and `right` are how far the stroke reaches on
+ * each side, as multiples of half the stroke width (looking along the path on screen, y down).
+ * A uniform stroke has 1 on both sides. Two points at the same `t` make a step.
+ */
+interface VectorWidthPoint {
+    t: number;
+    left: number;
+    right: number;
+}
 /** Paint and stroke settings of a path. */
 interface VectorStyle {
     fill?: VectorPaint;
@@ -98,6 +109,12 @@ interface VectorStyle {
     startArrowScale?: number;
     /** Size of the end head (default 1). */
     endArrowScale?: number;
+    /**
+     * Variable width: side scales along each subpath, interpolated with a monotone cubic (see
+     * `widthProfileAt`). Absent, empty or `null` strokes at a uniform width. A profiled stroke is
+     * drawn as its filled outline.
+     */
+    strokeWidthProfile?: VectorWidthPoint[] | null;
 }
 interface VectorNodeBase {
     id: string;
@@ -154,10 +171,12 @@ interface VectorHandleRef extends VectorAnchorRef {
 }
 /**
  * Canvas tools. `direct` edits anchors, handles and segments; the shape tools drag out a new
- * shape; `scissors` cuts a path at a point, `knife` cuts filled shapes along a freehand stroke
- * and `eraser` rubs out the area under one.
+ * 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.
  */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser';
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -192,6 +211,14 @@ interface VectorDefaults extends VectorStyle {
 type VectorAlign = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
 type VectorDistribute = 'horizontal' | 'vertical';
 type VectorBooleanOperation = 'union' | 'subtract' | 'intersect' | 'exclude';
+/**
+ * Pathfinder operations: `divide` (every face its own shape), `trim` (hidden parts removed),
+ * `merge` (Trim, then touching parts of one fill joined), `crop` (the top shape crops the others),
+ * `outline` (outlines cut into open strokes where they meet) and `minusBack` (the top shape minus
+ * everything below it).
+ */
+type VectorPathfinderOperation = 'divide' | 'trim' | 'merge' | 'crop' | 'outline' | 'minusBack';
+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';
@@ -408,6 +435,11 @@ interface VectorRenderStrokeParts {
     d: string;
     /** Width to draw it with: twice the stroke width when aligned, half of it being clipped away. */
     width: number;
+    /**
+     * A variable-width stroke: the area to fill with `stroke` (nonzero) instead of stroking `d`,
+     * clipped or masked like the stroke would be.
+     */
+    outline?: string;
     /**
      * Inside: a `<clipPath id>` holding the shape (`d`, `clip-rule` = `fillRule`). Outside: a
      * `<mask id>` in user space over `bounds`, white with the shape (`d`) in black.
@@ -422,6 +454,10 @@ interface VectorRenderStrokeParts {
 }
 /** The stroke parts of a path whose stroke needs more than one element, in its own space (undefined otherwise). */
 declare function vectorStrokeSvgParts(node: VectorPathNode, clipId: string, precision?: number): VectorRenderStrokeParts | undefined;
+/** A width profile as a data attribute: `t,left,right` points separated by `;`. */
+declare function widthProfileToAttribute(points: readonly VectorWidthPoint[], precision?: number): string;
+/** Reads `widthProfileToAttribute` output (invalid points are dropped). */
+declare function widthProfileFromAttribute(value: string | undefined): VectorWidthPoint[];
 /** Serializes a vector document as a standalone SVG string. */
 declare function vectorDocumentToSvg(doc: VectorDocument, options?: VectorSvgExportOptions): string;
 interface VectorSvgImportOptions {
@@ -491,6 +527,136 @@ declare function nextVectorCornerKind(kind: VectorCornerKind | undefined): Vecto
 /** Every anchor of a subpath given the same live corner (radius 0 clears them). */
 declare function setSubpathCorners(sp: VectorSubpath, radius: number, kind?: VectorCornerKind): VectorSubpath;
 
+/**
+ * Variable-width stroke profiles: stroke widths at positions along a path (each subpath on its
+ * own), interpolated smoothly and held flat before the first and after the last point. Each
+ * point has a left and a right side scale (looking along the path on screen, y down), so a
+ * stroke can grow on one side only.
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, see THIRD_PARTY_NOTICES.md):
+ * - figcraft `crates/doc/src/props.rs` — `WidthProfile` / `WidthPoint`: sanitising, side
+ *   scales, inserting and moving points, and the monotone cubic (Fritsch–Carlson) interpolation
+ *   that never overshoots its neighbouring points.
+ * - vectorcraft `crates/doc/src/appearance.rs` — `WidthProfile` as `(t, left, right)` points,
+ *   discontinuous points (two points at one `t` make a step) and the profile presets.
+ * - effectcraft `crates/path/src/varstroke.rs` — `width_factor`: the parametric Taper (lengths,
+ *   end widths, ease) and Wave (amount, cycles, phase) shapes, used here as profile generators.
+ */
+
+/** The most points a profile keeps. */
+declare const VECTOR_WIDTH_PROFILE_MAX_POINTS = 64;
+/** The widest a side can be, as a multiple of the stroke width. */
+declare const VECTOR_WIDTH_PROFILE_MAX_SCALE = 1000;
+/** Positions closer than this are the same place (the two sides of a discontinuous point). */
+declare const VECTOR_WIDTH_SAME_T = 0.000001;
+/** Built-in profiles. `uniform` is the plain stroke (no profile). */
+type VectorWidthPreset = 'uniform' | 'taperStart' | 'taperEnd' | 'taperBoth' | 'bulge' | 'pinch' | 'teardrop' | 'wave' | 'pressure';
+/** One preset as a menu shows it. */
+interface VectorWidthPresetInfo {
+    id: VectorWidthPreset;
+    label: string;
+    points: readonly VectorWidthPoint[];
+}
+/** The built-in profiles, in menu order. */
+declare const VECTOR_WIDTH_PRESETS: readonly VectorWidthPresetInfo[];
+declare const VECTOR_WIDTH_PRESET_IDS: readonly VectorWidthPreset[];
+/**
+ * A profile as the outline uses it: finite points only, `t` in 0–1, side scales in 0–1000,
+ * sorted by `t` (stable, so a step keeps its order), at most 64 points. Points missing a side
+ * take the other side's scale.
+ */
+declare function sanitizeWidthProfile(points: readonly Partial<VectorWidthPoint>[] | null | undefined): VectorWidthPoint[];
+/** True when the profile draws a plain stroke: no points, or every side at scale 1. */
+declare function isUniformWidthProfile(points: readonly VectorWidthPoint[] | null | undefined): boolean;
+/**
+ * The left and right side scales at `t` (0–1 along the subpath by length). Each side is
+ * interpolated on its own with a monotone cubic, so the width never overshoots its points;
+ * a profile without points is uniform (1, 1).
+ */
+declare function widthProfileAt(points: readonly VectorWidthPoint[] | null | undefined, t: number): {
+    left: number;
+    right: number;
+};
+/** The largest side scale (the interpolation never exceeds its points); 1 without a profile. */
+declare function widthProfileMaxScale(points: readonly VectorWidthPoint[] | null | undefined): number;
+/** The points of a preset (empty for `uniform`), or null for an unknown id. */
+declare function widthProfilePreset(id: string): VectorWidthPoint[] | null;
+/** The preset a profile matches: `uniform` without one (or all at scale 1), `custom` when none matches. */
+declare function widthProfilePresetId(points: readonly VectorWidthPoint[] | null | undefined): VectorWidthPreset | 'custom';
+/** The profile of the reversed path: positions mirrored and the sides swapped. */
+declare function reverseWidthProfile(points: readonly VectorWidthPoint[]): VectorWidthPoint[];
+/** The profile of a mirrored path (it runs the same way, but its sides swap). */
+declare function mirrorWidthProfile(points: readonly VectorWidthPoint[]): VectorWidthPoint[];
+/**
+ * Adds a width point at `t` (side scales `left` / `right`, default: as wide as the stroke is
+ * there) and returns the new profile and the point's index. Inserting at the position of an
+ * existing point replaces it, unless `step` is set (which makes a discontinuous point).
+ */
+declare function insertWidthPoint(points: readonly VectorWidthPoint[] | null | undefined, t: number, sides?: {
+    left?: number;
+    right?: number;
+}, options?: {
+    step?: boolean;
+}): {
+    points: VectorWidthPoint[];
+    index: number;
+};
+/**
+ * Changes point `index`: moves it to `t` (kept between its neighbours, so indices stay put)
+ * and / or sets its side scales. Out-of-range indices leave the profile as it is.
+ */
+declare function setWidthPoint(points: readonly VectorWidthPoint[], index: number, patch: Partial<VectorWidthPoint>): VectorWidthPoint[];
+/** Removes the points at `indices`. */
+declare function removeWidthPoints(points: readonly VectorWidthPoint[], indices: readonly number[]): VectorWidthPoint[];
+/** A parametric taper (effectcraft's Stroke Taper), lengths as fractions of the path. */
+interface VectorTaperOptions {
+    /** Fraction of the path the start taper covers (default 0). */
+    startLength?: number;
+    /** Fraction the end taper covers (default 0). */
+    endLength?: number;
+    /** Width at the start as a fraction of the stroke width (default 0: a point). */
+    startWidth?: number;
+    endWidth?: number;
+    /** 0 linear, 1 a quarter circle bulging outwards (default 0). */
+    startEase?: number;
+    endEase?: number;
+}
+/** A width wave (effectcraft's Stroke Wave): the width swings between `1 − amount` and 1. */
+interface VectorWaveOptions {
+    /** 0–1 (default 0.5). */
+    amount?: number;
+    /** Whole cycles along the path (default 4). */
+    cycles?: number;
+    /** Degrees (default 0). */
+    phase?: number;
+}
+/** The width factor at fraction `t` of a taper and / or a wave (effectcraft `width_factor`). */
+declare function taperWaveFactor(t: number, taper?: VectorTaperOptions | null, wave?: VectorWaveOptions | null): number;
+/**
+ * Samples a taper and / or wave into profile points (symmetric), simplified to within
+ * `tolerance` of the factor (default 0.01). The monotone interpolation draws them back smoothly.
+ */
+declare function generateWidthProfile(options: {
+    taper?: VectorTaperOptions | null;
+    wave?: VectorWaveOptions | null;
+    samples?: number;
+    tolerance?: number;
+}): VectorWidthPoint[];
+/** Pen pressure that draws the stroke's own width (a mouse reports 0.5 while a button is down). */
+declare const VECTOR_PRESSURE_NOMINAL = 0.5;
+/**
+ * A profile from pen pressure recorded along a stroke: `(t, pressure 0–1)` samples in order.
+ * The width scale is pressure ÷ 0.5 (so half pressure draws the stroke's width, full pressure
+ * twice it), at least 0.05; the samples are simplified to within `tolerance` (default 0.02).
+ * Returns an empty (uniform) profile when every sample is the same.
+ */
+declare function pressureWidthProfile(samples: readonly {
+    t: number;
+    pressure: number;
+}[], options?: {
+    tolerance?: number;
+}): VectorWidthPoint[];
+
 /**
  * What a guide line shows: `align` lines run from a target through the snapped point or box,
  * `construction` lines from where a drawn point leaves, `spacing` marks equal gaps and `size`
@@ -725,7 +891,19 @@ interface VectorPathEditOptions {
     recognizeShapes: boolean;
     /** Eraser diameter in document units (default 10). */
     eraserSize: number;
+    /**
+     * Record pointer pressure on pencil strokes as a width profile: `pen` (default) for pen input
+     * only, `all` for any pointer that reports pressure, `off` never.
+     */
+    pencilPressure: 'pen' | 'all' | 'off';
+    /**
+     * Paint bucket: gaps up to this distance (document units) between loose ends of outlines are
+     * closed when finding the region to fill (default 0, off).
+     */
+    fillGap: number;
 }
+/** The gap the toolbars' "Close gaps" toggle sets (document units). */
+declare const VECTOR_FILL_GAP = 6;
 /** Path-editing options new editors start with. */
 declare const DEFAULT_VECTOR_PATH_EDIT: Readonly<VectorPathEditOptions>;
 /** Longest pencil lazy-mouse string (at smoothing 1), in screen pixels. */
@@ -752,6 +930,27 @@ interface VectorEditorOptions {
 interface VectorPointerInput extends VectorModifiers {
     /** 0 = primary, 1 = middle (pans), 2 = secondary. Default 0. */
     button?: number;
+    /** `PointerEvent.pressure` (0–1), recorded on pencil strokes. */
+    pressure?: number;
+    /** `PointerEvent.pointerType` (`mouse`, `pen`, `touch`). */
+    pointerType?: string;
+}
+/** One width point of a path's stroke profile; `subpath` is the subpath it is shown on. */
+interface VectorWidthPointRef {
+    nodeId: string;
+    index: number;
+    subpath: number;
+}
+/** A spot on a stroke (width tool): where a drag would add a width point. Positions in document units. */
+interface VectorStrokeSpot {
+    nodeId: string;
+    subpath: number;
+    /** Position along the subpath by length, 0–1. */
+    t: number;
+    point: Vec2;
+    /** Ends of the stroke's width across the path there. */
+    left: Vec2;
+    right: Vec2;
 }
 /** A key press as the controller needs it. */
 interface VectorKeyInput extends VectorModifiers {
@@ -774,6 +973,12 @@ interface VectorHover {
     transformHandle?: VectorTransformHandle;
     /** A live corner widget (direct tool): the corner's anchor. */
     corner?: VectorAnchorRef;
+    /** A width point (width tool): its centre or the end of its left / right side. */
+    widthPoint?: VectorWidthPointRef & {
+        part: 'center' | 'left' | 'right';
+    };
+    /** A spot on a stroke away from its width points (width tool). */
+    strokeSpot?: VectorStrokeSpot;
 }
 /** The drag in progress, for overlays and status text. */
 type VectorInteraction = {
@@ -816,6 +1021,15 @@ type VectorInteraction = {
     tool: 'knife' | 'eraser';
     points: Vec2[];
     width: number;
+} | {
+    type: 'builder';
+    mode: 'merge' | 'erase';
+    points: Vec2[];
+} | {
+    type: 'width';
+    ref: VectorWidthPointRef;
+    mode: 'width' | 'move';
+    width: number;
 } | {
     type: 'pen';
     nodeId: string;
@@ -830,6 +1044,8 @@ 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 path whose anchors are being edited, if any. */
     editingId: string | null;
     /** Axis-aligned bounds of the selected nodes in document units. */
@@ -854,6 +1070,8 @@ interface VectorEditorState {
     } | null;
     /** Last pointer position in document units (for the pen preview), or null when outside. */
     pointer: Vec2 | null;
+    /** Shape Builder and paint bucket highlight: faces, line pieces and the gesture's trail. */
+    builder: VectorBuilderPreview | null;
     canUndo: boolean;
     canRedo: boolean;
     undoLabel: string;
@@ -867,6 +1085,37 @@ type VectorActionResult = {
     ok: false;
     message: 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
+ * delete, and the drag's trail. `mode` is `merge`, `erase` (Alt) or `fill` (paint bucket).
+ */
+interface VectorBuilderPreview {
+    mode: 'merge' | 'erase' | 'fill';
+    faces: BezierPath[];
+    lines: BezierPath[];
+    trail: Vec2[] | null;
+}
+/** Result of a Shape Builder gesture. */
+interface VectorShapeBuilderResult {
+    ok: boolean;
+    message?: string;
+    /** Id of the merged shape (none when erasing). */
+    merged: string | null;
+    faces: number;
+    lines: number;
+}
+/** A face of the Shape Builder map (document units). */
+interface VectorShapeBuilderFace {
+    index: number;
+    /** SVG path data. */
+    d: string;
+    area: number;
+    /** Ids of the paths whose fill covers it, bottom to top (empty for an area only outlines enclose). */
+    sources: string[];
+    /** A point inside it. */
+    point: Vec2 | null;
+}
 interface AddVectorNodeOptions {
     /** Group to add into (default: the root). */
     parentId?: string;
@@ -893,7 +1142,7 @@ interface VectorShapeInput extends VectorStyle {
     name?: string;
 }
 /** Every field of `VectorStyle`, in the order style panels and commands list them. */
-declare const VECTOR_STYLE_KEYS: readonly ["fill", "stroke", "strokeWidth", "strokeLinecap", "strokeLinejoin", "strokeDasharray", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale"];
+declare const VECTOR_STYLE_KEYS: readonly ["fill", "stroke", "strokeWidth", "strokeLinecap", "strokeLinejoin", "strokeDasharray", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale", "strokeWidthProfile"];
 /** Clipboard payload type written by `copy()`. */
 declare const VECTOR_CLIPBOARD_TYPE = "pixerate/vector";
 /** Screen distance of the rotation handle above the selection box. */
@@ -930,6 +1179,37 @@ interface VectorCornerWidget {
  * THIRD_PARTY_NOTICES.md), as is the `corner` drag below.
  */
 declare function getVectorCornerWidgets(state: Pick<VectorEditorState, 'document' | 'selection' | 'editingId' | 'tool' | 'pen' | 'selectedAnchors' | 'viewport'>): VectorCornerWidget[];
+/**
+ * The line a path's stroke follows (node space; shortened under `tip` arrowheads) and the
+ * distance a side scale of 1 reaches from it (half the drawn width: twice the stroke width for
+ * inside / outside strokes). Null for paths without a visible stroke.
+ */
+declare function vectorStrokeWidthGeometry(node: VectorPathNode): {
+    line: BezierPath;
+    unit: number;
+} | null;
+/** A width point of the width tool, in document units. */
+interface VectorWidthHandle {
+    ref: VectorWidthPointRef;
+    /** The point on the path. */
+    x: number;
+    y: number;
+    /** Ends of its left and right sides. */
+    left: Vec2;
+    right: Vec2;
+    t: number;
+    /** Side scales (multiples of half the stroke width). */
+    leftScale: number;
+    rightScale: number;
+    selected: boolean;
+}
+/**
+ * The width points the width tool shows: every profile point on every subpath of the stroke
+ * under the pointer, the selected paths and the stroke being edited. Ported from ArtCraft
+ * 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[];
 /** 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). */
@@ -986,6 +1266,8 @@ declare function vectorToolLabel(tool: VectorTool): string;
 declare const VECTOR_TOOL_SHORTCUTS: Readonly<Record<VectorTool, string>>;
 /** Short glyphs for tool buttons (pair them with `vectorToolLabel` for the accessible name). */
 declare const VECTOR_TOOL_GLYPHS: Readonly<Record<VectorTool, string>>;
+/** Names of the Pathfinder operations (undo steps, groups and buttons). */
+declare const VECTOR_PATHFINDER_LABELS: Readonly<Record<VectorPathfinderOperation, string>>;
 /**
  * Headless state for a vector editor: a document of paths and groups, select / direct /
  * pen / pencil / shape tools driven by pointer and key events, undo, transforms, boolean
@@ -998,6 +1280,7 @@ declare class VectorEditorController {
     private doc;
     private selection;
     private anchors;
+    private widthPoint;
     private editingId;
     private pen;
     private tool;
@@ -1017,6 +1300,13 @@ declare class VectorEditorController {
     private hoverTargets;
     private spaceHeld;
     private clipboard;
+    /** Shape Builder map of the selection, kept while the document and the selection stay the same. */
+    private builderCache;
+    /** Paint bucket map of the visible outlines. */
+    private fillCache;
+    private builderPreview;
+    /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
+    private builderHoverKey;
     private readonly createId;
     private readonly onChange?;
     private readonly listeners;
@@ -1131,6 +1421,19 @@ declare class VectorEditorController {
     }, ids?: readonly string[], options?: {
         label?: string;
     }): VectorActionResult;
+    /**
+     * Sets the variable-width profile of the selected (or given) paths: a preset id
+     * (`uniform` removes the profile), points, or a parametric taper / wave. Returns an error for
+     * an unknown preset.
+     */
+    setWidthProfile(profile: VectorWidthPreset | readonly VectorWidthPoint[] | {
+        taper?: VectorTaperOptions;
+        wave?: VectorWaveOptions;
+    } | null, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Removes one width point of a path's profile (the width tool's Delete). */
+    removeWidthPoint(ref: Pick<VectorWidthPointRef, 'nodeId' | 'index'>): VectorActionResult;
     /**
      * 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
@@ -1258,6 +1561,56 @@ declare class VectorEditorController {
     breakApart(options?: {
         ids?: readonly string[];
     }): VectorActionResult;
+    /**
+     * Pathfinder: Divide, Trim, Merge, Crop, Outline or Minus Back over the selected (or given)
+     * paths, in document space (rotated nodes and groups included, live corners cut). Unfilled
+     * stroked paths take part as the area their stroke paints (Divide: open ones cut instead).
+     * The results replace the operands at the place of the top-most one, grouped when there are
+     * several; each keeps the style of the operand whose area it is. Returns the new path ids,
+     * or an empty list when nothing came out.
+     */
+    pathfinder(op: VectorPathfinderOperation, options?: {
+        ids?: readonly string[];
+    }): string[];
+    /** The Shape Builder map of the selected (or given) paths, cached per document and selection. */
+    private shapeBuilderMap;
+    /** The faces the Shape Builder offers for the selected (or given) paths (document units). */
+    getShapeBuilderFaces(options?: {
+        ids?: readonly string[];
+    }): VectorShapeBuilderFace[];
+    /** Pick distance of the Shape Builder's erase for line pieces (document units). */
+    private builderLineTolerance;
+    /**
+     * Shape Builder gesture along `points` (document units; one point is a click) over the faces
+     * the selected (or given) paths make. Merges the faces touched into one shape styled like the
+     * top-most shape over the first face (the current fill for a face only outlines enclose);
+     * with `erase` deletes them, and the pieces of unfilled open paths within `tolerance`. Every
+     * shape covering a touched face loses that area. One undo step.
+     */
+    shapeBuilder(points: readonly Vec2[], options?: {
+        ids?: readonly string[];
+        erase?: boolean;
+        tolerance?: number;
+    }): VectorShapeBuilderResult;
+    private applyShapeBuilder;
+    /** The paint bucket's map of the visible outlines, cached per document and gap. */
+    private fillMap;
+    /**
+     * Paint bucket: the region the visible outlines enclose around `point` (document units),
+     * crossings split and islands left as holes, becomes a new path filled with the current fill
+     * default, placed just below the selection (or on top when nothing is selected). `gap`
+     * (default `editing.fillGap`) closes gaps up to that size between loose ends. Returns the new
+     * path's id, or null when nothing encloses the point.
+     */
+    fillRegion(point: Vec2, options?: {
+        gap?: number;
+    }): string | null;
+    /** Updates the Shape Builder / paint bucket highlight for the pointer at `p`; true when it changed. */
+    private hoverBuilder;
+    private builderPreviewOf;
+    private downBuilder;
+    private moveBuilder;
+    private upBuilder;
     private updateAnchors;
     /** Moves anchors by a document-space offset (converted into each node's own space). */
     private movedAnchors;
@@ -1403,6 +1756,12 @@ declare class VectorEditorController {
     /** Endpoints of open subpaths of unlocked visible paths (pen tool resumes from them). */
     private openEndpoints;
     private computeHover;
+    private widthView;
+    /** The width point centre or side end under `screen` (width tool). */
+    private hitWidthHandle;
+    /** The nearest stroked, unlocked visible path whose stroke is under document point `p` (width tool). */
+    private strokeSpotAt;
+    private downWidth;
     /** The nearest outline point of any visible, unlocked path within the pick distance of document point `p`. */
     private nearestOutline;
     private sameHover;
@@ -1517,6 +1876,22 @@ interface VectorRenderCornerWidget {
     /** Its corners are being dragged. */
     active: boolean;
 }
+/**
+ * A width point of the width tool in screen pixels: a diamond at (`x`, `y`) on the path and a
+ * line across the stroke from `left` to `right`, with a handle at each end.
+ */
+interface VectorRenderWidthPoint {
+    ref: VectorWidthPointRef;
+    x: number;
+    y: number;
+    left: Vec2;
+    right: Vec2;
+    selected: boolean;
+    /** The part under the pointer, if any. */
+    hovered: 'center' | 'left' | 'right' | null;
+    /** Being dragged. */
+    active: boolean;
+}
 /** A smart guide line in screen pixels. */
 interface VectorRenderGuideLine {
     kind: VectorGuideKind;
@@ -1586,6 +1961,29 @@ interface VectorOverlayRenderData {
      * Alt-click to cycle round / inverted / chamfer, click to pick its corner alone.
      */
     cornerWidgets: VectorRenderCornerWidget[];
+    /** Width points of the width tool (screen space). */
+    widthPoints: VectorRenderWidthPoint[];
+    /**
+     * Where a width-tool drag would add a width point (screen space): draw a dashed line from
+     * `left` to `right` and a hollow diamond at (`x`, `y`).
+     */
+    widthSpot: {
+        x: number;
+        y: number;
+        left: Vec2;
+        right: Vec2;
+    } | null;
+    /**
+     * Shape Builder and paint bucket highlight (screen space): `faces` are filled paths (fill
+     * them translucent and outline them), `lines` are line pieces an erase deletes, `trail` is
+     * the drag's polyline. `mode` is `merge`, `erase` (Alt) or `fill` (paint bucket).
+     */
+    builder: {
+        mode: 'merge' | 'erase' | 'fill';
+        faces: string[];
+        lines: string[];
+        trail: string | null;
+    } | null;
     /** A short status, e.g. "W 120 × H 80" or "45°". */
     status: string | null;
 }
@@ -1612,7 +2010,16 @@ declare const VECTOR_OVERLAY_THEME: {
     readonly handleRadius: 3.5;
     /** Radius of a live corner widget (a ring with a dot). */
     readonly cornerWidgetRadius: 4;
+    /** Half the diagonal of a width point's diamond. */
+    readonly widthPointSize: 5;
+    /** Shape Builder faces to merge and paint bucket regions. */
+    readonly builderFill: "rgba(14, 165, 233, 0.22)";
+    /** Shape Builder faces and line pieces an Alt gesture deletes. */
+    readonly builderErase: "#ef4444";
+    readonly builderEraseFill: "rgba(239, 68, 68, 0.22)";
 };
+/** SVG path data of the diamond a width point is drawn with (screen pixels). */
+declare function vectorDiamondPath(x: number, y: number, r?: number): string;
 interface ModifierEventLike {
     shiftKey?: boolean;
     altKey?: boolean;
@@ -1625,10 +2032,17 @@ declare function toVectorModifiers(event: ModifierEventLike): {
     alt: boolean;
     mod: boolean;
 };
-/** A pointer event as `VectorEditorController.pointerDown/Move/Up` input. */
+/**
+ * A pointer event as `VectorEditorController.pointerDown/Move/Up` input: modifiers, button,
+ * and the pressure and pointer type the pencil records as a width profile.
+ */
 declare function toVectorPointerInput(event: ModifierEventLike & {
     button?: number;
+    pressure?: number;
+    pointerType?: string;
 }): {
+    pointerType?: string | undefined;
+    pressure?: number | undefined;
     button: number | undefined;
     shift: boolean;
     alt: boolean;
@@ -1657,6 +2071,9 @@ interface VectorSelectionStyle {
     arrowAlign: VectorArrowAlign;
     startArrowScale: number;
     endArrowScale: number;
+    /** The first path's width profile (null when uniform) and the preset it matches. */
+    strokeWidthProfile: VectorWidthPoint[] | null;
+    widthProfile: VectorWidthPreset | 'custom';
     /**
      * Live corners of the selected anchors (direct tool) or of every corner of the selected
      * paths: the first one's radius and kind, and how many corners there are (0: none to round).
@@ -1677,6 +2094,7 @@ interface VectorSelectionStyle {
         arrowAlign: boolean;
         startArrowScale: boolean;
         endArrowScale: boolean;
+        widthProfile: boolean;
         cornerRadius: boolean;
         cornerKind: boolean;
     };
@@ -1703,6 +2121,16 @@ interface VectorPathAction {
 }
 /** Join, Average, Cut at Points, Remove Redundant Points, Smooth and Outline Stroke, as the toolbars show them. */
 declare const VECTOR_PATH_ACTIONS: readonly VectorPathAction[];
+/** A Pathfinder button of the bundled toolbars. */
+interface VectorPathfinderAction {
+    id: VectorPathfinderOperation;
+    label: string;
+    title: string;
+    /** Paths (or groups) it needs selected. */
+    min: number;
+}
+/** Divide, Trim, Merge, Crop, Outline and Minus Back, as the toolbars show them. */
+declare const VECTOR_PATHFINDER_ACTIONS: readonly VectorPathfinderAction[];
 /** The on / off path-editing settings the toolbars toggle. */
 declare const VECTOR_EDIT_TOGGLES: readonly {
     key: 'keepShapeOnDelete' | 'curvatureMoves' | 'recognizeShapes';
@@ -1954,8 +2382,15 @@ interface VectorStrokeParts {
 declare function isClosedBezierShape(path: BezierPath): boolean;
 /** The alignment a stroke is drawn with: the style's, or `center` for open shapes. */
 declare function effectiveStrokeAlign(style: Pick<VectorStyle, 'strokeAlign'>, closedShape: boolean): VectorStrokeAlign;
-/** True when the style asks for more than a plain centred stroke (an alignment or arrowheads). */
+/** The style's width profile, sanitised, or null when the stroke is uniform. */
+declare function strokeWidthProfileOf(style: Pick<VectorStyle, 'strokeWidthProfile'>): VectorWidthPoint[] | null;
+/** True when the style asks for more than a plain centred stroke (an alignment, arrowheads or a width profile). */
 declare function hasStrokeExtras(style: VectorStyle): boolean;
+/**
+ * The area of the stroke along `parts.line` before alignment clipping: SVG's stroke for a
+ * 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. */
 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. */
@@ -1983,4 +2418,181 @@ declare function hitTestVectorStroke(path: BezierPath, p: Vec2, style: VectorSty
 /** How far the stroke can reach past the outline (for padding bounds and masks). */
 declare function vectorStrokeReach(style: VectorStyle): number;
 
-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_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_EDIT_TOGGLES, VECTOR_INK_MAX_CORNERS, VECTOR_OVERLAY_THEME, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, 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 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 VectorPathNode, 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 VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeParts, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, applyMatrix, applyMatrixLinear, applyVectorCornersAttribute, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, createVectorCommands, curvatureMoveAnchor, cutSubpathAt, decomposeRigid, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorCornerWidgets, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVisibleAnchors, getVisibleHandles, hasPaint, hasStrokeExtras, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, invertMatrix, isClosedBezierShape, isIdentityMatrix, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, moveAnchorHandle, multiplyMatrices, nearestSegment, nextVectorCornerKind, nodeMatrix, parseSvgTransform, parseVectorSvg, polygonSubpath, polylineBounds, recognizeInkShape, rectSubpath, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, reverseSubpath, rotateMatrix, roundSubpaths, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, subpathPointAt, subpathSegment, subpathSegmentCount, subpathsToBezier, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, unionBounds, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDocumentToSvg, vectorInkShapeName, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathWorldBezier, vectorResizeCursor, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorToolLabel, vectorWorldMatrix, walkVectorNodes };
+/**
+ * The outline of a variable-width stroke, as a clean filled Bézier path.
+ *
+ * Each subpath is flattened (finely enough for the width to vary smoothly) and the stroke is
+ * the union of positively wound pieces: one trapezoid per flattened segment (its ends at the
+ * local side widths), a wedge on the outer side of every bend (the style's join at the path's
+ * own corners, round inside curves) and the caps. Filled with the non-zero rule the union is
+ * exact whatever the profile does; it is built as the boundary those pieces add up to (see
+ * `variableStrokeRings`), normalised with the polygon boolean engine, and every ring is refitted
+ * with cubics (`fitCubics`) to within the tolerance — a real Bézier outline, not a polyline.
+ *
+ * Ported from ArtCraft effectcraft `crates/path/src/varstroke.rs` (`outline`, `dash_intervals`)
+ * (MIT OR Apache-2.0, see THIRD_PARTY_NOTICES.md), with one-sided widths after figcraft
+ * `crates/pathops/src/width.rs` (`variable_outline`).
+ */
+
+interface VariableStrokeOptions {
+    /** Stroke width: a side scale of 1 reaches half of it from the centre line. */
+    width: number;
+    profile: readonly VectorWidthPoint[];
+    /** Joins at the path's own corners (default `miter`); bends inside curves are always round. */
+    join?: StrokeJoin;
+    /** Default `butt`. */
+    cap?: StrokeCap;
+    /** Default 4 (as SVG). */
+    miterLimit?: number;
+    /** Dash pattern (as SVG); the profile still runs along the whole subpath. */
+    dash?: readonly number[];
+    dashOffset?: number;
+    /** Largest distance of the result from the exact outline (default 0.05). */
+    tolerance?: number;
+}
+type Vec = [number, number];
+/** Arc-length intervals that are "on" for a dash pattern on a path `len` long (effectcraft `dash_intervals`). */
+declare function dashIntervals(pattern: readonly number[], offset: number, len: number): [number, number][];
+/**
+ * The rings of a variable-width stroke in the path's own space; filled with the non-zero rule
+ * they are the stroke.
+ *
+ * effectcraft builds the stroke as a union of positively wound pieces: a trapezoid per flattened
+ * segment (its ends at the local side widths), a wedge on the outer side of every bend and the
+ * caps. Unioning thousands of overlapping pieces is slow, so each run is emitted as the boundary
+ * those pieces add up to instead (winding numbers add, so the non-zero fill is the same): the
+ * offset sides with the outer join between them, and on the inner side of a bend either the point
+ * where the two offsets cross (the region cut off is covered by both trapezoids) or, when they do
+ * not cross, a detour through the centre point (which keeps the winding right when segments are
+ * shorter than the width). A closed subpath gives two rings, an open run one.
+ */
+declare function variableStrokeRings(path: BezierPath, options: VariableStrokeOptions): Point[][];
+/**
+ * The outline of a variable-width stroke of `path` (side widths from `profile`), as a clean
+ * Bézier path: overlaps removed, outer rings and holes, each refitted with cubics to within
+ * `tolerance` of the exact outline. Fill it with the non-zero rule (either rule works).
+ */
+declare function variableStrokeOutline(path: BezierPath, options: VariableStrokeOptions): BezierPath;
+/**
+ * Where point `p` lies relative to the stroke's centre line: the nearest point's contour,
+ * its position `t` by length (0–1), the distance, and the side (`left` looking along the
+ * path on screen) — what hit-testing and the width tool need.
+ */
+declare function nearestStrokePosition(path: BezierPath, p: Point, 
+/** Only this contour (subpath) of the path. */
+only?: number): {
+    contour: number;
+    t: number;
+    distance: number;
+    side: 'left' | 'right';
+    point: Point;
+    tangent: Vec;
+    length: number;
+} | null;
+/** The point and unit tangent at position `t` (0–1 by length) of contour `index` of `path`. */
+declare function strokePositionPoint(path: BezierPath, index: number, t: number): {
+    point: Point;
+    tangent: Vec;
+} | null;
+
+/** A path node with the matrix of its parent space (parent → document). */
+interface VectorPathEntry {
+    node: VectorPathNode;
+    parent: AffineMatrix;
+}
+/**
+ * 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.
+ */
+declare function vectorPathEntries(doc: VectorDocument, roots: readonly string[] | null, options?: {
+    locked?: boolean;
+}): VectorPathEntry[];
+/** Whether a subpath, closed, encloses an area (rather than retracing itself). */
+declare function subpathEnclosesArea(sp: VectorSubpath): boolean;
+/** How an operand takes part in a Pathfinder operation: its fill, its stroke's area, a cutting line or its bare outline. */
+type VectorPathfinderPaint = 'fill' | 'stroke' | 'line' | 'outline';
+/** The Pathfinder shape of a path (document space), and what it stands for. */
+declare function vectorPathfinderShape(entry: VectorPathEntry, op: PathfinderOperation): PathfinderShape & {
+    paint: VectorPathfinderPaint;
+};
+/**
+ * Style of a Pathfinder or Shape Builder result taken from `node`: the node's own style for a
+ * filled area, the stroke's paint as a fill for a stroke's area, or (for Outline edges) a stroke
+ * in the paint of the area the edge bounds. Never carries the node's id, transform or geometry.
+ */
+declare function vectorResultStyle(node: VectorPathNode, paint: VectorPathfinderPaint, edge?: boolean): Omit<VectorPathNode, 'id' | 'subpaths'>;
+/** A piece of an unfilled open path between the points where other paths meet it. */
+interface VectorBuilderLinePiece {
+    path: BezierPath;
+    segments: BezierSegment[];
+    /** Index of the entry it belongs to. */
+    source: number;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+/** The Shape Builder's planar map of a set of paths. */
+interface VectorShapeBuilderMap {
+    entries: VectorPathEntry[];
+    map: PlanarMap;
+    /** Entries with no closed subpath (cutting lines; their pieces can be erased). */
+    lines: boolean[];
+    pieces: VectorBuilderLinePiece[];
+}
+/** What a Shape Builder gesture touches at a point. */
+type VectorBuilderHit = {
+    face: number;
+} | {
+    line: number;
+};
+/** The faces and line pieces a gesture touched, in the order touched. */
+interface VectorBuilderTouched {
+    faces: number[];
+    lines: number[];
+}
+/**
+ * The Shape Builder map of `entries` (bottom to top). Filled open subpaths that enclose an area
+ * are closed. Null when nothing can be mapped.
+ */
+declare function vectorShapeBuilderMap(entries: readonly VectorPathEntry[]): VectorShapeBuilderMap | null;
+/** The face under `p`, or with `lineTolerance` (erasing) first the line piece that close. */
+declare function vectorShapeBuilderHit(m: VectorShapeBuilderMap, p: Vec2, lineTolerance?: number | null): VectorBuilderHit | null;
+/** Points along a polyline no more than `step` apart (the pointer's path through faces). */
+declare function samplePolyline(points: readonly Vec2[], step: number): Vec2[];
+/** Adds what a point hits to `touched` (each face or piece once). */
+declare function addBuilderHit(touched: VectorBuilderTouched, hit: VectorBuilderHit | null): boolean;
+/** What becomes of one entry: unchanged (absent), removed (`null`), or new outlines (document space). */
+type VectorBuilderReplacement = {
+    kind: 'fill';
+    path: BezierPath;
+} | {
+    kind: 'pieces';
+    paths: BezierPath[];
+} | null;
+interface VectorShapeBuilderPlan {
+    replace: Map<number, VectorBuilderReplacement>;
+    /** The merged shape (document space), styled like entry `style`; `currentFill` when only outlines enclosed it. */
+    merged: {
+        path: BezierPath;
+        style: number;
+        currentFill: boolean;
+    } | null;
+}
+/**
+ * What a gesture does: merging (or with `erase`, deleting) the touched faces takes them away
+ * from every shape covering them; line pieces touched (erasing) or lying between touched faces
+ * go; merging adds the union of the faces as a new shape styled like the top-most shape over the
+ * first face touched (or, for a face only outlines enclose, the top-most shape with the current
+ * fill).
+ */
+declare function planShapeBuilder(m: VectorShapeBuilderMap, touched: VectorBuilderTouched, erase: boolean): VectorShapeBuilderPlan;
+/**
+ * The planar map of every visible path's outline as drawn (locked ones included), for the paint
+ * bucket. `gap` closes gaps up to that distance between loose ends.
+ */
+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_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, 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 };