@pixerate/editor 0.108.0 → 0.110.0

package/dist/{svg-SseJTIrA.d.ts → svg-D_cfkhlB.d.cts}

@@ -1,631 +1,5 @@
-import { C as CanvasGradientDef, B as BezierPath, A as AffineMatrix, S as SvgGradientDef } from './bezier-DYBvLgUH.js';
-import { W as WarpStyle, a as WarpMesh } from './types-CwMPoRMU.js';
-
-/** An affine matrix `[a, b, c, d, e, f]`: `x' = a·x + c·y + e`, `y' = b·x + d·y + f` (SVG order). */
-type VectorMatrix = readonly [number, number, number, number, number, number];
-/** A point in document coordinates. */
-interface Vec2 {
-    x: number;
-    y: number;
-}
-/**
- * How an anchor's handles relate:
- * - `corner`: handles move independently (or are absent).
- * - `smooth`: handles stay on one line through the anchor, lengths independent.
- * - `symmetric`: handles stay on one line with equal lengths.
- */
-type VectorAnchorType = 'corner' | 'smooth' | 'symmetric';
-/**
- * Live corner shapes: `round` (an arc tangent to both sides), `inverted` (an arc centred on
- * the corner, cut into the shape) and `chamfer` (a straight bevel).
- */
-type VectorCornerKind = 'round' | 'inverted' | 'chamfer';
-declare const VECTOR_CORNER_KINDS: readonly VectorCornerKind[];
-/**
- * A live corner: drawn rounded (or cut) at render, hit-test, bounds, boolean, outline and export
- * time while the stored anchor stays sharp. The radius shrinks to fit when the sides are short:
- * the cut reaches at most halfway along each side.
- */
-interface VectorCorner {
-    radius: number;
-    /** Default `round`. */
-    kind?: VectorCornerKind;
-}
-/**
- * One anchor of a subpath. Handles are absolute document positions; a missing (or `null`)
- * handle sits on the anchor, so a segment with no handles at either end is a straight line.
- */
-interface VectorAnchor {
-    x: number;
-    y: number;
-    /** Control point of the segment arriving at this anchor. */
-    in?: Vec2 | null;
-    /** Control point of the segment leaving this anchor. */
-    out?: Vec2 | null;
-    /** Default `corner`. */
-    type?: VectorAnchorType;
-    /** Live corner radius. Ignored on smooth / symmetric anchors and the ends of open subpaths. */
-    corner?: VectorCorner | null;
-}
-/** A chain of anchors joined by line or cubic Bézier segments. */
-interface VectorSubpath {
-    anchors: VectorAnchor[];
-    /** Joins the last anchor back to the first. */
-    closed: boolean;
-}
-/**
- * Gradient styles: `linear` (start → end), `radial` (centred on the start, reaching the end;
- * focal point and aspect), `conic` (an angle sweep around the start, from the end's direction
- * towards the aspect handle's: clockwise on screen), `reflected` (linear mirrored about the
- * start) and `diamond` (`|u| + |v|` in the gradient's frame: a rhombus through the end and the
- * aspect handle).
- */
-type VectorGradientType = 'linear' | 'radial' | 'conic' | 'reflected' | 'diamond';
-declare const VECTOR_GRADIENT_TYPES: readonly VectorGradientType[];
-/** What a gradient paints past its ends: the end colours, mirrored periods or repeated periods. */
-type VectorGradientSpread = 'pad' | 'reflect' | 'repeat';
-declare const VECTOR_GRADIENT_SPREADS: readonly VectorGradientSpread[];
-/** Where colours mix between stops: sRGB (SVG's own), linear light or Oklab. */
-type VectorGradientInterpolation = 'srgb' | 'linear' | 'oklab';
-declare const VECTOR_GRADIENT_INTERPOLATIONS: readonly VectorGradientInterpolation[];
-/**
- * The space a gradient's points are in: fractions of the shape's bounding box (SVG's
- * `objectBoundingBox`, the default) or the node's own coordinates (`userSpaceOnUse`).
- */
-type VectorGradientUnits = 'objectBoundingBox' | 'userSpaceOnUse';
-/**
- * How a gradient lies on a stroke: `within` (laid over the stroke's area like a fill), `along`
- * (t runs from 0 at the start of each subpath to 1 at its end) or `across` (from the stroke's
- * left edge to its right edge, looking along the path).
- */
-type VectorStrokeGradientMode = 'within' | 'along' | 'across';
-declare const VECTOR_STROKE_GRADIENT_MODES: readonly VectorStrokeGradientMode[];
-/** A colour stop. `opacity` multiplies the colour's own alpha. */
-interface VectorGradientStop {
-    /** 0–1. */
-    offset: number;
-    color: string;
-    /** 0–1, default 1. */
-    opacity?: number;
-    /**
-     * Where, between this stop and the next (0–1 of the way), the colour is half-way between
-     * them. Default 0.5 (an even mix).
-     */
-    midpoint?: number;
-}
-/**
- * A gradient paint. `CanvasGradientDef` (the canvas package's linear `angle` / radial
- * `cx, cy, r` gradients) is a valid value: those fields are the shorthand form. Explicit
- * geometry (`start` / `end`, in `units`) wins over the shorthand.
- */
-interface VectorGradient {
-    type: VectorGradientType;
-    stops: VectorGradientStop[];
-    /**
-     * Shorthand direction in degrees, CSS style (0 points up, clockwise): a linear or reflected
-     * gradient's direction across the box (default 180), a conic gradient's start angle or a
-     * diamond's turn (default 90).
-     */
-    angle?: number;
-    /** Shorthand centre and radius of radial, conic and diamond gradients (fractions of the box, default 0.5). */
-    cx?: number;
-    cy?: number;
-    r?: number;
-    /** Where t = 0: a linear gradient's start, the centre of the other styles. */
-    start?: Vec2;
-    /** Where t = 1 along the gradient's main axis (a radial gradient's radius). */
-    end?: Vec2;
-    /**
-     * The end of the secondary axis (radial, conic and diamond): its distance from `start` over
-     * the main axis' length is the aspect ratio. Absent: square to the main axis, as long.
-     */
-    width?: Vec2 | null;
-    /** A radial gradient's focal point (where t = 0); absent: the centre. */
-    focal?: Vec2 | null;
-    /** Radius of the focal circle as a fraction of the radius (SVG `fr`, default 0). */
-    focalRadius?: number;
-    /** Space of `start`, `end`, `width` and `focal` (default `objectBoundingBox`). */
-    units?: VectorGradientUnits;
-    /** Default `pad`. */
-    spread?: VectorGradientSpread;
-    /** Default `srgb`. */
-    interpolation?: VectorGradientInterpolation;
-    /**
-     * 0–1: how far the colours follow a smooth spline through the stops instead of straight
-     * lines (Photoshop's Smoothness). Default 0.
-     */
-    smoothness?: number;
-    /** On a stroke: how the gradient lies on it (default `within`). Ignored on fills. */
-    strokeMode?: VectorStrokeGradientMode;
-}
-/** A fill or stroke: any CSS colour, a gradient, or `null` / `'none'` for no paint. */
-type VectorPaint = string | VectorGradient | CanvasGradientDef | null;
-type VectorFillRule = 'nonzero' | 'evenodd';
-type VectorLineCap = 'butt' | 'round' | 'square';
-type VectorLineJoin = 'miter' | 'round' | 'bevel';
-/**
- * Where the stroke sits on the outline: centred on it, inside the shape or outside it. Only
- * shapes whose subpaths are all closed have an inside; open paths always stroke centred.
- */
-type VectorStrokeAlign = 'center' | 'inside' | 'outside';
-/** Arrowheads and end markers for the ends of open paths. */
-type VectorArrowhead = 'triangle' | 'arrow' | 'open' | 'circle' | 'square' | 'bar';
-declare const VECTOR_ARROWHEADS: readonly VectorArrowhead[];
-/**
- * `extend`: the head's tip sits past the end point and the path keeps its length; `tip`: the
- * 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;
-}
-/**
- * Blend modes of paint layers and nodes: the set SVG and CSS `mix-blend-mode` draw, named as the
- * image editor names them (`@pixerate/editor/image-editor` `BlendMode`). `linear-dodge` draws as
- * CSS `plus-lighter`. The image editor's other modes (linear burn, vivid light, pigment, …) have
- * no SVG equivalent and are not offered.
- */
-type VectorBlendMode = 'normal' | 'darken' | 'multiply' | 'color-burn' | 'lighten' | 'screen' | 'color-dodge' | 'linear-dodge' | 'overlay' | 'soft-light' | 'hard-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';
-/** Every vector blend mode, in the image editor's (Photoshop's) menu order. */
-declare const VECTOR_BLEND_MODES: readonly VectorBlendMode[];
-/** One fill of a path's fill stack (`VectorStyle.fills`). */
-interface VectorPaintLayer {
-    /** A colour, a gradient, or `null` for none. */
-    paint: VectorPaint;
-    /** 0–1, default 1. Multiplies the paint's own alpha. */
-    opacity?: number;
-    /** How the layer mixes with what is under it (the layers below, then the backdrop). Default `normal`. */
-    blendMode?: VectorBlendMode;
-    /** Hidden layers are kept but not drawn or hit. Default true. */
-    visible?: boolean;
-}
-/** The settings each stroke layer has of its own (the stroke shorthand fields of `VectorStyle`). */
-type VectorStrokeSettings = Pick<VectorStyle, 'strokeWidth' | 'strokeLinecap' | 'strokeLinejoin' | 'strokeDasharray' | 'strokeAlign' | 'startArrow' | 'endArrow' | 'arrowAlign' | 'startArrowScale' | 'endArrowScale' | 'strokeWidthProfile'>;
-/**
- * What a stroke layer draws. Only `paint` (a paint along the outline, the default) exists today.
- * Other kinds are the extension point for strokes drawn some other way, such as a raster
- * brushstroke from `@pixerate/editor/paint` laid along the path: a layer with an unknown kind is
- * kept through edits, load and SVG round trips, listed to agents, and skipped when drawing and
- * hit-testing.
- */
-type VectorStrokeLayerKind = 'paint';
-/** One stroke of a path's stroke stack (`VectorStyle.strokes`): a paint plus its own stroke settings. */
-interface VectorStrokeLayer extends VectorPaintLayer, VectorStrokeSettings {
-    /** Default `paint`. See `VectorStrokeLayerKind`. */
-    kind?: VectorStrokeLayerKind;
-}
-/** Paint and stroke settings of a path. */
-interface VectorStyle {
-    fill?: VectorPaint;
-    stroke?: VectorPaint;
-    /** Default 1. */
-    strokeWidth?: number;
-    strokeLinecap?: VectorLineCap;
-    strokeLinejoin?: VectorLineJoin;
-    strokeDasharray?: number[];
-    /** Default `nonzero`. */
-    fillRule?: VectorFillRule;
-    /** Default `center`. */
-    strokeAlign?: VectorStrokeAlign;
-    /** Head at the start of the first subpath when it is open, or none. */
-    startArrow?: VectorArrowhead | null;
-    /** Head at the end of the last subpath when it is open, or none. */
-    endArrow?: VectorArrowhead | null;
-    /** Default `extend`. */
-    arrowAlign?: VectorArrowAlign;
-    /** Size of the start head as a multiple of the stroke width (default 1: a head 4 widths long). */
-    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;
-    /**
-     * The fill stack, bottom to top. Absent: `fill` alone is the stack (one layer, or none without
-     * a paint). Present: it is the truth, and `fill` mirrors its top layer's paint. The shorthand
-     * stays writable: setting `fill` to a paint repaints the top layer, `null` clears the stack.
-     * Stacks of one plain layer (full opacity, `normal`, visible) are stored as the shorthand.
-     */
-    fills?: VectorPaintLayer[] | null;
-    /**
-     * The stroke stack, bottom to top, drawn over every fill. Like `fills`: absent, `stroke` and the
-     * stroke settings above are the one stroke; present, they mirror its top layer, and writing them
-     * edits that layer (`stroke: null` clears the stack).
-     */
-    strokes?: VectorStrokeLayer[] | null;
-}
-interface VectorNodeBase {
-    id: string;
-    name?: string;
-    /** Default true. */
-    visible?: boolean;
-    /** Locked nodes are drawn but cannot be picked or edited on the canvas. */
-    locked?: boolean;
-    /** 0–1, default 1. */
-    opacity?: number;
-    /**
-     * Placement in the parent's space: a rigid matrix (rotation + translation). Anchors and
-     * children are in the node's own space. Omitted for unrotated nodes, whose positions are
-     * stored directly. Scale and skew are never stored here — `transformVectorNode` bakes
-     * them into the geometry, so stroke widths and the rotated selection box stay exact.
-     */
-    transform?: VectorMatrix;
-    /**
-     * An in-between a blend group generated from its keys. Steps are rebuilt whenever a key or
-     * the blend options change, and are locked (clicks select the blend group).
-     */
-    blendStep?: boolean;
-    /**
-     * Live path effects, applied top to bottom: each acts on every path above it (the node's own
-     * outline, or a group's children, then the result of the effects before it), and effects after a
-     * repeater act on its copies. The stored anchors and children never change.
-     */
-    effects?: VectorEffect[] | null;
-    /**
-     * As an operand of a live boolean group: how it combines with the result of the operands below
-     * it. Absent: the group's `liveBoolean` operation.
-     */
-    booleanOperation?: VectorBooleanOperation | null;
-    /** How the whole node (all its paint, filters included) mixes with what is under it. Default `normal`. */
-    blendMode?: VectorBlendMode;
-    /**
-     * Visual filters (drop and inner shadows, glows, blurs, feather), applied to everything the
-     * node draws. Unlike path `effects` they never change geometry: bounds, hit-testing and
-     * booleans ignore them.
-     */
-    filters?: VectorFilter[] | null;
-}
-/** A shape made of one or more subpaths (holes and compound shapes included). */
-interface VectorPathNode extends VectorNodeBase, VectorStyle {
-    type: 'path';
-    subpaths: VectorSubpath[];
-}
-/**
- * How a blend spaces its in-betweens: a number of `steps` between each pair of keys, a fixed
- * `distance` between steps along the spine, or `smoothColor` (as many steps as the colours
- * need for a smooth ramp; by distance when the colours match).
- */
-type VectorBlendSpacing = 'steps' | 'distance' | 'smoothColor';
-declare const VECTOR_BLEND_SPACINGS: readonly VectorBlendSpacing[];
-/** Settings of a blend. */
-interface VectorBlendOptions {
-    /** Default `steps`. */
-    spacing?: VectorBlendSpacing;
-    /** Steps between each pair of keys with `steps` spacing (default 5). */
-    steps?: number;
-    /** Distance between steps along the spine with `distance` spacing (default 20). */
-    distance?: number;
-    /** Turn the steps with the spine's direction (default `false`: they keep the keys' orientation). */
-    orientToSpine?: boolean;
-    /** Move anchors in straight lines instead of the rotation-aware morph (default `false`). */
-    linear?: boolean;
-}
-/** A live blend: the group's keys plus how the in-betweens are made and laid out. */
-interface VectorBlend extends VectorBlendOptions {
-    /**
-     * A replaced spine in the group's space: the steps follow it instead of the straight lines
-     * between the keys' centres (the keys sit along it, spread evenly by arc length).
-     */
-    spine?: VectorSubpath | null;
-    /** The anchor of each key's first subpath its blend starts from, by key id (the Blend tool's clicks). */
-    starts?: Record<string, number>;
-}
-/**
- * How a mask group's mask (its first, bottom child) hides the rest: `clip` (a clipping mask: the
- * mask's outline, fully opaque; its paint is not drawn), `alpha` (an opacity mask by the mask's
- * drawn alpha: soft edges, gradients and opacity count) or `luminance` (by its brightness times
- * its alpha: white shows, black hides).
- */
-type VectorMaskType = 'clip' | 'alpha' | 'luminance';
-declare const VECTOR_MASK_TYPES: readonly VectorMaskType[];
-/** A group's mask settings (`VectorGroupNode.mask`). */
-interface VectorMask {
-    type: VectorMaskType;
-    /** Show the contents where the mask hides them and hide them where it shows them. Default false. */
-    invert?: boolean;
-}
-/** A group of nodes that select and transform together. */
-interface VectorGroupNode extends VectorNodeBase {
-    type: 'group';
-    children: VectorNode[];
-    /**
-     * Makes the group a live blend: its children that are not `blendStep`s are the keys, in
-     * stacking order, and the steps between them are regenerated whenever a key changes.
-     */
-    blend?: VectorBlend | null;
-    /**
-     * Makes the group a live boolean: its children stay editable operands, folded bottom to top
-     * (each by its own `booleanOperation` or this one), and the group draws as the result in the
-     * bottom operand's style.
-     */
-    liveBoolean?: VectorBooleanOperation | null;
-    /**
-     * Makes the group a mask group: its first (bottom) child is the mask and the children above it
-     * show only where the mask lets them (see `VectorMaskType`). Hit-testing, bounds, snapping and
-     * booleans use the masked result. A hidden mask child turns the mask off (the contents draw
-     * whole). The group's own opacity, blend mode and filters apply to the masked result, and its
-     * path effects to the contents (not the mask). Ignored on blends and live booleans.
-     */
-    mask?: VectorMask | null;
-}
-type VectorNode = VectorPathNode | VectorGroupNode;
-/** A vector drawing: an artboard and its nodes, bottom to top. */
-interface VectorDocument {
-    width: number;
-    height: number;
-    /** Artboard colour (default: transparent). */
-    background?: string;
-    nodes: VectorNode[];
-}
-/** An axis-aligned rectangle. */
-interface VectorBounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** Identifies one anchor of a path node. */
-interface VectorAnchorRef {
-    nodeId: string;
-    subpath: number;
-    index: number;
-}
-/** Identifies one handle of an anchor. */
-interface VectorHandleRef extends VectorAnchorRef {
-    handle: 'in' | 'out';
-}
-/**
- * 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,
- * `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. `blend`
- * blends the shape clicked first into the one clicked next (clicking an anchor of a closed path
- * starts the blend there). `envelope` edits the mesh of the selection's envelope: drag its
- * anchors and handles, or inside a patch to pull the surface.
- */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend' | 'gradient' | 'envelope';
-declare const VECTOR_TOOLS: readonly VectorTool[];
-/** Keyboard modifiers held during a pointer event. */
-interface VectorModifiers {
-    shift?: boolean;
-    alt?: boolean;
-    /** Cmd on macOS, Ctrl elsewhere. */
-    mod?: boolean;
-}
-/** The eight resize handles of a selection box and the rotation handle. */
-type VectorTransformHandle = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'rotate';
-declare const VECTOR_TRANSFORM_HANDLES: readonly VectorTransformHandle[];
-/** Pan and zoom of the canvas: `screen = document × zoom + (x, y)`. */
-interface VectorViewport {
-    /** Screen position of the document origin, in screen pixels. */
-    x: number;
-    y: number;
-    zoom: number;
-}
-/** What the next shape and pen path are drawn with. */
-interface VectorDefaults extends VectorStyle {
-    /** Sides of the polygon tool (default 6). */
-    polygonSides?: number;
-    /** Points of the star tool (default 5). */
-    starPoints?: number;
-    /** Inner radius of the star tool as a fraction of the outer one (default 0.5). */
-    starInnerRatio?: number;
-    /** Live corner radius the rectangle, polygon and star tools give their corners (default 0). */
-    cornerRadius?: number;
-    /** Corner kind of those tools (default `round`). */
-    cornerKind?: VectorCornerKind;
-}
-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';
-/**
- * Live path effects (After Effects' path operators): `trim` (Trim Paths), `roundCorners`,
- * `puckerBloat`, `twist`, `zigzag`, `wiggle` (Wiggle Paths), `offset` (Offset Paths), `merge`
- * (Merge Paths), `repeater` and `envelope` (an envelope distortion: a warp preset or a mesh).
- */
-type VectorEffectType = 'trim' | 'roundCorners' | 'puckerBloat' | 'twist' | 'zigzag' | 'wiggle' | 'offset' | 'merge' | 'repeater' | 'envelope';
-declare const VECTOR_EFFECT_TYPES: readonly VectorEffectType[];
-/** Warp presets (Photoshop's fifteen, in menu order); shared with the image editor (`src/geom`). */
-type VectorWarpStyle = WarpStyle;
-/**
- * A grid of bicubic Bézier patches mapping a source box onto the plane. `us` / `vs` are the patch
- * boundaries as fractions of the box (increasing, first 0, last 1); `points` is the
- * `(3·(us.length − 1) + 1) × (3·(vs.length − 1) + 1)` control grid, row by row, in the node's own
- * space. Neighbouring patches share their edge row: anchors sit where both indices are multiples
- * of 3, handles where one is. Shared with the image editor (`src/geom`).
- */
-type VectorWarpMesh = WarpMesh;
-/** Merge Paths modes: a compound path (no boolean), union, the first minus the others, intersection or exclusion. */
-type VectorMergeMode = 'merge' | 'add' | 'subtract' | 'intersect' | 'exclude';
-declare const VECTOR_MERGE_MODES: readonly VectorMergeMode[];
-/** Parameters of each effect type. Lengths are in the node's own units, angles in degrees, percentages 0–100. */
-interface VectorEffectParamsMap {
-    trim: {
-        /** Start and end of the kept part, percent of the length (swapped when start > end). */
-        start: number;
-        end: number;
-        /** Shifts both, in degrees (360° = once round). */
-        offset: number;
-        /**
-         * `simultaneous`: every path trimmed by the same fractions of its own length;
-         * `individual`: the paths laid end to end in stacking order and trimmed as one length.
-         */
-        mode: 'simultaneous' | 'individual';
-    };
-    roundCorners: {
-        radius: number;
-    };
-    /** Percent, −100 (pucker: spiky) to 100 (bloat: bulging). */
-    puckerBloat: {
-        amount: number;
-    };
-    twist: {
-        /** Turn at the farthest point from the centre (none at the centre). */
-        angle: number;
-        /** The centre as an offset from the middle of the paths' bounds. */
-        center: Vec2;
-    };
-    zigzag: {
-        /** How far the points move to either side. */
-        size: number;
-        /** Ridges per segment. */
-        ridges: number;
-        /** Rounded waves instead of sharp zig zags. */
-        smooth: boolean;
-    };
-    wiggle: {
-        /** Largest displacement. */
-        size: number;
-        /** Points added per segment. */
-        detail: number;
-        smooth: boolean;
-        /** Wiggles per second. */
-        speed: number;
-        /** Percent: how much neighbouring points move together. */
-        correlation: number;
-        /** Degrees (360° = one wiggle). */
-        phase: number;
-        /** The same seed (and time) always gives the same wiggle. */
-        seed: number;
-        /** Seconds: where along the wiggle's motion it is drawn. */
-        time: number;
-    };
-    offset: {
-        /** Grows (positive) or shrinks (negative) the shapes. */
-        amount: number;
-        join: VectorLineJoin;
-        miterLimit: number;
-        /** Copies, copy i offset by `amount · (i + 1 + copyOffset)`. */
-        copies: number;
-        copyOffset: number;
-    };
-    merge: {
-        mode: VectorMergeMode;
-    };
-    repeater: {
-        /** Copies, the original included; a fraction fades the last copy. */
-        copies: number;
-        /** Shifts the copies along: copy i is transformed `i + offset` times. */
-        offset: number;
-        /** Each step: move, about `anchor` turn by `rotation` and scale by `scale` percent. */
-        position: Vec2;
-        /** Offset from the middle of the paths' bounds. */
-        anchor: Vec2;
-        rotation: number;
-        scale: Vec2;
-        /** Percent opacity of the first and last copies (in between interpolated). */
-        startOpacity: number;
-        endOpacity: number;
-        /** `below`: each copy draws under the one before it; `above`: over it. */
-        composite: 'below' | 'above';
-    };
-    /**
-     * Envelope distortion: the paths above it are mapped from their combined bounds through a warp
-     * preset (bend and horizontal / vertical distortion in percent) or, with style `mesh`, through
-     * `mesh` (null: the flat mesh of `columns × rows` patches over the bounds). The bounds are
-     * taken afresh each time, so editing the contents keeps the envelope.
-     */
-    envelope: {
-        style: VectorWarpStyle | 'mesh';
-        bend: number;
-        horizontal: number;
-        vertical: number;
-        orientation: 'horizontal' | 'vertical';
-        /** Patches of the mesh (a preset turns into a mesh of this size when it is edited). */
-        rows: number;
-        columns: number;
-        mesh: VectorWarpMesh | null;
-    };
-}
-/** One entry of an effect stack. */
-type VectorEffect = {
-    [K in VectorEffectType]: {
-        /** Unique within the node. */
-        id: string;
-        type: K;
-        /** Disabled effects are skipped. Default true. */
-        enabled?: boolean;
-        params: VectorEffectParamsMap[K];
-    };
-}[VectorEffectType];
-/** Identifies one segment of a path node: from anchor `segment` to the next. */
-interface VectorSegmentRef {
-    nodeId: string;
-    subpath: number;
-    segment: number;
-}
-/**
- * Visual filters: `dropShadow` (the node's silhouette, offset and blurred, under it),
- * `innerShadow` (a shadow cast inside the edges), `outerGlow` / `innerGlow` (an unoffset glow
- * outside or inside the edges), `layerBlur` (the whole node blurred) and `feather` (edges faded
- * to transparent).
- */
-type VectorFilterType = 'dropShadow' | 'innerShadow' | 'outerGlow' | 'innerGlow' | 'layerBlur' | 'feather';
-declare const VECTOR_FILTER_TYPES: readonly VectorFilterType[];
-/** A shadow or glow: colour, offset, blur and spread in the node's own units. */
-interface VectorShadowParams {
-    color: string;
-    /** 0–1: multiplies the colour's own alpha. */
-    opacity: number;
-    /** Blur radius (the SVG / CSS standard deviation is half of it). */
-    blur: number;
-    /** Grows the silhouette before blurring (inner effects: chokes it inwards). */
-    spread: number;
-}
-/** Parameters of each filter type. Lengths are in the node's own units. */
-interface VectorFilterParamsMap {
-    dropShadow: VectorShadowParams & {
-        offsetX: number;
-        offsetY: number;
-    };
-    innerShadow: VectorShadowParams & {
-        offsetX: number;
-        offsetY: number;
-    };
-    outerGlow: VectorShadowParams;
-    innerGlow: VectorShadowParams;
-    layerBlur: {
-        radius: number;
-    };
-    /** Fades the edges over `radius` inwards. */
-    feather: {
-        radius: number;
-    };
-}
-/** One entry of a node's filter stack. */
-type VectorFilter = {
-    [K in VectorFilterType]: {
-        /** Unique within the node. */
-        id: string;
-        type: K;
-        /** Disabled filters are skipped. Default true. */
-        enabled?: boolean;
-        params: VectorFilterParamsMap[K];
-    };
-}[VectorFilterType];
+import { B as BezierPath, A as AffineMatrix, S as SvgGradientDef } from './bezier-BfwIbVTl.cjs';
+import { V as VectorEffectType, a as VectorEffectParamsMap, b as VectorPathNode, c as VectorFillRule, d as VectorBooleanOperation, e as VectorNode, f as VectorEffect, g as VectorGroupNode, h as VectorBounds, i as VectorWarpMesh, j as VectorFilterType, k as VectorFilterParamsMap, l as VectorFilter, m as VectorGradient, n as Vec2, o as VectorGradientUnits, p as VectorGradientSpread, q as VectorGradientType, r as VectorPaint, s as VectorMatrix, t as VectorGradientStop, u as VectorStrokeAlign, v as VectorSubpath, w as VectorDocument, x as VectorWidthPoint } from './types-DyQq-WPY.cjs';
 
 /**
  * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
@@ -1279,4 +653,4 @@ declare function parseSvgTransform(value: string | undefined): AffineMatrix;
 /** Parses SVG markup into a vector document. Throws when there is no `<svg>` element. */
 declare function parseVectorSvg(svg: string, options?: VectorSvgImportOptions): VectorDocument;
 
-export { type VectorPaintDef as $, type VectorGradientPatch as A, type VectorBlendMode as B, type VectorFilterType as C, type VectorEffectType as D, type VectorEnvelopeParams as E, type VectorAlign as F, type VectorDistribute as G, type VectorArrange as H, type VectorBooleanOperation as I, type VectorMaskType as J, type VectorMask as K, type VectorAverageAxis as L, type VectorWarpMesh as M, type VectorFillRule as N, type VectorRenderFilter as O, type VectorAppearanceShape as P, type VectorArrowhead as Q, type VectorBlendSpacing as R, type VectorGradientInterpolation as S, type VectorGradientSpread as T, type VectorGradientType as U, type VectorDocument as V, type VectorStrokeAlign as W, type VectorStrokeGradientMode as X, type VectorFilterParamSpec as Y, type VectorEffectParamSpec as Z, type VectorRenderStrokeParts as _, type VectorNode as a, expandVectorAppearances as a$, type VectorArrowAlign as a0, type VectorEffect as a1, type VectorPaintLayer as a2, type VectorStrokeLayer as a3, type VectorFilter as a4, type VectorBlend as a5, type VectorMergeMode as a6, type VectorLineJoin as a7, type VectorEffectParamsMap as a8, type VectorStrokeSettings as a9, type VectorFilterParamsMap as aA, type VectorFilterPrimitive as aB, type VectorGradientPoints as aC, type VectorGradientRamp as aD, type VectorGradientSvgOptions as aE, type VectorGradientUnits as aF, type VectorLineCap as aG, type VectorMatrix as aH, type VectorPaintSvgOptions as aI, type VectorRgba as aJ, type VectorStrokeLayerKind as aK, type VectorSvgImportOptions as aL, type VectorSvgPatternDef as aM, type VectorSvgWrapper as aN, type VectorWarpStyle as aO, activeVectorEffects as aP, activeVectorFilters as aQ, applyVectorCornersAttribute as aR, applyVectorEffects as aS, applyVectorGradientPatch as aT, applyVectorGradientSpread as aU, clearVectorLiveBooleanCache as aV, convertVectorGradient as aW, createVectorEffect as aX, createVectorFilter as aY, defaultVectorGradient as aZ, expandVectorAppearance as a_, VECTOR_ARROWHEADS as aa, VECTOR_BLEND_MODES as ab, VECTOR_BLEND_SPACINGS as ac, VECTOR_CORNER_KINDS as ad, VECTOR_EFFECT_DEFAULTS as ae, VECTOR_EFFECT_LABELS as af, VECTOR_EFFECT_PARAM_SPECS as ag, VECTOR_EFFECT_TYPES as ah, VECTOR_FILTER_DEFAULTS as ai, VECTOR_FILTER_LABELS as aj, VECTOR_FILTER_MENU as ak, VECTOR_FILTER_PARAM_SPECS as al, VECTOR_FILTER_TYPES as am, VECTOR_GRADIENT_INTERPOLATIONS as an, VECTOR_GRADIENT_MAX_PERIODS as ao, VECTOR_GRADIENT_MIN_STOPS as ap, VECTOR_GRADIENT_SPREADS as aq, VECTOR_GRADIENT_TYPES as ar, VECTOR_MASK_TYPES as as, VECTOR_MERGE_MODES as at, VECTOR_PATHFINDER_OPERATIONS as au, VECTOR_STROKE_GRADIENT_MODES as av, VECTOR_TOOLS as aw, VECTOR_TRANSFORM_HANDLES as ax, type VectorBooleanOperand as ay, type VectorCorner as az, type VectorBounds as b, vectorGradientMidpointPosition as b$, expandVectorGradientSpread as b0, expandVectorGradientStops as b1, explicitVectorGradient as b2, foldVectorBooleanOperands as b3, gradientMidpointRemap as b4, hasExplicitGradientGeometry as b5, hasOwnVectorAppearance as b6, hasVectorAppearance as b7, insertVectorGradientStop as b8, isCentredVectorGradient as b9, spanVectorGradientStops as bA, transformVectorEffects as bB, transformVectorGradient as bC, transformVectorPaint as bD, vectorAppearanceNodes as bE, vectorAppearanceOutline as bF, vectorAppearanceShapes as bG, vectorBoxMatrix as bH, vectorChildAppearanceShapes as bI, vectorCornersAttribute as bJ, vectorDocumentToSvg as bK, vectorEffectInputBounds as bL, vectorEffectInputPaths as bM, vectorEnteredGroups as bN, vectorEnvelopeFrame as bO, vectorEnvelopeMap as bP, vectorEnvelopeMesh as bQ, vectorFilterMarkup as bR, vectorFilterParamKeys as bS, vectorFilterReach as bT, vectorFilterSvg as bU, vectorGradientArea as bV, vectorGradientAspect as bW, vectorGradientFocalParam as bX, vectorGradientHandles as bY, vectorGradientMatrix as bZ, vectorGradientMidpointFromPosition as b_, isVectorFilterType as ba, isVectorGradient as bb, isVectorLiveBoolean as bc, mapVectorGradient as bd, mapVectorPaint as be, moveVectorGradientHandle as bf, moveVectorGradientStop as bg, normalizeVectorEffectParams as bh, normalizeVectorFilterParams as bi, parseSvgTransform as bj, parseVectorColor as bk, parseVectorSvg as bl, patternAttrs as bm, periodicVectorGradientStops as bn, pinVectorGradient as bo, removeVectorGradientStop as bp, reverseVectorGradient as bq, samplePlainStops as br, sampleVectorGradient as bs, sampleVectorGradientAt as bt, sampleVectorPaintDefAt as bu, sanitizeVectorEffects as bv, sanitizeVectorFilters as bw, sanitizeVectorGradient as bx, setVectorGradientVector as by, sortedVectorGradientStops as bz, type VectorSvgExportOptions as c, vectorGradientNeedsExpansion as c0, vectorGradientParam as c1, vectorGradientPoints as c2, vectorGradientRamp as c3, vectorGradientSvgDefs as c4, vectorGradientTAt as c5, vectorGradientUnitsMatrix as c6, vectorLiveBooleanSteps as c7, vectorNodeEnvelope as c8, vectorNodeFilterSvg as c9, vectorNodeLocalPaintBounds as ca, vectorOperandOperation as cb, vectorPaintToSvg as cc, vectorPathLocalBounds as cd, vectorStrokeSvgParts as ce, widthProfileFromAttribute as cf, widthProfileToAttribute as cg, type Vec2 as d, type VectorSubpath as e, type VectorAnchor as f, type VectorPathNode as g, type VectorAnchorType as h, type VectorPaint as i, type VectorGroupNode as j, type VectorCornerKind as k, type VectorWidthPoint as l, type VectorGradientHandle as m, type VectorGradient as n, type VectorGradientStop as o, type VectorViewport as p, type VectorTransformHandle as q, type VectorAnchorRef as r, type VectorPathfinderOperation as s, type VectorTool as t, type VectorDefaults as u, type VectorStyle as v, type VectorHandleRef as w, type VectorSegmentRef as x, type VectorBlendOptions as y, type VectorModifiers as z };
+export { isVectorGradient as $, type VectorSvgPatternDef as A, type VectorSvgWrapper as B, activeVectorEffects as C, activeVectorFilters as D, applyVectorCornersAttribute as E, applyVectorEffects as F, applyVectorGradientPatch as G, applyVectorGradientSpread as H, clearVectorLiveBooleanCache as I, convertVectorGradient as J, createVectorEffect as K, createVectorFilter as L, defaultVectorGradient as M, expandVectorAppearance as N, expandVectorAppearances as O, expandVectorGradientSpread as P, expandVectorGradientStops as Q, explicitVectorGradient as R, foldVectorBooleanOperands as S, gradientMidpointRemap as T, hasExplicitGradientGeometry as U, type VectorSvgExportOptions as V, hasOwnVectorAppearance as W, hasVectorAppearance as X, insertVectorGradientStop as Y, isCentredVectorGradient as Z, isVectorFilterType as _, type VectorGradientHandle as a, vectorOperandOperation as a$, isVectorLiveBoolean as a0, mapVectorGradient as a1, mapVectorPaint as a2, moveVectorGradientHandle as a3, moveVectorGradientStop as a4, normalizeVectorEffectParams as a5, normalizeVectorFilterParams as a6, parseSvgTransform as a7, parseVectorColor as a8, parseVectorSvg as a9, vectorEffectInputPaths as aA, vectorEnteredGroups as aB, vectorEnvelopeFrame as aC, vectorEnvelopeMap as aD, vectorEnvelopeMesh as aE, vectorFilterMarkup as aF, vectorFilterParamKeys as aG, vectorFilterReach as aH, vectorFilterSvg as aI, vectorGradientArea as aJ, vectorGradientAspect as aK, vectorGradientFocalParam as aL, vectorGradientHandles as aM, vectorGradientMatrix as aN, vectorGradientMidpointFromPosition as aO, vectorGradientMidpointPosition as aP, vectorGradientNeedsExpansion as aQ, vectorGradientParam as aR, vectorGradientPoints as aS, vectorGradientRamp as aT, vectorGradientSvgDefs as aU, vectorGradientTAt as aV, vectorGradientUnitsMatrix as aW, vectorLiveBooleanSteps as aX, vectorNodeEnvelope as aY, vectorNodeFilterSvg as aZ, vectorNodeLocalPaintBounds as a_, patternAttrs as aa, periodicVectorGradientStops as ab, pinVectorGradient as ac, removeVectorGradientStop as ad, reverseVectorGradient as ae, samplePlainStops as af, sampleVectorGradient as ag, sampleVectorGradientAt as ah, sampleVectorPaintDefAt as ai, sanitizeVectorEffects as aj, sanitizeVectorFilters as ak, sanitizeVectorGradient as al, setVectorGradientVector as am, sortedVectorGradientStops as an, spanVectorGradientStops as ao, transformVectorEffects as ap, transformVectorGradient as aq, transformVectorPaint as ar, vectorAppearanceNodes as as, vectorAppearanceOutline as at, vectorAppearanceShapes as au, vectorBoxMatrix as av, vectorChildAppearanceShapes as aw, vectorCornersAttribute as ax, vectorDocumentToSvg as ay, vectorEffectInputBounds as az, type VectorGradientPatch as b, vectorPaintToSvg as b0, vectorPathLocalBounds as b1, vectorStrokeSvgParts as b2, widthProfileFromAttribute as b3, widthProfileToAttribute as b4, type VectorEnvelopeParams as c, type VectorRenderFilter as d, type VectorAppearanceShape as e, type VectorFilterParamSpec as f, type VectorEffectParamSpec as g, type VectorRenderStrokeParts as h, type VectorPaintDef as i, VECTOR_EFFECT_DEFAULTS as j, VECTOR_EFFECT_LABELS as k, VECTOR_EFFECT_PARAM_SPECS as l, VECTOR_FILTER_DEFAULTS as m, VECTOR_FILTER_LABELS as n, VECTOR_FILTER_MENU as o, VECTOR_FILTER_PARAM_SPECS as p, VECTOR_GRADIENT_MAX_PERIODS as q, VECTOR_GRADIENT_MIN_STOPS as r, type VectorBooleanOperand as s, type VectorFilterPrimitive as t, type VectorGradientPoints as u, type VectorGradientRamp as v, type VectorGradientSvgOptions as w, type VectorPaintSvgOptions as x, type VectorRgba as y, type VectorSvgImportOptions as z };