@pixerate/editor 0.96.0 → 0.98.0

package/dist/vector/index.d.ts

@@ -1,15 +1,52 @@
-import { d as Vec2, e as VectorSubpath, b as VectorBounds, f as VectorAnchor, V as VectorDocument, a as VectorNode, g as VectorPathNode, h as VectorAnchorType, i as VectorPaint, j as VectorGroupNode, k as VectorCornerKind, l as VectorWidthPoint, m as VectorGradientHandle, n as VectorGradient, o as VectorGradientStop, p as VectorViewport, q as VectorEffectType, r as VectorEffectParamsMap, s as VectorFillRule, t as VectorBooleanOperation, u as VectorEffect, v as VectorWarpMesh, w as VectorTransformHandle, x as VectorAnchorRef, y as VectorPathfinderOperation, z as VectorTool, A as VectorDefaults, B as VectorStyle, C as VectorHandleRef, D as VectorSegmentRef, E as VectorBlendOptions, F as VectorModifiers, c as VectorSvgExportOptions, G as VectorGradientPatch, H as VectorAlign, I as VectorDistribute, J as VectorArrange, K as VectorAverageAxis, L as VectorArrowhead, M as VectorBlendSpacing, N as VectorGradientInterpolation, O as VectorGradientSpread, P as VectorGradientType, Q as VectorStrokeAlign, R as VectorStrokeGradientMode, S as VectorRenderStrokeParts, T as VectorPaintDef, U as VectorArrowAlign, W as VectorBlend, X as VectorMergeMode, Y as VectorLineJoin, Z as VectorWarpStyle } from '../svg-Dh17jCyA.js';
-export { _ as VECTOR_ARROWHEADS, $ as VECTOR_BLEND_SPACINGS, a0 as VECTOR_CORNER_KINDS, a1 as VECTOR_EFFECT_TYPES, a2 as VECTOR_GRADIENT_INTERPOLATIONS, a3 as VECTOR_GRADIENT_MAX_PERIODS, a4 as VECTOR_GRADIENT_MIN_STOPS, a5 as VECTOR_GRADIENT_SPREADS, a6 as VECTOR_GRADIENT_TYPES, a7 as VECTOR_MERGE_MODES, a8 as VECTOR_PATHFINDER_OPERATIONS, a9 as VECTOR_STROKE_GRADIENT_MODES, aa as VECTOR_TOOLS, ab as VECTOR_TRANSFORM_HANDLES, ac as VectorCorner, ad as VectorGradientPoints, ae as VectorGradientRamp, af as VectorGradientSvgOptions, ag as VectorGradientUnits, ah as VectorLineCap, ai as VectorMatrix, aj as VectorPaintSvgOptions, ak as VectorRgba, al as VectorSvgImportOptions, am as VectorSvgPatternDef, an as VectorSvgWrapper, ao as applyVectorCornersAttribute, ap as applyVectorGradientPatch, aq as applyVectorGradientSpread, ar as convertVectorGradient, as as defaultVectorGradient, at as expandVectorGradientSpread, au as expandVectorGradientStops, av as explicitVectorGradient, aw as gradientMidpointRemap, ax as hasExplicitGradientGeometry, ay as insertVectorGradientStop, az as isCentredVectorGradient, aA as isVectorGradient, aB as mapVectorGradient, aC as mapVectorPaint, aD as moveVectorGradientHandle, aE as moveVectorGradientStop, aF as parseSvgTransform, aG as parseVectorColor, aH as parseVectorSvg, aI as patternAttrs, aJ as periodicVectorGradientStops, aK as pinVectorGradient, aL as removeVectorGradientStop, aM as reverseVectorGradient, aN as samplePlainStops, aO as sampleVectorGradient, aP as sampleVectorGradientAt, aQ as sampleVectorPaintDefAt, aR as sanitizeVectorGradient, aS as setVectorGradientVector, aT as sortedVectorGradientStops, aU as spanVectorGradientStops, aV as transformVectorGradient, aW as transformVectorPaint, aX as vectorBoxMatrix, aY as vectorCornersAttribute, aZ as vectorDocumentToSvg, a_ as vectorGradientArea, a$ as vectorGradientAspect, b0 as vectorGradientFocalParam, b1 as vectorGradientHandles, b2 as vectorGradientMatrix, b3 as vectorGradientMidpointFromPosition, b4 as vectorGradientMidpointPosition, b5 as vectorGradientNeedsExpansion, b6 as vectorGradientParam, b7 as vectorGradientPoints, b8 as vectorGradientRamp, b9 as vectorGradientSvgDefs, ba as vectorGradientTAt, bb as vectorGradientUnitsMatrix, bc as vectorPaintToSvg, bd as vectorPathLocalBounds, be as vectorStrokeSvgParts, bf as widthProfileFromAttribute, bg as widthProfileToAttribute } from '../svg-Dh17jCyA.js';
+import { d as Vec2$1, e as VectorSubpath, b as VectorBounds, f as VectorAnchor, V as VectorDocument, a as VectorNode, g as VectorPathNode, h as VectorAnchorType, i as VectorPaint, j as VectorGroupNode, k as VectorCornerKind, l as VectorWidthPoint, m as VectorGradientHandle, n as VectorGradient, o as VectorGradientStop, p as VectorViewport, q as VectorEffectType, r as VectorEffectParamsMap, s as VectorFillRule, t as VectorBooleanOperation, u as VectorEffect, v as VectorWarpMesh, w as VectorTransformHandle, x as VectorAnchorRef, y as VectorPathfinderOperation, z as VectorTool, A as VectorDefaults, B as VectorStyle, C as VectorHandleRef, D as VectorSegmentRef, E as VectorBlendOptions, F as VectorModifiers, c as VectorSvgExportOptions, G as VectorGradientPatch, H as VectorAlign, I as VectorDistribute, J as VectorArrange, K as VectorAverageAxis, L as VectorArrowhead, M as VectorBlendSpacing, N as VectorGradientInterpolation, O as VectorGradientSpread, P as VectorGradientType, Q as VectorStrokeAlign, R as VectorStrokeGradientMode, S as VectorRenderStrokeParts, T as VectorPaintDef, U as VectorArrowAlign, W as VectorBlend, X as VectorMergeMode, Y as VectorLineJoin } from '../svg-MVKBqwD4.js';
+export { Z as VECTOR_ARROWHEADS, _ as VECTOR_BLEND_SPACINGS, $ as VECTOR_CORNER_KINDS, a0 as VECTOR_EFFECT_TYPES, a1 as VECTOR_GRADIENT_INTERPOLATIONS, a2 as VECTOR_GRADIENT_MAX_PERIODS, a3 as VECTOR_GRADIENT_MIN_STOPS, a4 as VECTOR_GRADIENT_SPREADS, a5 as VECTOR_GRADIENT_TYPES, a6 as VECTOR_MERGE_MODES, a7 as VECTOR_PATHFINDER_OPERATIONS, a8 as VECTOR_STROKE_GRADIENT_MODES, a9 as VECTOR_TOOLS, aa as VECTOR_TRANSFORM_HANDLES, ab as VectorCorner, ac as VectorGradientPoints, ad as VectorGradientRamp, ae as VectorGradientSvgOptions, af as VectorGradientUnits, ag as VectorLineCap, ah as VectorMatrix, ai as VectorPaintSvgOptions, aj as VectorRgba, ak as VectorSvgImportOptions, al as VectorSvgPatternDef, am as VectorSvgWrapper, an as VectorWarpStyle, ao as applyVectorCornersAttribute, ap as applyVectorGradientPatch, aq as applyVectorGradientSpread, ar as convertVectorGradient, as as defaultVectorGradient, at as expandVectorGradientSpread, au as expandVectorGradientStops, av as explicitVectorGradient, aw as gradientMidpointRemap, ax as hasExplicitGradientGeometry, ay as insertVectorGradientStop, az as isCentredVectorGradient, aA as isVectorGradient, aB as mapVectorGradient, aC as mapVectorPaint, aD as moveVectorGradientHandle, aE as moveVectorGradientStop, aF as parseSvgTransform, aG as parseVectorColor, aH as parseVectorSvg, aI as patternAttrs, aJ as periodicVectorGradientStops, aK as pinVectorGradient, aL as removeVectorGradientStop, aM as reverseVectorGradient, aN as samplePlainStops, aO as sampleVectorGradient, aP as sampleVectorGradientAt, aQ as sampleVectorPaintDefAt, aR as sanitizeVectorGradient, aS as setVectorGradientVector, aT as sortedVectorGradientStops, aU as spanVectorGradientStops, aV as transformVectorGradient, aW as transformVectorPaint, aX as vectorBoxMatrix, aY as vectorCornersAttribute, aZ as vectorDocumentToSvg, a_ as vectorGradientArea, a$ as vectorGradientAspect, b0 as vectorGradientFocalParam, b1 as vectorGradientHandles, b2 as vectorGradientMatrix, b3 as vectorGradientMidpointFromPosition, b4 as vectorGradientMidpointPosition, b5 as vectorGradientNeedsExpansion, b6 as vectorGradientParam, b7 as vectorGradientPoints, b8 as vectorGradientRamp, b9 as vectorGradientSvgDefs, ba as vectorGradientTAt, bb as vectorGradientUnitsMatrix, bc as vectorPaintToSvg, bd as vectorPathLocalBounds, be as vectorStrokeSvgParts, bf as widthProfileFromAttribute, bg as widthProfileToAttribute } from '../svg-MVKBqwD4.js';
 import { P as Point } from '../types-BFkYA4eF.js';
-import { A as AffineMatrix, a as BezierPathInput, B as BezierPath, c as BezierSegment } from '../bezier-DYBvLgUH.js';
+import { a as BezierPathInput, A as AffineMatrix$1, B as BezierPath, c as BezierSegment } from '../bezier-DYBvLgUH.js';
 export { S as SvgGradientDef } from '../bezier-DYBvLgUH.js';
 import { H as HistoryManager } from '../HistoryManager-DWSLd6Tf.js';
 import { C as CommandSpec } from '../registry-rVtFJjRM.js';
 import { S as StrokeJoin, a as StrokeCap, P as PlanarMap, b as PathfinderOperation, c as PathfinderShape } from '../pathfinder-CNtsbCRK.js';
 import { b as AnimationEasing } from '../easing-lM0Xo9Ni.js';
+export { W as VECTOR_WARP_STYLES, a as VECTOR_WARP_STYLE_LABELS, b as VectorWarpPreset, c as applyVectorHomography, d as dragVectorMeshPoint, e as evalVectorMesh, f as fitVectorMesh, i as isValidVectorMesh, m as mapVectorMeshPoints, o as orderVectorQuad, p as pullVectorMesh, r as removeVectorMeshSplitU, g as removeVectorMeshSplitV, h as resizeVectorMesh, s as solve8, j as splitVectorMeshU, k as splitVectorMeshV, l as vectorHomography, n as vectorHomographyKeepsQuad, q as vectorIdentityMesh, w as vectorMeshColumns, t as vectorMeshControlBounds, u as vectorMeshEditPoints, v as vectorMeshGridCurves, x as vectorMeshParamAt, y as vectorMeshRows, z as vectorWarpPresetGrid, A as vectorWarpPresetMesh } from '../warp-B8rAguzs.js';
+import { A as AffineMatrix, V as Vec2 } from '../types-CwMPoRMU.js';
+export { H as VectorHomography } from '../types-CwMPoRMU.js';
 import '../types-DsiXGmjo.js';
 import '../schema-Di0CS6Pe.js';
 
+/**
+ * Affine matrices in SVG order (`[a, b, c, d, e, f]`), shared by the vector and image editors.
+ * Angles are degrees, clockwise on screen (y points down).
+ */
+
+declare const IDENTITY_MATRIX: AffineMatrix;
+/** `a` then `b` (apply `a` first). */
+declare function multiplyMatrices(a: AffineMatrix, b: AffineMatrix): AffineMatrix;
+declare const translateMatrix: (dx: number, dy: number) => AffineMatrix;
+declare function scaleMatrix(sx: number, sy: number, origin?: Vec2): AffineMatrix;
+/** Rotation by `degrees` clockwise (y points down) around `origin`. */
+declare function rotateMatrix(degrees: number, origin?: Vec2): AffineMatrix;
+declare function applyMatrix(m: AffineMatrix, p: Vec2): Vec2;
+declare function isIdentityMatrix(m: AffineMatrix, eps?: number): boolean;
+/** The inverse matrix (the identity for a singular one). */
+declare function invertMatrix(m: AffineMatrix): AffineMatrix;
+/** Applies only the linear part (for directions and offsets). */
+declare function applyMatrixLinear(m: AffineMatrix, v: Vec2): Vec2;
+/**
+ * The rotation of a matrix in degrees, clockwise (y down), in (−180, 180]. For a mirrored
+ * matrix it is the rotation left after undoing a horizontal flip, so a flipped rotated shape
+ * keeps its angle.
+ */
+declare function matrixRotation(m: AffineMatrix): number;
+/**
+ * Splits `m` into `residual` then `rigid` (`m = residual × rigid` in apply order): `rigid` is
+ * the nearest rotation plus the translation, `residual` the linear rest (scale, skew,
+ * reflection). An unrotated `m` gives an identity `rigid` and everything in `residual`.
+ */
+declare function decomposeRigid(m: AffineMatrix): {
+    rigid: AffineMatrix;
+    residual: AffineMatrix;
+};
+
 declare const cloneAnchor: (a: VectorAnchor) => VectorAnchor;
 declare const cloneSubpath: (s: VectorSubpath) => VectorSubpath;
 /** A deep copy of a node (ids kept). */
@@ -53,12 +90,12 @@ declare function locateVectorNode(nodes: VectorNode[], id: string): {
 /** Every path node in the subtree (a path node itself, or a group's descendants). */
 declare function collectPathNodes(node: VectorNode): VectorPathNode[];
 /** The node's local → parent matrix (identity when it has no `transform`). */
-declare function nodeMatrix(node: VectorNode): AffineMatrix;
+declare function nodeMatrix(node: VectorNode): AffineMatrix$1;
 /**
  * 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?: {
+declare function vectorPathWorldBezier(node: VectorPathNode, parent?: AffineMatrix$1, options?: {
     effects?: boolean;
 }): BezierPath;
 /**
@@ -66,13 +103,13 @@ declare function vectorPathWorldBezier(node: VectorPathNode, parent?: AffineMatr
  * by default the node's parent space, which for top-level nodes is the document. Null when
  * the node has no points.
  */
-declare function vectorNodeBounds(node: VectorNode, parent?: AffineMatrix): VectorBounds | null;
+declare function vectorNodeBounds(node: VectorNode, parent?: AffineMatrix$1): VectorBounds | null;
 /** The smallest box around all non-null boxes, or null. */
 declare function unionBounds(list: readonly (VectorBounds | null | undefined)[]): VectorBounds | null;
 /** True when two boxes overlap (touching counts). */
 declare function boundsIntersect(a: VectorBounds, b: VectorBounds): boolean;
 /** A box from two corners in any order. */
-declare function boundsFromPoints(a: Vec2, b: Vec2): VectorBounds;
+declare function boundsFromPoints(a: Vec2$1, b: Vec2$1): VectorBounds;
 /** Options of `hitTestVectorNode`. */
 interface VectorHitTestOptions {
     /**
@@ -86,71 +123,44 @@ interface VectorHitTestOptions {
  * (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, options?: VectorHitTestOptions): boolean;
+declare function hitTestVectorNode(node: VectorNode, p: Vec2$1, tolerance?: number, parent?: AffineMatrix$1, 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;
+declare function vectorStrokeOutline(node: VectorPathNode, parent?: AffineMatrix$1): BezierPath;
 /** The topmost node hit by `p` (skipping hidden and locked ones), or null. */
-declare function hitTestVectorNodes(nodes: readonly VectorNode[], p: Vec2, tolerance?: number, options?: VectorHitTestOptions): VectorNode | null;
+declare function hitTestVectorNodes(nodes: readonly VectorNode[], p: Vec2$1, tolerance?: number, options?: VectorHitTestOptions): VectorNode | null;
 interface NearestSegment {
     subpath: number;
     segment: number;
     /** Curve parameter 0–1 on the segment. */
     t: number;
-    point: Vec2;
+    point: Vec2$1;
     distance: number;
 }
 /** The closest point on any segment of a path node (`p` and the result are in the node's own space). */
-declare function nearestSegment(node: VectorPathNode, p: Vec2): NearestSegment | null;
-declare const IDENTITY_MATRIX: AffineMatrix;
-/** `a` then `b` (apply `a` first). */
-declare function multiplyMatrices(a: AffineMatrix, b: AffineMatrix): AffineMatrix;
-declare const translateMatrix: (dx: number, dy: number) => AffineMatrix;
-declare function scaleMatrix(sx: number, sy: number, origin?: Vec2): AffineMatrix;
-/** Rotation by `degrees` clockwise (y points down) around `origin`. */
-declare function rotateMatrix(degrees: number, origin?: Vec2): AffineMatrix;
-declare function applyMatrix(m: AffineMatrix, p: Vec2): Vec2;
-declare function isIdentityMatrix(m: AffineMatrix, eps?: number): boolean;
-/** The inverse matrix (the identity for a singular one). */
-declare function invertMatrix(m: AffineMatrix): AffineMatrix;
-/** Applies only the linear part (for directions and offsets). */
-declare function applyMatrixLinear(m: AffineMatrix, v: Vec2): Vec2;
-/**
- * The rotation of a matrix in degrees, clockwise (y down), in (−180, 180]. For a mirrored
- * matrix it is the rotation left after undoing a horizontal flip, so a flipped rotated shape
- * keeps its angle.
- */
-declare function matrixRotation(m: AffineMatrix): number;
-/**
- * Splits `m` into `residual` then `rigid` (`m = residual × rigid` in apply order): `rigid` is
- * the nearest rotation plus the translation, `residual` the linear rest (scale, skew,
- * reflection). An unrotated `m` gives an identity `rigid` and everything in `residual`.
- */
-declare function decomposeRigid(m: AffineMatrix): {
-    rigid: AffineMatrix;
-    residual: AffineMatrix;
-};
+declare function nearestSegment(node: VectorPathNode, p: Vec2$1): NearestSegment | null;
+
 /**
  * A copy of the node moved by `m`, given in its parent's space. The node's rotation and
  * translation go to its rigid `transform`; scale and skew are baked into its anchors (or its
  * children), so the result draws exactly as `m` says. Stroke widths are kept.
  */
-declare function transformVectorNode<T extends VectorNode>(node: T, m: AffineMatrix): T;
+declare function transformVectorNode<T extends VectorNode>(node: T, m: AffineMatrix$1): T;
 /** The node's rotation in degrees (from its `transform` and its ancestors' when `parent` is given). */
-declare function vectorNodeRotation(node: VectorNode, parent?: AffineMatrix): number;
+declare function vectorNodeRotation(node: VectorNode, parent?: AffineMatrix$1): number;
 /** The local → document matrix of node `id` (ancestors' transforms included), or null. */
-declare function vectorWorldMatrix(nodes: readonly VectorNode[], id: string): AffineMatrix | null;
+declare function vectorWorldMatrix(nodes: readonly VectorNode[], id: string): AffineMatrix$1 | null;
 /** The parent space → document matrix of node `id` (identity for top-level nodes), or null. */
-declare function vectorParentMatrix(nodes: readonly VectorNode[], id: string): AffineMatrix | null;
+declare function vectorParentMatrix(nodes: readonly VectorNode[], id: string): AffineMatrix$1 | null;
 /** Moves an anchor and its handles by (dx, dy). */
 declare function translateAnchor(a: VectorAnchor, dx: number, dy: number): VectorAnchor;
 /**
  * Moves one handle to `pos`, keeping the other in line for `smooth` anchors and mirrored for
  * `symmetric` ones. With `breakHandles` the anchor becomes a `corner` and only this handle moves.
  */
-declare function moveAnchorHandle(a: VectorAnchor, side: 'in' | 'out', pos: Vec2, breakHandles?: boolean): VectorAnchor;
+declare function moveAnchorHandle(a: VectorAnchor, side: 'in' | 'out', pos: Vec2$1, breakHandles?: boolean): VectorAnchor;
 /**
  * Converts anchor `index` of a subpath. `corner` removes both handles; `smooth` and
  * `symmetric` keep existing handles in line, or add handles a third of the way to the
@@ -186,7 +196,7 @@ declare function polygonSubpath(b: VectorBounds, sides?: number): VectorSubpath;
 /** A star inscribed in a box, first point at the top. `innerRatio` is inner / outer radius. */
 declare function starSubpath(b: VectorBounds, points?: number, innerRatio?: number): VectorSubpath;
 /** A straight open line. */
-declare function lineSubpath(a: Vec2, b: Vec2): VectorSubpath;
+declare function lineSubpath(a: Vec2$1, b: Vec2$1): VectorSubpath;
 /** Rounds every coordinate to `precision` decimals (stable JSON and SVG output). */
 declare function roundSubpaths(subpaths: readonly VectorSubpath[], precision?: number): VectorSubpath[];
 
@@ -198,10 +208,10 @@ interface VectorCornerInfo {
     subpath: number;
     index: number;
     /** Where the sides meet. */
-    at: Vec2;
+    at: Vec2$1;
     /** Unit directions the sides leave the corner in: towards the previous anchor, then the next one. */
-    u: Vec2;
-    v: Vec2;
+    u: Vec2$1;
+    v: Vec2$1;
     /** The sides' lengths (along curves), in the same order. */
     lu: number;
     lv: number;
@@ -222,9 +232,9 @@ declare const cornerSetback: (c: Pick<VectorCornerInfo, "cos" | "sin">, r: numbe
 /** `radius` clamped to what the corner can draw (0 for negative or non-finite radii). */
 declare const fitCornerRadius: (c: Pick<VectorCornerInfo, "maxRadius">, radius: number) => number;
 /** The point `k` along the corner's bisector, measured in (u + v): a round cut of radius r is centred at k = r / sin. */
-declare const cornerBisectorPoint: (c: VectorCornerInfo, k: number) => Vec2;
+declare const cornerBisectorPoint: (c: VectorCornerInfo, k: number) => Vec2$1;
 /** How much the radius grows when the round cut's centre moves by `d` (its part along the bisector, in radius units). */
-declare const cornerRadiusChange: (c: VectorCornerInfo, d: Vec2) => number;
+declare const cornerRadiusChange: (c: VectorCornerInfo, d: Vec2$1) => number;
 /** True when any anchor of the subpaths has a live corner radius. */
 declare function hasVectorCorners(subpaths: readonly VectorSubpath[]): boolean;
 /** One subpath with its corners cut; `sources[i]` is the stored anchor each output anchor comes from. */
@@ -419,16 +429,16 @@ interface VectorGradientAnnotator {
     /** The path's box in its own space. */
     bounds: VectorBounds | null;
     /** The path's own space → document. */
-    world: AffineMatrix;
+    world: AffineMatrix$1;
     /** Screen positions of the handles. */
-    start: Vec2;
-    end: Vec2;
+    start: Vec2$1;
+    end: Vec2$1;
     /** Radial, conic and diamond gradients. */
-    aspect: Vec2 | null;
+    aspect: Vec2$1 | null;
     /** Radial gradients. */
-    focal: Vec2 | null;
+    focal: Vec2$1 | null;
     /** Unit normal to the bar towards the stop chips (screen). */
-    normal: Vec2;
+    normal: Vec2$1;
     /** Stops (sorted, as the gradient stores them) with their chips' screen positions. */
     stops: (VectorGradientStop & {
         index: number;
@@ -450,12 +460,12 @@ declare function vectorGradientTargetPath(doc: VectorDocument, selection: readon
 /** The annotator of the selection's gradient (`target` paint), in screen pixels, or null when it has none. */
 declare function getVectorGradientAnnotator(doc: VectorDocument, selection: readonly string[], viewport: VectorViewport, target: VectorGradientTarget): VectorGradientAnnotator | null;
 /** Where `p` lies relative to the bar: offset along it (0 at the start, 1 at the end) and distance towards the stop chips. */
-declare function vectorGradientBarPosition(a: Pick<VectorGradientAnnotator, 'start' | 'end' | 'normal'>, p: Vec2): {
+declare function vectorGradientBarPosition(a: Pick<VectorGradientAnnotator, 'start' | 'end' | 'normal'>, p: Vec2$1): {
     offset: number;
     across: number;
 };
 /** The annotator part under screen point `p`: stops, then midpoints, the handles and the bar. */
-declare function hitVectorGradientAnnotator(a: VectorGradientAnnotator, p: Vec2): VectorGradientPart | null;
+declare function hitVectorGradientAnnotator(a: VectorGradientAnnotator, p: Vec2$1): VectorGradientPart | null;
 
 /**
  * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
@@ -628,7 +638,7 @@ declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
  * 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, node?: VectorNode): VectorEffect[];
+declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix$1, node?: VectorNode): 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
@@ -637,7 +647,7 @@ declare function transformVectorEffects(effects: readonly VectorEffect[], m: Aff
 declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
 
 /** A map of the plane (document or node space). */
-type VectorPointMap = (p: Vec2) => Vec2;
+type VectorPointMap = (p: Vec2$1) => Vec2$1;
 /** Every anchor and handle of `subpaths` through `f` (no subdivision). */
 declare function mapVectorPoints(subpaths: readonly VectorSubpath[], f: VectorPointMap): VectorSubpath[];
 interface MapVectorSubpathsOptions {
@@ -671,23 +681,23 @@ declare const VECTOR_DISTORT_TOLERANCE = 0.05;
 /** How dragging a selection box handle distorts it: each corner freely, or in symmetric perspective. */
 type VectorDistortMode = 'distort' | 'perspective';
 /** A box's corners clockwise from the top left. */
-declare const vectorBoxCorners: (b: VectorBounds) => Vec2[];
+declare const vectorBoxCorners: (b: VectorBounds) => Vec2$1[];
 /**
  * The quad (clockwise from the top left) box `b` becomes when handle `handle` is dragged by `d`: a
  * corner moves by `d` (`distort`), or along the drag's dominant axis with the corner beside it on
  * that side moving the opposite way (`perspective`); a side moves both its corners.
  */
-declare function vectorDistortQuad(b: VectorBounds, handle: VectorTransformHandle, d: Vec2, mode?: VectorDistortMode): Vec2[];
+declare function vectorDistortQuad(b: VectorBounds, handle: VectorTransformHandle, d: Vec2$1, mode?: VectorDistortMode): Vec2$1[];
 /**
  * The skew for dragging side `handle` of box `b` by `d`: along that side, about the opposite side
  * (or the centre, `fromCenter`). Corners give the identity.
  */
-declare function vectorShearForSide(b: VectorBounds, handle: VectorTransformHandle, d: Vec2, fromCenter?: boolean): AffineMatrix;
+declare function vectorShearForSide(b: VectorBounds, handle: VectorTransformHandle, d: Vec2$1, fromCenter?: boolean): AffineMatrix$1;
 /**
  * A skew by `ax` degrees horizontally (vertical lines lean right for positive angles: x' = x + tan(ax)·y)
  * and `ay` degrees vertically (y' = y + tan(ay)·x), about `origin`.
  */
-declare function vectorSkewMatrix(ax: number, ay: number, origin?: Vec2): AffineMatrix;
+declare function vectorSkewMatrix(ax: number, ay: number, origin?: Vec2$1): AffineMatrix$1;
 /**
  * A node sent through `f`, a map of the space `parentToDoc` maps its parent to (the document):
  * every anchor and handle is mapped in the node's own space, adaptively so curves stay within
@@ -695,7 +705,7 @@ declare function vectorSkewMatrix(ax: number, ay: number, origin?: Vec2): Affine
  * handles mapped (bounding-box ones follow the new bounds), envelope meshes and a blend's spine
  * are mapped too; stroke widths, live corner radii and effect parameters are kept.
  */
-declare function distortVectorNode<T extends VectorNode>(node: T, parentToDoc: AffineMatrix, f: VectorPointMap, tolerance?: number): T;
+declare function distortVectorNode<T extends VectorNode>(node: T, parentToDoc: AffineMatrix$1, f: VectorPointMap, tolerance?: number): T;
 
 /**
  * What a guide line shows: `align` lines run from a target through the snapped point or box,
@@ -725,7 +735,7 @@ interface VectorSnapGuides {
     labels: VectorGuideLabel[];
 }
 interface VectorPointSnap extends VectorSnapGuides {
-    point: Vec2;
+    point: Vec2$1;
     /** The rule that placed the point, or null when nothing was in reach. */
     kind: VectorSnapKind | null;
     /** Whether x / y were set by a target (for falling back to the grid on the other axis). */
@@ -749,7 +759,7 @@ interface VectorScaleSnap extends VectorSnapGuides {
  * anchor) and how it keeps to it.
  */
 interface VectorSnapLeave {
-    at: Vec2;
+    at: Vec2$1;
     /**
      * Shift held: keep to 45° steps round `at` (`angle`), to a diagonal (`square`, a box's
      * corner) or to the nearer axis (`axis`, a dragged point).
@@ -763,7 +773,7 @@ interface VectorSnapLeave {
 /** The construction guide angles new editors start with. */
 declare const VECTOR_CONSTRUCTION_ANGLES: readonly number[];
 /** Where `constrain` puts `p` (unchanged without one). */
-declare function constrainToLeave(leave: VectorSnapLeave | null | undefined, p: Vec2): Vec2;
+declare function constrainToLeave(leave: VectorSnapLeave | null | undefined, p: Vec2$1): Vec2$1;
 /**
  * Snap targets in document space, gathered once per gesture. Build them with `forMove`,
  * `forResize`, `forDrawing`, `forAnchorDrag` or `forHandle`, then call `snapFrom`,
@@ -824,7 +834,7 @@ declare class VectorSnapTargets {
      */
     private static collect;
     /** Snaps a single point (see `snapFrom`). */
-    snapPoint(p: Vec2, tol: number): VectorPointSnap;
+    snapPoint(p: Vec2$1, tol: number): VectorPointSnap;
     /**
      * Snaps a point `p`, drawn or dragged from `leave` when given. With `leave.constrain` it keeps
      * to its angle round `leave.at`, sliding along that way into line with the nearest target.
@@ -833,7 +843,7 @@ declare class VectorSnapTargets {
      * through `leave.at` (where a target's line crosses it if one does nearby), or else lines up
      * with targets on x and y.
      */
-    snapFrom(p: Vec2, leave: VectorSnapLeave | null | undefined, tol: number): VectorPointSnap;
+    snapFrom(p: Vec2$1, leave: VectorSnapLeave | null | undefined, tol: number): VectorPointSnap;
     private label;
     /** The anchor or centre nearest `p`, within `tol`. */
     private nearestPoint;
@@ -989,10 +999,10 @@ interface VectorStrokeSpot {
     subpath: number;
     /** Position along the subpath by length, 0–1. */
     t: number;
-    point: Vec2;
+    point: Vec2$1;
     /** Ends of the stroke's width across the path there. */
-    left: Vec2;
-    right: Vec2;
+    left: Vec2$1;
+    right: Vec2$1;
 }
 /**
  * The width point being edited numerically (double-click with the width tool): `index` is the
@@ -1007,7 +1017,7 @@ interface VectorWidthPointEdit {
     t: number;
     left: number;
     right: number;
-    point: Vec2;
+    point: Vec2$1;
 }
 /** A key press as the controller needs it. */
 interface VectorKeyInput extends VectorModifiers {
@@ -1025,7 +1035,7 @@ interface VectorHover {
         subpath: number;
         segment: number;
         t: number;
-        point: Vec2;
+        point: Vec2$1;
     };
     transformHandle?: VectorTransformHandle;
     /** A live corner widget (direct tool): the corner's anchor. */
@@ -1079,16 +1089,16 @@ type VectorInteraction = {
     tool: VectorTool;
     nodeId: string;
     bounds: VectorBounds;
-    string?: [Vec2, Vec2];
+    string?: [Vec2$1, Vec2$1];
 } | {
     type: 'stroke';
     tool: 'knife' | 'eraser';
-    points: Vec2[];
+    points: Vec2$1[];
     width: number;
 } | {
     type: 'builder';
     mode: 'merge' | 'erase';
-    points: Vec2[];
+    points: Vec2$1[];
 } | {
     type: 'width';
     ref: VectorWidthPointRef;
@@ -1109,7 +1119,7 @@ type VectorInteraction = {
  | {
     type: 'distort';
     mode: VectorDistortMode | 'skew';
-    corners: Vec2[];
+    corners: Vec2$1[];
 }
 /** Envelope tool: a mesh point (`index`) or the surface (`index` null) being dragged. */
  | {
@@ -1154,7 +1164,7 @@ interface VectorEditorState {
         subpath: number;
     } | null;
     /** Last pointer position in document units (for the pen preview), or null when outside. */
-    pointer: Vec2 | null;
+    pointer: Vec2$1 | null;
     /** Shape Builder and paint bucket highlight: faces, line pieces and the gesture's trail. */
     builder: VectorBuilderPreview | null;
     /** The Blend tool's first click: the shape (and anchor of its first subpath) the next click blends from. */
@@ -1210,7 +1220,7 @@ interface VectorBuilderPreview {
     mode: 'merge' | 'erase' | 'fill';
     faces: BezierPath[];
     lines: BezierPath[];
-    trail: Vec2[] | null;
+    trail: Vec2$1[] | null;
 }
 /** Result of a Shape Builder gesture. */
 interface VectorShapeBuilderResult {
@@ -1232,7 +1242,7 @@ interface VectorShapeBuilderFace {
     /** 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;
+    point: Vec2$1 | null;
 }
 interface AddVectorNodeOptions {
     /** Group to add into (default: the root). */
@@ -1313,8 +1323,8 @@ interface VectorWidthHandle {
     x: number;
     y: number;
     /** Ends of its left and right sides. */
-    left: Vec2;
-    right: Vec2;
+    left: Vec2$1;
+    right: Vec2$1;
     t: number;
     /** Side scales (multiples of half the stroke width). */
     leftScale: number;
@@ -1334,8 +1344,8 @@ declare function getAnchor(doc: VectorDocument, ref: VectorAnchorRef): VectorAnc
 declare function getAnchorWorld(doc: VectorDocument, ref: VectorAnchorRef): {
     x: number;
     y: number;
-    in?: Vec2;
-    out?: Vec2;
+    in?: Vec2$1;
+    out?: Vec2$1;
     type?: VectorAnchorType;
 } | undefined;
 /**
@@ -1371,10 +1381,10 @@ interface VectorSelectionBoxGeometry {
         handle: VectorTransformHandle;
         x: number;
         y: number;
-        screen: Vec2;
+        screen: Vec2$1;
     }[];
     /** The four corners on screen, clockwise from the top left. */
-    corners: Vec2[];
+    corners: Vec2$1[];
 }
 declare function getVectorSelectionBoxGeometry(frame: VectorSelectionFrame, viewport: VectorViewport): VectorSelectionBoxGeometry;
 /**
@@ -1388,7 +1398,7 @@ declare function getVectorEnvelopeTarget(doc: VectorDocument, selection: readonl
         bounds: VectorBounds;
         mesh: VectorWarpMesh;
     };
-    world: AffineMatrix;
+    world: AffineMatrix$1;
 } | null;
 /** The resize cursor for a handle of a box rotated by `angle` degrees. */
 declare function vectorResizeCursor(handle: VectorTransformHandle, angle?: number): string;
@@ -1494,11 +1504,11 @@ declare class VectorEditorController {
     private replaceNode;
     private freshIds;
     private newId;
-    screenToDocument(p: Vec2): Vec2;
-    documentToScreen(p: Vec2): Vec2;
+    screenToDocument(p: Vec2$1): Vec2$1;
+    documentToScreen(p: Vec2$1): Vec2$1;
     setViewport(viewport: Partial<VectorViewport>): void;
     /** Zooms by `factor` keeping the document point under `screen` in place. */
-    zoomAt(screen: Vec2, factor: number): void;
+    zoomAt(screen: Vec2$1, factor: number): void;
     panBy(dx: number, dy: number): void;
     /** Fits the artboard (or `bounds`) into a canvas of `size` screen pixels. */
     zoomToFit(size: {
@@ -1509,7 +1519,7 @@ declare class VectorEditorController {
         bounds?: VectorBounds;
     }): void;
     /** Zoom at the canvas centre-ish: positive `delta` zooms out (wheel convention). Use with `wheel`. */
-    wheel(screen: Vec2, delta: {
+    wheel(screen: Vec2$1, delta: {
         x: number;
         y: number;
     }, mods?: VectorModifiers): void;
@@ -1765,7 +1775,7 @@ declare class VectorEditorController {
      * so straight lines stay straight. Curves are followed within `tolerance` (document units).
      * One undo step.
      */
-    distort(corners: readonly Vec2[], options?: {
+    distort(corners: readonly Vec2$1[], options?: {
         ids?: readonly string[];
         tolerance?: number;
     }): VectorActionResult;
@@ -1776,7 +1786,7 @@ declare class VectorEditorController {
      */
     skew(ax: number, ay?: number, options?: {
         ids?: readonly string[];
-        origin?: Vec2;
+        origin?: Vec2$1;
     }): VectorActionResult;
     /** A selection box handle dragged in Free Distort mode. */
     private moveDistort;
@@ -1826,7 +1836,7 @@ declare class VectorEditorController {
     private downEnvelope;
     private moveEnvelope;
     /** Applies a matrix to the selected (or given) nodes as one undo step. */
-    transform(matrix: AffineMatrix, options?: {
+    transform(matrix: AffineMatrix$1, options?: {
         ids?: readonly string[];
         label?: string;
     }): VectorActionResult;
@@ -1843,12 +1853,12 @@ declare class VectorEditorController {
      */
     scale(sx: number, sy?: number, options?: {
         ids?: readonly string[];
-        origin?: Vec2;
+        origin?: Vec2$1;
     }): VectorActionResult;
     /** Rotates clockwise by `degrees` around `origin` (default: the selection centre). */
     rotate(degrees: number, options?: {
         ids?: readonly string[];
-        origin?: Vec2;
+        origin?: Vec2$1;
     }): VectorActionResult;
     /** Sets each selected (or given) node's rotation to `degrees`, turning it around its own centre. */
     setRotation(degrees: number, options?: {
@@ -1873,7 +1883,7 @@ declare class VectorEditorController {
     /** Copies the selection (offset by `offset`, default 10, 10) on top of each original. */
     duplicate(options?: {
         ids?: readonly string[];
-        offset?: Vec2;
+        offset?: Vec2$1;
     }): string[];
     private withDuplicates;
     /** Groups the selected nodes (they must share a parent). Returns the group id. */
@@ -1983,7 +1993,7 @@ declare class VectorEditorController {
      * deleted in the same gesture go with the face. Every shape covering a touched face loses
      * that area; paths keep their own transforms. One undo step.
      */
-    shapeBuilder(points: readonly Vec2[], options?: {
+    shapeBuilder(points: readonly Vec2$1[], options?: {
         ids?: readonly string[];
         erase?: boolean;
         tolerance?: number;
@@ -1998,7 +2008,7 @@ declare class VectorEditorController {
      * (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?: {
+    fillRegion(point: Vec2$1, options?: {
         gap?: number;
     }): string | null;
     /** Updates the Shape Builder / paint bucket highlight for the pointer at `p`; true when it changed. */
@@ -2014,7 +2024,7 @@ declare class VectorEditorController {
      * Moves one anchor to a document position. Its handles follow; with `curvature` (default:
      * the `curvatureMoves` setting) its two segments bend instead, as the Curvature tool does.
      */
-    moveAnchor(ref: VectorAnchorRef, to: Vec2, options?: {
+    moveAnchor(ref: VectorAnchorRef, to: Vec2$1, options?: {
         curvature?: boolean;
     }): VectorActionResult;
     /** `doc` with anchor `ref` moved to document point `to` by a Curvature-tool move. */
@@ -2025,15 +2035,15 @@ declare class VectorEditorController {
      * Bends a segment so the curve passes through document point `to` at parameter `t`
      * (default 0.5, clamped to 0.05–0.95); see `bendSegment` in `pathEdit`.
      */
-    bendSegment(ref: VectorSegmentRef, to: Vec2, t?: number): VectorActionResult;
+    bendSegment(ref: VectorSegmentRef, to: Vec2$1, t?: number): VectorActionResult;
     /** Moves one handle to a document position (see `moveAnchorHandle` for how the opposite handle follows). */
-    moveHandle(ref: VectorHandleRef, to: Vec2, options?: {
+    moveHandle(ref: VectorHandleRef, to: Vec2$1, options?: {
         breakHandles?: boolean;
     }): VectorActionResult;
     /** Converts the selected (or given) anchors between corner, smooth and symmetric. */
     convertAnchors(type: VectorAnchorType, refs?: readonly VectorAnchorRef[]): VectorActionResult;
     /** Adds an anchor on the nearest segment of `nodeId` to document point `point` (shape unchanged). */
-    insertAnchorAt(nodeId: string, point: Vec2): VectorAnchorRef | null;
+    insertAnchorAt(nodeId: string, point: Vec2$1): VectorAnchorRef | null;
     /**
      * Deletes the selected (or given) anchors; subpaths left with one anchor and empty paths go
      * too. With `keepShape` (default: the `keepShapeOnDelete` setting, on) the neighbours'
@@ -2096,7 +2106,7 @@ declare class VectorEditorController {
      * anchor when within the pick distance of one). A closed subpath opens there; an open one
      * splits in two (a one-subpath path becomes two paths). Returns the ids of the paths.
      */
-    cutPathAt(nodeId: string, point: Vec2): string[] | null;
+    cutPathAt(nodeId: string, point: Vec2$1): string[] | null;
     /** Scissors on the selected (or given) anchors: each cuts its subpath there (see `cutPathAt`). */
     cutAtAnchors(refs?: readonly VectorAnchorRef[]): VectorActionResult;
     /** Visible, unlocked paths a stroke over `points` can reach: in `ids`, the selection, or (with neither) any whose bounds it crosses. */
@@ -2109,7 +2119,7 @@ declare class VectorEditorController {
      * selection, or (with neither) every path it crosses. Returns the ids of the pieces (empty
      * when nothing was cut).
      */
-    knife(points: readonly Vec2[], options?: {
+    knife(points: readonly Vec2$1[], options?: {
         ids?: readonly string[];
     }): string[];
     /**
@@ -2119,7 +2129,7 @@ declare class VectorEditorController {
      * the given paths, the selection, or (with neither) every path it reaches. Returns the ids
      * of the paths it changed or created.
      */
-    erase(points: readonly Vec2[], options?: {
+    erase(points: readonly Vec2$1[], options?: {
         ids?: readonly string[];
         size?: number;
     }): string[];
@@ -2133,7 +2143,7 @@ declare class VectorEditorController {
      * Returns the new ids.
      */
     paste(text?: string, options?: {
-        offset?: Vec2;
+        offset?: Vec2$1;
     }): string[];
     undo(): boolean;
     redo(): boolean;
@@ -2171,7 +2181,7 @@ declare class VectorEditorController {
     private nearestOutline;
     private sameHover;
     /** Primary button down on the canvas at `screen` (pixels relative to the canvas). */
-    pointerDown(screen: Vec2, input?: VectorPointerInput): void;
+    pointerDown(screen: Vec2$1, input?: VectorPointerInput): void;
     /** The shape under the pointer for the Blend tool, and the anchor of its first subpath under it. */
     private blendHit;
     /** Blend tool: the first click picks the shape to blend from, the next one blends it into the shape clicked. */
@@ -2182,7 +2192,7 @@ declare class VectorEditorController {
     private downPencil;
     private downShape;
     /** Pointer moved over the canvas (with or without a button down). */
-    pointerMove(screen: Vec2, input?: VectorPointerInput): void;
+    pointerMove(screen: Vec2$1, input?: VectorPointerInput): void;
     /** Snaps a move of the selection by (dx, dy): its bounds line up with targets or space evenly, else go to the grid. */
     private snapMove;
     /** The anchor a point drag snaps by, where it started: the grabbed one, else the moving one nearest the press. */
@@ -2190,7 +2200,7 @@ declare class VectorEditorController {
     /** A shape's dragged corner moved so its width or height matches another object's, when one is within reach. */
     private matchShapeSize;
     /** Primary button released. */
-    pointerUp(screen?: Vec2, input?: VectorPointerInput): void;
+    pointerUp(screen?: Vec2$1, input?: VectorPointerInput): void;
     /** The pointer left the canvas. */
     pointerLeave(): void;
     /** Abandons the drag in progress (Escape, lost capture). */
@@ -2199,7 +2209,7 @@ declare class VectorEditorController {
      * Double click: select tool enters path editing, direct tool toggles an anchor or adds one,
      * width tool opens the width-point editor (`widthPointEdit`).
      */
-    doubleClick(screen: Vec2): void;
+    doubleClick(screen: Vec2$1): void;
     /**
      * Handles editor shortcuts. Returns true when the key was used (call `preventDefault`).
      * Do not forward keys typed into text inputs.
@@ -2208,10 +2218,10 @@ declare class VectorEditorController {
     keyUp(input: VectorKeyInput): void;
 }
 /** Scale factors and origin for dragging a selection-box handle to `p`. */
-declare function scaleFor(handle: VectorTransformHandle, b: VectorBounds, p: Vec2, mods?: VectorModifiers): {
+declare function scaleFor(handle: VectorTransformHandle, b: VectorBounds, p: Vec2$1, mods?: VectorModifiers): {
     sx: number;
     sy: number;
-    origin: Vec2;
+    origin: Vec2$1;
 };
 
 interface VectorRenderPath {
@@ -2300,8 +2310,8 @@ interface VectorRenderWidthPoint {
     ref: VectorWidthPointRef;
     x: number;
     y: number;
-    left: Vec2;
-    right: Vec2;
+    left: Vec2$1;
+    right: Vec2$1;
     selected: boolean;
     /** The part under the pointer, if any. */
     hovered: 'center' | 'left' | 'right' | null;
@@ -2338,7 +2348,7 @@ interface VectorOverlayRenderData {
     selectionBox: (VectorBounds & {
         angle: number;
         transform: string;
-        corners: Vec2[];
+        corners: Vec2$1[];
         handles: VectorSelectionBoxGeometry['handles'];
         freeDistort: boolean;
     }) | null;
@@ -2349,7 +2359,7 @@ interface VectorOverlayRenderData {
     distort: {
         mode: 'distort' | 'perspective' | 'skew';
         d: string;
-        corners: Vec2[];
+        corners: Vec2$1[];
     } | null;
     /**
      * The Envelope tool's mesh of the selected envelope (screen space): `grid` is the grid lines as
@@ -2407,7 +2417,7 @@ interface VectorOverlayRenderData {
         y2: number;
     } | null;
     /** Where the scissors would cut (screen space). */
-    cutPoint: Vec2 | null;
+    cutPoint: Vec2$1 | null;
     /**
      * Live corner widgets of the direct tool (screen space): drag one to round its corners,
      * Alt-click to cycle round / inverted / chamfer, click to pick its corner alone.
@@ -2422,8 +2432,8 @@ interface VectorOverlayRenderData {
     widthSpot: {
         x: number;
         y: number;
-        left: Vec2;
-        right: Vec2;
+        left: Vec2$1;
+        right: Vec2$1;
     } | null;
     /**
      * Shape Builder and paint bucket highlight (screen space): `faces` are filled paths (fill
@@ -2450,12 +2460,12 @@ interface VectorOverlayRenderData {
         spines: {
             id: string;
             d: string;
-            keys: Vec2[];
+            keys: Vec2$1[];
             replaced: boolean;
         }[];
         start: {
             d: string;
-            anchor: Vec2 | null;
+            anchor: Vec2$1 | null;
         } | null;
         anchors: {
             x: number;
@@ -2858,9 +2868,9 @@ declare function removeAnchorsKeepingShape(sp: VectorSubpath, indices: readonly
  * `B(t) = L(t) + 3t(1 − t)·offset` exactly. The end anchors keep their types (a smooth or
  * symmetric end turns its other handle to stay in line).
  */
-declare function bendSegment(sp: VectorSubpath, segment: number, t: number, p: Vec2): VectorSubpath;
+declare function bendSegment(sp: VectorSubpath, segment: number, t: number, p: Vec2$1): VectorSubpath;
 /** The point at parameter `t` of segment `segment` (for tests and previews). */
-declare function subpathPointAt(sp: VectorSubpath, segment: number, t: number): Vec2;
+declare function subpathPointAt(sp: VectorSubpath, segment: number, t: number): Vec2$1;
 /**
  * Moves anchor `index` to `q` the way the Curvature tool drags a point: only the two segments
  * at it change. A smooth or symmetric anchor turns its handles along the line through its
@@ -2868,7 +2878,7 @@ declare function subpathPointAt(sp: VectorSubpath, segment: number, t: number):
  * their directions while their lengths scale with their segment's chord, so the segments
  * beyond don't move and a corner without handles keeps none.
  */
-declare function curvatureMoveAnchor(sp: VectorSubpath, index: number, q: Vec2): VectorSubpath;
+declare function curvatureMoveAnchor(sp: VectorSubpath, index: number, q: Vec2$1): VectorSubpath;
 /**
  * Cuts a subpath at the anchors `at`: each becomes the end of one open piece and the start of
  * the next, its handle off each piece dropped (the shape doesn't change). A closed subpath
@@ -3024,9 +3034,9 @@ declare function recognizeInkShape(points: readonly Point[], options?: Recognize
 interface VectorArrowheadShape {
     end: 'start' | 'end';
     kind: VectorArrowhead;
-    tip: Vec2;
+    tip: Vec2$1;
     /** Unit direction the head points in. */
-    dir: Vec2;
+    dir: Vec2$1;
     /** Distance from the tip back to where the stroke ends under the head. */
     inset: number;
     path: BezierPath;
@@ -3064,7 +3074,7 @@ declare function arrowheadWeight(style: VectorStyle, end: 'start' | 'end'): numb
 /** Distance from the tip where the stroke ends, for a stroke whose cap reaches `cap` past its end. */
 declare function arrowheadInset(kind: VectorArrowhead, hw: number, cap: number): number;
 /** The outline of a `kind` head of weight `hw` with its tip at `tip`, pointing along unit `dir`. */
-declare function arrowheadPath(kind: VectorArrowhead, tip: Vec2, dir: Vec2, hw: number): BezierPath;
+declare function arrowheadPath(kind: VectorArrowhead, tip: Vec2$1, dir: Vec2$1, hw: number): BezierPath;
 /**
  * The stroke of `path` as `style` draws it: its alignment, the line it follows (shortened under
  * `tip`-aligned heads) and its arrowheads. Heads go on the start of the first subpath and the
@@ -3082,7 +3092,7 @@ declare function vectorStrokeOutlinePath(path: BezierPath, style: VectorStyle):
  * the width of the outline for a centred stroke, within the whole width on the inside or the
  * outside of the fill for an aligned one, or on an arrowhead.
  */
-declare function hitTestVectorStroke(path: BezierPath, p: Vec2, style: VectorStyle, tolerance?: number): boolean;
+declare function hitTestVectorStroke(path: BezierPath, p: Vec2$1, style: VectorStyle, tolerance?: number): boolean;
 /** How far the stroke can reach past the outline (for padding bounds and masks). */
 declare function vectorStrokeReach(style: VectorStyle): number;
 
@@ -3166,7 +3176,7 @@ declare function strokePositionPoint(path: BezierPath, index: number, t: number)
 /** A path node with the matrix of its parent space (parent → document). */
 interface VectorPathEntry {
     node: VectorPathNode;
-    parent: AffineMatrix;
+    parent: AffineMatrix$1;
 }
 /**
  * The path nodes inside `roots` (or every node when `roots` is null), bottom to top, with their
@@ -3245,9 +3255,9 @@ declare function vectorShapeBuilderMap(entries: readonly VectorPathEntry[]): Vec
  * The face under `p`, or with `lineTolerance` (erasing) first the nearer of the line piece and
  * the outline edge that close.
  */
-declare function vectorShapeBuilderHit(m: VectorShapeBuilderMap, p: Vec2, lineTolerance?: number | null): VectorBuilderHit | null;
+declare function vectorShapeBuilderHit(m: VectorShapeBuilderMap, p: Vec2$1, 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[];
+declare function samplePolyline(points: readonly Vec2$1[], step: number): Vec2$1[];
 /** Adds what a point hits to `touched` (each face or piece once). */
 declare function addBuilderHit(touched: VectorBuilderTouched, hit: VectorBuilderHit | null): boolean;
 /**
@@ -3358,9 +3368,9 @@ interface VectorMorphContour {
     pts: Point[];
 }
 /** A subpath mapped by `m` as cubics (lines with handles at thirds), or null when empty. */
-declare function subpathToMorphContour(sp: VectorSubpath, m?: AffineMatrix): VectorMorphContour | null;
+declare function subpathToMorphContour(sp: VectorSubpath, m?: AffineMatrix$1): VectorMorphContour | null;
 /** A contour back to a subpath (`m` maps it out of the morph's space). Straight cubics become lines. */
-declare function morphContourToSubpath(c: VectorMorphContour, m?: AffineMatrix, closed?: boolean): VectorSubpath;
+declare function morphContourToSubpath(c: VectorMorphContour, m?: AffineMatrix$1, closed?: boolean): VectorSubpath;
 /**
  * Exactly the same outline with `segments` cubics (at least as many as it has), the new
  * anchors spread over its segments in proportion to their arc length (largest remainder)
@@ -3411,7 +3421,7 @@ declare function interpolateMorphContours(a: readonly VectorMorphContour[], b: r
  * Interpolates two rigid matrices as a rotation (the shorter way round) plus a translation.
  * Any scale or skew is interpolated linearly in the rotated frame.
  */
-declare function interpolateRigidMatrix(a: AffineMatrix, b: AffineMatrix, t: number): AffineMatrix;
+declare function interpolateRigidMatrix(a: AffineMatrix$1, b: AffineMatrix$1, t: number): AffineMatrix$1;
 /** Two colours mixed in OKLab (premultiplied alpha); unreadable colours switch halfway. */
 declare function interpolateVectorColor(a: string, b: string, t: number): string;
 /**
@@ -3572,7 +3582,7 @@ declare function offsetPaths(paths: readonly BezierPath[], amount: number, join?
  * 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[];
+declare function twistPaths(paths: readonly BezierPath[], angle: number, center: Vec2$1): 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.
@@ -3592,7 +3602,7 @@ declare function mergePaths(paths: readonly BezierPath[], mode?: VectorMergeMode
 interface VectorRepeaterCopy {
     /** Copy number (0 is the original). */
     index: number;
-    matrix: AffineMatrix;
+    matrix: AffineMatrix$1;
     opacity: number;
 }
 /**
@@ -3601,14 +3611,14 @@ interface VectorRepeaterCopy {
  * `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[];
+declare function vectorRepeaterCopies(r: VectorEffectParamsMap['repeater'], pivot: Vec2$1): VectorRepeaterCopy[];
 /** Each path repeated by `vectorRepeaterCopies` (copy order, the original first). */
-declare function repeatPaths(paths: readonly BezierPath[], r: VectorEffectParamsMap['repeater'], pivot: Vec2): {
+declare function repeatPaths(paths: readonly BezierPath[], r: VectorEffectParamsMap['repeater'], pivot: Vec2$1): {
     copy: VectorRepeaterCopy;
     paths: BezierPath[];
 }[];
 /** The middle of the paths' bounds (the origin when they are empty). */
-declare function pathsCenter(paths: readonly BezierPath[]): Vec2;
+declare function pathsCenter(paths: readonly BezierPath[]): Vec2$1;
 
 /**
  * The paint server of a gradient along or across the stroke of `node` (in its own space): a
@@ -3621,140 +3631,6 @@ declare function vectorStrokeGradientDefs(g: VectorGradient, id: string, node: V
     precision?: number;
 }): VectorPaintDef[];
 
-/**
- * Perspective (projective) maps between quadrilaterals: what Free Distort needs. Pure maths;
- * degenerate or non-finite quads give `null` instead of NaNs.
- *
- * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
- * THIRD_PARTY_NOTICES.md): pdfcraft `crates/geom/src/perspective.rs` (`Homography::from_points`,
- * `Homography::apply`, `solve8`, `order_quad`).
- */
-
-/** A 3×3 projective map, row-major, normalised so that the last entry is 1. */
-type VectorHomography = readonly [number, number, number, number, number, number, number, number, number];
-/**
- * Gaussian elimination with partial pivoting on an 8×8 system (the 9th column of each row is the
- * right-hand side). Null when the system is singular.
- */
-declare function solve8(rows: readonly (readonly number[])[]): number[] | null;
-/** The image of `p`, or null where the map sends it to infinity. */
-declare function applyVectorHomography(h: VectorHomography, p: Vec2): Vec2 | null;
-/**
- * The projective map that takes each of `from` to the point at the same index of `to`. Null when
- * three of either set are collinear or a coordinate is not finite.
- */
-declare function vectorHomography(from: readonly Vec2[], to: readonly Vec2[]): VectorHomography | null;
-/**
- * Whether `h` maps the whole convex quad `quad` without sending any of it through infinity (the
- * denominator keeps one sign over it): what a usable distortion needs.
- */
-declare function vectorHomographyKeepsQuad(h: VectorHomography, quad: readonly Vec2[]): boolean;
-/**
- * The four corners in reading order for a y-down space: top-left, top-right, bottom-right,
- * bottom-left, whatever order they come in. Null unless they form a convex quadrilateral with a
- * non-negligible area.
- */
-declare function orderVectorQuad(points: readonly Vec2[]): Vec2[] | null;
-
-/**
- * Warp geometry for envelope distortion: preset warp styles and editable Bézier meshes, both
- * forward maps from a source box (the bounds of the paths an envelope bends) to the node's space.
- *
- * - **Presets** (`VectorWarpStyle`, Photoshop's fifteen with bend and horizontal / vertical
- *   distortion in percent): each is one bicubic Bézier patch whose 4 × 4 control grid follows the
- *   bend (`vectorWarpPresetGrid`). Every preset is the identity at bend 0 and continuous in it.
- * - **Meshes** (`VectorWarpMesh`): a grid of bicubic patches. Splitting a mesh (`splitVectorMeshU`
- *   / `V`) is an exact de Casteljau subdivision, so it never changes the shape, and a preset turns
- *   into an editable mesh of any size exactly.
- *
- * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
- * THIRD_PARTY_NOTICES.md): photocraft `crates/geom/src/warp.rs` (`WarpStyle`, `StyleWarp`,
- * `rest_grid`, `edge_arc`, `arc_grid`, `blend_rows`, `preset_grid`, `bernstein`, `split_cubic`,
- * `BERN_INV`, and `BezierMesh`: `identity`, `fit`, `eval`, `split_u`, `split_v`, `remove_split_u`,
- * `transpose`, `map_points`, `param_at`, `pull`, `smooth_lines`, `drag_point`, `control_bounds`;
- * `Warp::map` and `Warp::to_mesh`). The Coons patch of `vectorMeshFromOutline` is our own.
- */
-
-/** The fifteen presets in Photoshop's menu order. */
-declare const VECTOR_WARP_STYLES: readonly VectorWarpStyle[];
-declare const VECTOR_WARP_STYLE_LABELS: Readonly<Record<VectorWarpStyle, string>>;
-/**
- * A preset as a Bézier control grid (rows of `[x, y]` in box units, y down). `b`, `hd`, `vd` are
- * the bend and the horizontal / vertical distortion as fractions (−1…1); `aspect` is the box's
- * height over its width. The arc family stays circular in pixels, the other offsets scale with the
- * box, and a vertical warp is the horizontal one with the axes (and distortions) swapped.
- */
-declare function vectorWarpPresetGrid(style: VectorWarpStyle, b: number, hd: number, vd: number, vertical: boolean, aspect: number): [number, number][][];
-/** A preset warp's settings (bend and distortions in percent, −100…100). */
-interface VectorWarpPreset {
-    style: VectorWarpStyle;
-    bend: number;
-    horizontal?: number;
-    vertical?: number;
-    /** Bend along the vertical axis. */
-    orientation?: 'horizontal' | 'vertical';
-}
-/**
- * A preset as one Bézier patch over `bounds` (points in the bounds' space), or null when it
- * changes nothing (an unknown style, all-zero amounts, or an empty box).
- */
-declare function vectorWarpPresetMesh(preset: VectorWarpPreset, bounds: VectorBounds): VectorWarpMesh | null;
-/** Control points per row. */
-declare const vectorMeshColumns: (m: VectorWarpMesh) => number;
-/** Control point rows. */
-declare const vectorMeshRows: (m: VectorWarpMesh) => number;
-/** Whether a mesh is well formed: knots from 0 to 1 increasing, the right number of finite points. */
-declare function isValidVectorMesh(m: unknown): m is VectorWarpMesh;
-/** Fits a mesh with patch boundaries `us` / `vs` to the map `f` (box fractions → output) by interpolating it at each patch's thirds. Exact for bicubic maps (affine maps included). */
-declare function fitVectorMesh(f: (s: number, t: number) => Vec2, us: readonly number[], vs: readonly number[]): VectorWarpMesh;
-/** The identity mesh over `bounds` with `columns × rows` patches. */
-declare function vectorIdentityMesh(bounds: VectorBounds, columns?: number, rows?: number): VectorWarpMesh;
-/** The surface at box fractions `(s, t)`. */
-declare function evalVectorMesh(m: VectorWarpMesh, s: number, t: number): Vec2;
-/** The mesh with the patch column holding `s` split at `s` (exact). Null when `s` is on or too close to a boundary. */
-declare function splitVectorMeshU(m: VectorWarpMesh, s: number): VectorWarpMesh | null;
-/** The mesh with the patch row holding `t` split at `t` (exact). */
-declare function splitVectorMeshV(m: VectorWarpMesh, t: number): VectorWarpMesh | null;
-/**
- * The mesh without interior vertical boundary `k` (1 … us.length − 2), its two patch columns
- * merged: exact when they came from an unedited split; otherwise the outer control points stay and
- * the inner handles are extrapolated.
- */
-declare function removeVectorMeshSplitU(m: VectorWarpMesh, k: number): VectorWarpMesh | null;
-/** Removes interior horizontal boundary `k`. */
-declare function removeVectorMeshSplitV(m: VectorWarpMesh, k: number): VectorWarpMesh | null;
-/** Every control point through `f` (exact for affine maps). */
-declare function mapVectorMeshPoints(m: VectorWarpMesh, f: (p: Vec2) => Vec2): VectorWarpMesh;
-/**
- * The mesh with `columns × rows` patches over the same surface: split exactly when its knots are
- * a subset of the new even ones (a one-patch mesh always is), otherwise refitted.
- */
-declare function resizeVectorMesh(m: VectorWarpMesh, columns: number, rows: number): VectorWarpMesh;
-/** Bounding box of the control points (the surface lies inside it). */
-declare function vectorMeshControlBounds(m: VectorWarpMesh): VectorBounds;
-/** Box fractions `(s, t)` whose surface point is nearest `p` (a coarse search, then Newton steps). */
-declare function vectorMeshParamAt(m: VectorWarpMesh, p: Vec2): {
-    s: number;
-    t: number;
-    distance: number;
-};
-/**
- * `base` with control point `index` dragged by `d`, keeping the surface smooth across the grid
- * lines: an anchor moves with the eight points around it as one block; a handle moves with the two
- * points beside it across its line, and the handle opposite it on the same anchor turns the other
- * way (with its two neighbours), so the line keeps passing straight through the anchor. An inner
- * point of a patch moves alone.
- */
-declare function dragVectorMeshPoint(base: VectorWarpMesh, index: number, d: Vec2): VectorWarpMesh;
-/**
- * `base` with its surface point at box fractions `(s, t)` pulled by `d`, the way dragging inside a
- * patch works: interior anchors within about two cells follow by a share of `d` that fades with
- * distance (each with its block of handles, so grid lines stay smooth); the outer border stays
- * pinned unless the grab is near it, and then it bows; the four corners never move. The grabbed
- * patch's inner points (and, near the border, the border's handles) make up the rest, so the
- * grabbed point lands exactly at its start + `d`.
- */
-declare function pullVectorMesh(base: VectorWarpMesh, s: number, t: number, d: Vec2): VectorWarpMesh;
 /**
  * A mesh whose border follows a closed outline (Illustrator's Make with Top Object): the outline is
  * cut into four sides at the points nearest its bounding box's corners, and the interior is the
@@ -3764,19 +3640,5 @@ declare function pullVectorMesh(base: VectorWarpMesh, s: number, t: number, d: V
 declare function vectorMeshFromOutline(sp: VectorSubpath, columns?: number, rows?: number): VectorWarpMesh | null;
 /** The mesh's border as one closed subpath (clockwise from the top-left corner): what Release gives back as the envelope's shape. */
 declare function vectorMeshOutline(m: VectorWarpMesh): VectorSubpath;
-/**
- * The control points an editor shows: the anchors (where grid lines cross) and the handles along
- * the grid lines, each with the anchor it belongs to. Points inside a patch are left out (drag
- * inside a patch to pull the surface instead).
- */
-declare function vectorMeshEditPoints(m: VectorWarpMesh): {
-    anchors: number[];
-    handles: {
-        index: number;
-        anchor: number;
-    }[];
-};
-/** The mesh's grid lines (patch borders) as cubics `[p0, p1, p2, p3]`. */
-declare function vectorMeshGridCurves(m: VectorWarpMesh): 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 MapVectorSubpathsOptions, type NearestSegment, type RecognizeInkOptions, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_DISTORT_TOLERANCE, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_ENVELOPE_STYLE_OPTIONS, VECTOR_FILL_GAP, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_WARP_STYLES, VECTOR_WARP_STYLE_LABELS, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, Vec2, type VectorActionResult, VectorAlign, VectorAnchor, VectorAnchorRef, VectorAnchorType, type VectorAppearanceShape, VectorArrange, VectorArrowAlign, VectorArrowhead, type VectorArrowheadShape, VectorAverageAxis, VectorBlend, type VectorBlendControls, type VectorBlendInput, VectorBlendOptions, type VectorBlendRail, VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperand, VectorBooleanOperation, VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCornerInfo, VectorCornerKind, type VectorCornerWidget, VectorDefaults, type VectorDistortMode, VectorDistribute, VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, VectorEffect, type VectorEffectParamSpec, VectorEffectParamsMap, VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorEnvelopePanelData, type VectorEnvelopeParams, VectorFillRule, VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, VectorGradientHandle, VectorGradientInterpolation, type VectorGradientPart, VectorGradientPatch, VectorGradientSpread, VectorGradientStop, type VectorGradientTarget, VectorGradientType, VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, VectorHandleRef, type VectorHitTestOptions, type VectorHomography, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, VectorLineJoin, VectorMergeMode, VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, VectorNode, type VectorNodeListing, type VectorOverlayRenderData, VectorPaint, VectorPaintDef, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, VectorPathNode, type VectorPathfinderAction, VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointMap, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorScaleSnap, type VectorSceneRenderData, 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, VectorStrokeAlign, VectorStrokeGradientMode, type VectorStrokeParts, type VectorStrokeSpot, VectorStyle, VectorSubpath, VectorSvgExportOptions, type VectorTaperOptions, VectorTool, VectorTransformHandle, VectorViewport, VectorWarpMesh, type VectorWarpPreset, VectorWarpStyle, type VectorWaveOptions, type VectorWidthHandle, VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorEffects, applyVectorHomography, 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, distortVectorNode, dragVectorMeshPoint, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evalVectorMesh, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, fitVectorMesh, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorEnvelopePanel, getVectorEnvelopeTarget, getVectorGradientAnnotator, getVectorGradientEditor, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isValidVectorMesh, isVectorBlendGroup, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, mapBezierPath, mapVectorMeshPoints, mapVectorPoints, mapVectorSubpaths, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, orderVectorQuad, pathsCenter, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, pullVectorMesh, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeVectorMeshSplitU, removeVectorMeshSplitV, removeWidthPoints, repeatPaths, resampleGradientStops, resizeVectorMesh, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePolyline, sanitizeVectorEffects, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, solve8, splitIntoFaces, splitSubpathAt, splitVectorMeshU, splitVectorMeshV, 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, vectorBoxCorners, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorDiamondPath, vectorDistortQuad, vectorEffectInputBounds, vectorEffectInputPaths, vectorEnteredGroups, vectorEnvelopeFrame, vectorEnvelopeMap, vectorEnvelopeMesh, vectorFillMap, vectorGradientBarPosition, vectorGradientTargetPath, vectorHomography, vectorHomographyKeepsQuad, vectorIdentityMesh, vectorInkShapeName, vectorLiveBooleanSteps, vectorMeshColumns, vectorMeshControlBounds, vectorMeshEditPoints, vectorMeshFromOutline, vectorMeshGridCurves, vectorMeshOutline, vectorMeshParamAt, vectorMeshRows, vectorNodeBounds, vectorNodeEnvelope, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorShearForSide, vectorSkewMatrix, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeWidthGeometry, vectorToolLabel, vectorWarpPresetGrid, vectorWarpPresetMesh, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, wigglePaths, zigzagPaths };
+export { type AddVectorNodeOptions, AffineMatrix$1 as AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type MapVectorSubpathsOptions, type NearestSegment, type RecognizeInkOptions, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_DISTORT_TOLERANCE, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_ENVELOPE_STYLE_OPTIONS, VECTOR_FILL_GAP, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, Vec2$1 as Vec2, type VectorActionResult, VectorAlign, VectorAnchor, VectorAnchorRef, VectorAnchorType, type VectorAppearanceShape, VectorArrange, VectorArrowAlign, VectorArrowhead, type VectorArrowheadShape, VectorAverageAxis, VectorBlend, type VectorBlendControls, type VectorBlendInput, VectorBlendOptions, type VectorBlendRail, VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperand, VectorBooleanOperation, VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCornerInfo, VectorCornerKind, type VectorCornerWidget, VectorDefaults, type VectorDistortMode, VectorDistribute, VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, VectorEffect, type VectorEffectParamSpec, VectorEffectParamsMap, VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorEnvelopePanelData, type VectorEnvelopeParams, VectorFillRule, VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, VectorGradientHandle, VectorGradientInterpolation, type VectorGradientPart, VectorGradientPatch, VectorGradientSpread, VectorGradientStop, type VectorGradientTarget, VectorGradientType, VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, VectorHandleRef, type VectorHitTestOptions, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, VectorLineJoin, VectorMergeMode, VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, VectorNode, type VectorNodeListing, type VectorOverlayRenderData, VectorPaint, VectorPaintDef, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, VectorPathNode, type VectorPathfinderAction, VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointMap, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorScaleSnap, type VectorSceneRenderData, 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, VectorStrokeAlign, VectorStrokeGradientMode, type VectorStrokeParts, type VectorStrokeSpot, VectorStyle, VectorSubpath, VectorSvgExportOptions, type VectorTaperOptions, VectorTool, VectorTransformHandle, VectorViewport, VectorWarpMesh, type VectorWaveOptions, type VectorWidthHandle, VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, 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, distortVectorNode, 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, getVectorEnvelopePanel, getVectorEnvelopeTarget, getVectorGradientAnnotator, getVectorGradientEditor, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorBlendGroup, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, mapBezierPath, mapVectorPoints, mapVectorSubpaths, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, 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, vectorBoxCorners, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorDiamondPath, vectorDistortQuad, vectorEffectInputBounds, vectorEffectInputPaths, vectorEnteredGroups, vectorEnvelopeFrame, vectorEnvelopeMap, vectorEnvelopeMesh, vectorFillMap, vectorGradientBarPosition, vectorGradientTargetPath, vectorInkShapeName, vectorLiveBooleanSteps, vectorMeshFromOutline, vectorMeshOutline, vectorNodeBounds, vectorNodeEnvelope, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorShearForSide, vectorSkewMatrix, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, wigglePaths, zigzagPaths };