@pixerate/editor 0.107.0 → 0.109.0

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

@@ -1,609 +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>;
-}
-/** 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;
-}
-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
@@ -730,6 +126,8 @@ interface VectorBooleanOperand {
 declare function foldVectorBooleanOperands(operands: readonly VectorBooleanOperand[]): BezierPath;
 /** Applies an effect stack to shapes, top to bottom (disabled effects skipped). */
 declare function applyVectorEffects(shapes: readonly VectorAppearanceShape[], effects: readonly VectorEffect[] | null | undefined): VectorAppearanceShape[];
+/** The shapes of a child in its parent's space (hidden children have none), ordered by its index. */
+declare function vectorChildAppearanceShapes(child: VectorNode, index: number): VectorAppearanceShape[];
 /** The paths entering effect `effectId` of the node's stack (those above it applied), in the node's own space. */
 declare function vectorEffectInputPaths(node: VectorNode, effectId: string): BezierPath[] | null;
 /** The box effect `effectId` (an envelope) bends: the combined bounds of the paths entering it, in the node's own space. */
@@ -779,7 +177,7 @@ declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
 declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix, 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
+ * holding a node in `ids`; mask groups only when they hold one. Their children are hit and outlined as stored instead of as drawn, so
  * each operand can be picked (figcraft `crates/engine/src/booleans.rs`, `result_outline`).
  */
 declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
@@ -1255,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 VectorStrokeLayer 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 VectorAverageAxis as J, type VectorWarpMesh as K, type VectorArrowhead as L, type VectorBlendSpacing as M, type VectorGradientInterpolation as N, type VectorGradientSpread as O, type VectorGradientType as P, type VectorStrokeAlign as Q, type VectorStrokeGradientMode as R, type VectorFilterParamSpec as S, type VectorEffectParamSpec as T, type VectorRenderStrokeParts as U, type VectorDocument as V, type VectorPaintDef as W, type VectorRenderFilter as X, type VectorArrowAlign as Y, type VectorEffect as Z, type VectorPaintLayer as _, type VectorNode as a, explicitVectorGradient as a$, type VectorFilter as a0, type VectorBlend as a1, type VectorMergeMode as a2, type VectorLineJoin as a3, type VectorEffectParamsMap as a4, type VectorStrokeSettings as a5, VECTOR_ARROWHEADS as a6, VECTOR_BLEND_MODES as a7, VECTOR_BLEND_SPACINGS as a8, VECTOR_CORNER_KINDS as a9, type VectorGradientRamp as aA, type VectorGradientSvgOptions as aB, type VectorGradientUnits as aC, type VectorLineCap as aD, type VectorMatrix as aE, type VectorPaintSvgOptions as aF, type VectorRgba as aG, type VectorStrokeLayerKind as aH, type VectorSvgImportOptions as aI, type VectorSvgPatternDef as aJ, type VectorSvgWrapper as aK, type VectorWarpStyle as aL, activeVectorEffects as aM, activeVectorFilters as aN, applyVectorCornersAttribute as aO, applyVectorEffects as aP, applyVectorGradientPatch as aQ, applyVectorGradientSpread as aR, clearVectorLiveBooleanCache as aS, convertVectorGradient as aT, createVectorEffect as aU, createVectorFilter as aV, defaultVectorGradient as aW, expandVectorAppearance as aX, expandVectorAppearances as aY, expandVectorGradientSpread as aZ, expandVectorGradientStops as a_, VECTOR_EFFECT_DEFAULTS as aa, VECTOR_EFFECT_LABELS as ab, VECTOR_EFFECT_PARAM_SPECS as ac, VECTOR_EFFECT_TYPES as ad, VECTOR_FILTER_DEFAULTS as ae, VECTOR_FILTER_LABELS as af, VECTOR_FILTER_MENU as ag, VECTOR_FILTER_PARAM_SPECS as ah, VECTOR_FILTER_TYPES as ai, VECTOR_GRADIENT_INTERPOLATIONS as aj, VECTOR_GRADIENT_MAX_PERIODS as ak, VECTOR_GRADIENT_MIN_STOPS as al, VECTOR_GRADIENT_SPREADS as am, VECTOR_GRADIENT_TYPES as an, VECTOR_MERGE_MODES as ao, VECTOR_PATHFINDER_OPERATIONS as ap, VECTOR_STROKE_GRADIENT_MODES as aq, VECTOR_TOOLS as ar, VECTOR_TRANSFORM_HANDLES as as, type VectorAppearanceShape as at, type VectorBooleanOperand as au, type VectorCorner as av, type VectorFillRule as aw, type VectorFilterParamsMap as ax, type VectorFilterPrimitive as ay, type VectorGradientPoints as az, type VectorBounds as b, vectorGradientRamp as b$, foldVectorBooleanOperands as b0, gradientMidpointRemap as b1, hasExplicitGradientGeometry as b2, hasOwnVectorAppearance as b3, hasVectorAppearance as b4, insertVectorGradientStop as b5, isCentredVectorGradient as b6, isVectorFilterType as b7, isVectorGradient as b8, isVectorLiveBoolean as b9, transformVectorPaint as bA, vectorAppearanceNodes as bB, vectorAppearanceOutline as bC, vectorAppearanceShapes as bD, vectorBoxMatrix as bE, vectorCornersAttribute as bF, vectorDocumentToSvg as bG, vectorEffectInputBounds as bH, vectorEffectInputPaths as bI, vectorEnteredGroups as bJ, vectorEnvelopeFrame as bK, vectorEnvelopeMap as bL, vectorEnvelopeMesh as bM, vectorFilterMarkup as bN, vectorFilterParamKeys as bO, vectorFilterReach as bP, vectorFilterSvg as bQ, vectorGradientArea as bR, vectorGradientAspect as bS, vectorGradientFocalParam as bT, vectorGradientHandles as bU, vectorGradientMatrix as bV, vectorGradientMidpointFromPosition as bW, vectorGradientMidpointPosition as bX, vectorGradientNeedsExpansion as bY, vectorGradientParam as bZ, vectorGradientPoints as b_, mapVectorGradient as ba, mapVectorPaint as bb, moveVectorGradientHandle as bc, moveVectorGradientStop as bd, normalizeVectorEffectParams as be, normalizeVectorFilterParams as bf, parseSvgTransform as bg, parseVectorColor as bh, parseVectorSvg as bi, patternAttrs as bj, periodicVectorGradientStops as bk, pinVectorGradient as bl, removeVectorGradientStop as bm, reverseVectorGradient as bn, samplePlainStops as bo, sampleVectorGradient as bp, sampleVectorGradientAt as bq, sampleVectorPaintDefAt as br, sanitizeVectorEffects as bs, sanitizeVectorFilters as bt, sanitizeVectorGradient as bu, setVectorGradientVector as bv, sortedVectorGradientStops as bw, spanVectorGradientStops as bx, transformVectorEffects as by, transformVectorGradient as bz, type VectorSvgExportOptions as c, vectorGradientSvgDefs as c0, vectorGradientTAt as c1, vectorGradientUnitsMatrix as c2, vectorLiveBooleanSteps as c3, vectorNodeEnvelope as c4, vectorNodeFilterSvg as c5, vectorNodeLocalPaintBounds as c6, vectorOperandOperation as c7, vectorPaintToSvg as c8, vectorPathLocalBounds as c9, vectorStrokeSvgParts as ca, widthProfileFromAttribute as cb, widthProfileToAttribute as cc, 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 };