@pixerate/editor 0.99.0 → 0.101.0

package/dist/{svg-C9r284x8.d.cts → svg-Bj1MQFh6.d.cts}

@@ -1,4 +1,4 @@
-import { C as CanvasGradientDef, S as SvgGradientDef, A as AffineMatrix } from './bezier-BfwIbVTl.cjs';
+import { C as CanvasGradientDef, B as BezierPath, A as AffineMatrix, S as SvgGradientDef } from './bezier-BfwIbVTl.cjs';
 import { W as WarpStyle, a as WarpMesh } from './types-CwMPoRMU.cjs';
 
 /** An affine matrix `[a, b, c, d, e, f]`: `x' = a·x + c·y + e`, `y' = b·x + d·y + f` (SVG order). */
@@ -167,6 +167,41 @@ interface VectorWidthPoint {
     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;
@@ -196,6 +231,19 @@ interface VectorStyle {
      * 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;
@@ -229,6 +277,14 @@ interface VectorNodeBase {
      * 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 {
@@ -499,6 +555,329 @@ interface VectorSegmentRef {
     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];
+
+/**
+ * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
+ * stored anchors and children stay editable.
+ *
+ * `expandVectorAppearance` is the one place the effected geometry is made (cached per node
+ * object, so an edit recomputes only the nodes it replaced). Rendering, hit-testing, bounds,
+ * snapping, booleans, the Pathfinder, the Shape Builder and SVG export all read it, the way they
+ * read live corners through `subpathsToBezier`; Expand Appearance stores it.
+ *
+ * Stacking follows After Effects' shape layers (effectcraft `crates/render/src/shapes.rs`): an
+ * effect acts on every path above it — the node's own outline, or for a group every path of its
+ * children (nested groups included, as drawn by their own effects) — in the order of the stack,
+ * and effects placed after a repeater act on its copies. The result paints with the style of the
+ * path each shape came from; Merge Paths and live booleans paint with the bottom one's.
+ *
+ * Live booleans fold their operands bottom to top, each combined with the result below it by its
+ * own operation or the group's, and every prefix of the fold is cached under a rolling hash of the
+ * operands it covers, so editing one operand recombines only the operands from it up; the cache
+ * drops its least recently used half when full. Live groups are hit by their result except while
+ * they are being edited (`vectorEnteredGroups`).
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): the stacking rule of effectcraft `crates/render/src/shapes.rs`
+ * (`collect()`); figcraft `crates/render/src/boolean.rs` (`fold_cached`, `PathCache`) and
+ * `crates/engine/src/booleans.rs` (`operand_op`, `result_outline`); and the live-object model of
+ * vectorcraft `crates/doc/src/live.rs` (`expand_live`, `expanded_group`, `subtree_has_live`).
+ */
+
+/** One shape of a node's appearance: a path in the node's own space, painted in `source`'s style. */
+interface VectorAppearanceShape {
+    /** The path whose style paints it. */
+    source: VectorPathNode;
+    path: BezierPath;
+    /** Opacity factor relative to the node (its own opacity not included). */
+    opacity: number;
+    /** Draw-order key (compared element by element). */
+    order: number[];
+}
+/** Default parameters of each effect type. */
+declare const VECTOR_EFFECT_DEFAULTS: {
+    readonly [K in VectorEffectType]: VectorEffectParamsMap[K];
+};
+declare const VECTOR_EFFECT_LABELS: Record<VectorEffectType, string>;
+/** How a panel edits one effect parameter. */
+type VectorEffectParamSpec = {
+    key: string;
+    label: string;
+    kind: 'number';
+    min?: number;
+    max?: number;
+    step: number;
+    slider?: boolean;
+} | {
+    key: string;
+    label: string;
+    kind: 'vec2';
+    step: number;
+} | {
+    key: string;
+    label: string;
+    kind: 'boolean';
+} | {
+    key: string;
+    label: string;
+    kind: 'select';
+    options: {
+        value: string;
+        label: string;
+    }[];
+};
+/** The editable parameters of each effect type, in panel order. */
+declare const VECTOR_EFFECT_PARAM_SPECS: Record<VectorEffectType, VectorEffectParamSpec[]>;
+/** Envelope parameters. */
+type VectorEnvelopeParams = VectorEffectParamsMap['envelope'];
+/**
+ * The envelope's mesh over `bounds` (the paths' combined bounds), in the node's space: its own
+ * mesh, the flat mesh of `columns × rows` patches, or a preset split exactly into that many patches.
+ */
+declare function vectorEnvelopeMesh(params: VectorEnvelopeParams, bounds: VectorBounds): VectorWarpMesh;
+/** The envelope as a map of the node's space over `bounds`, or null when it changes nothing (or the box is empty). */
+declare function vectorEnvelopeMap(params: VectorEnvelopeParams, bounds: VectorBounds | null): ((p: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+}) | null;
+/**
+ * Effect parameters with defaults filled in and invalid values dropped (unknown keys go too).
+ * Returns null for an unknown type.
+ */
+declare function normalizeVectorEffectParams<K extends VectorEffectType>(type: K, params: Record<string, unknown> | null | undefined, base?: VectorEffectParamsMap[K]): VectorEffectParamsMap[K] | null;
+/** A new effect of `type` (defaults merged with `params`), or null for an unknown type. */
+declare function createVectorEffect<K extends VectorEffectType>(type: K, id: string, params?: Partial<VectorEffectParamsMap[K]> | Record<string, unknown>): Extract<VectorEffect, {
+    type: K;
+}> | null;
+/** The node's effects that take part (enabled, of a known type). */
+declare function activeVectorEffects(node: VectorNode): VectorEffect[];
+/** Whether the node itself draws differently from its stored geometry (effects or a live boolean). */
+declare function hasOwnVectorAppearance(node: VectorNode): boolean;
+/** Whether the node or anything inside it has a live appearance. */
+declare function hasVectorAppearance(node: VectorNode): boolean;
+/** A live boolean group (its children are operands). */
+declare function isVectorLiveBoolean(node: VectorNode | null | undefined): node is VectorGroupNode & {
+    liveBoolean: VectorBooleanOperation;
+};
+/** How operand `child` of a live boolean group combines with the operands below it. */
+declare function vectorOperandOperation(group: VectorGroupNode, child: VectorNode): VectorBooleanOperation;
+/** How many boolean steps (one operand combined with the result below it) live booleans have computed: what a cache miss costs. */
+declare function vectorLiveBooleanSteps(): number;
+/** Empties the live boolean prefix cache. */
+declare function clearVectorLiveBooleanCache(): void;
+/** One operand of a live boolean: its outline (group space), fill rule and operation (unused for the bottom one). */
+interface VectorBooleanOperand {
+    path: BezierPath;
+    fillRule: VectorFillRule;
+    operation: VectorBooleanOperation;
+}
+/**
+ * The result of folding `operands` bottom to top, reusing the longest cached prefix: only the
+ * operands above it are combined. Invalid geometry gives an empty path.
+ */
+declare function foldVectorBooleanOperands(operands: readonly VectorBooleanOperand[]): BezierPath;
+/** Applies an effect stack to shapes, top to bottom (disabled effects skipped). */
+declare function applyVectorEffects(shapes: readonly VectorAppearanceShape[], effects: readonly VectorEffect[] | null | undefined): VectorAppearanceShape[];
+/** 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. */
+declare function vectorEffectInputBounds(node: VectorNode, effectId: string): VectorBounds | null;
+/** The node's first enabled envelope effect, or null. */
+declare function vectorNodeEnvelope(node: VectorNode | null | undefined): Extract<VectorEffect, {
+    type: 'envelope';
+}> | null;
+/**
+ * The editable mesh of a node's envelope (its own mesh, or the preset or flat mesh it stands for)
+ * with the box it bends, in the node's own space; null without an envelope or contents.
+ */
+declare function vectorEnvelopeFrame(node: VectorNode, effectId?: string): {
+    effectId: string;
+    bounds: VectorBounds;
+    mesh: VectorWarpMesh;
+} | null;
+/**
+ * What a node draws as: shapes in its own space (its `transform` and opacity not applied),
+ * bottom to top, with its effects and those of everything inside it applied. Cached per node
+ * object.
+ */
+declare function vectorAppearanceShapes(node: VectorNode): VectorAppearanceShape[];
+/** Everything a node draws as one path in its own space (live corners cut, effects applied). */
+declare function vectorAppearanceOutline(node: VectorNode): BezierPath;
+/** What a node draws as, one plain path per shape (ids `<id>~fx<n>`, opacity relative to the node). */
+declare function vectorAppearanceNodes(node: VectorNode): VectorPathNode[];
+/**
+ * The node as plain geometry: path effects and live booleans evaluated into paths (the node
+ * itself when nothing inside it is live). A path keeps its id when it draws as one shape;
+ * otherwise, like any live group, it becomes a group with that id holding one path per shape
+ * (ids `<id>~fx<n>`). Groups without effects of their own keep their structure. Cached per node.
+ */
+declare function expandVectorAppearance(node: VectorNode): VectorNode;
+/** Every node of a list expanded (the same array when nothing in it is live). */
+declare function expandVectorAppearances(nodes: readonly VectorNode[]): VectorNode[];
+/**
+ * Reads effects from untrusted data (JSON, agent input): unknown types and malformed entries are
+ * dropped, parameters normalized, ids made unique.
+ */
+declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
+/**
+ * Effect parameters carried through a linear map baked into a node's geometry (scaling or
+ * flipping it): offsets and positions move with it, angles turn the other way when it mirrors.
+ * Lengths such as sizes and radii are kept, like stroke widths.
+ */
+declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix, 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
+ * each operand can be picked (figcraft `crates/engine/src/booleans.rs`, `result_outline`).
+ */
+declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
+
+/**
+ * Visual filters of vector nodes: drop shadow, inner shadow, outer and inner glow, layer blur and
+ * feather, drawn as one SVG `<filter>` per node (in the canvases and in SVG export alike).
+ *
+ * The filter takes everything the node draws (`SourceGraphic`) and its silhouette
+ * (`SourceAlpha`) in the node's own space, and builds, in this order:
+ *
+ * 1. Inner shadows and inner glows, in stack order, over the body: the inverse of the silhouette
+ *    (offset for a shadow), grown by `spread` (which chokes the shadow inwards), blurred, coloured
+ *    and clipped to the silhouette.
+ * 2. Feather: the body kept where the silhouette, eroded by half the radius and blurred by a
+ *    quarter of it, is, so the edge fades from about nothing at the outline to full strength
+ *    `radius` inside.
+ * 3. Drop shadows and outer glows, in stack order, under the body: the silhouette grown by
+ *    `spread`, blurred, offset (shadows) and coloured.
+ * 4. Layer blurs, over the whole result (shadows included).
+ *
+ * Blur radii are CSS / Figma blur radii: the Gaussian's standard deviation is half the radius, and
+ * it reaches about 1.5 radii. Background blur needs the backdrop, which an SVG filter cannot read
+ * (`BackgroundImage` was dropped from browsers) and which other SVG readers cannot either, so it is
+ * left to the planned lens objects.
+ *
+ * The construction of feather, glows and inner shadows from blur, offset and clip follows
+ * designcraft `crates/render/src/fx.rs` (`draw_item_fx`, `inner_edge`, `split`); the effect set,
+ * defaults and reach follow figcraft `crates/doc/src/props.rs` (`EffectKind`, `Shadow`,
+ * `Effect::reach`). Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md).
+ */
+
+/** Default parameters of each filter type. */
+declare const VECTOR_FILTER_DEFAULTS: {
+    readonly [K in VectorFilterType]: VectorFilterParamsMap[K];
+};
+declare const VECTOR_FILTER_LABELS: Readonly<Record<VectorFilterType, string>>;
+/** How a panel edits one filter parameter: an effect parameter spec, or a colour. */
+type VectorFilterParamSpec = VectorEffectParamSpec | {
+    key: string;
+    label: string;
+    kind: 'color';
+};
+/** The editable parameters of each filter type, in panel order. */
+declare const VECTOR_FILTER_PARAM_SPECS: Readonly<Record<VectorFilterType, readonly VectorFilterParamSpec[]>>;
+declare function isVectorFilterType(value: unknown): value is VectorFilterType;
+/**
+ * Filter parameters with defaults (or `base`) filled in; values of the wrong type are dropped,
+ * numbers clamped to their range, unknown keys ignored. Null for an unknown type.
+ */
+declare function normalizeVectorFilterParams<K extends VectorFilterType>(type: K, params: Record<string, unknown> | null | undefined, base?: VectorFilterParamsMap[K]): VectorFilterParamsMap[K] | null;
+/** The parameter keys a filter type takes (for error messages). */
+declare function vectorFilterParamKeys(type: VectorFilterType): string[];
+/** A new filter of `type` (defaults merged with `params`), or null for an unknown type. */
+declare function createVectorFilter<K extends VectorFilterType>(type: K, id: string, params?: Partial<VectorFilterParamsMap[K]> | Record<string, unknown>): Extract<VectorFilter, {
+    type: K;
+}> | null;
+/**
+ * Reads filters from untrusted data (JSON, agent input, SVG): unknown types and malformed entries
+ * are dropped, parameters normalized, ids made unique.
+ */
+declare function sanitizeVectorFilters(value: unknown): VectorFilter[];
+/** The node's filters that draw something (enabled, known, with a visible result). */
+declare function activeVectorFilters(node: Pick<VectorNode, 'filters'>): VectorFilter[];
+/** How far a node's filters can paint past what it draws, in its own units. */
+declare function vectorFilterReach(filters: readonly VectorFilter[]): number;
+/** One SVG filter primitive as data: a tag (`feGaussianBlur`, …), its attributes and children. */
+interface VectorFilterPrimitive {
+    tag: string;
+    attrs: Readonly<Record<string, string | number>>;
+    children?: VectorFilterPrimitive[];
+}
+/**
+ * A node's filter as data: draw `<filter id filterUnits="userSpaceOnUse" x y width height
+ * color-interpolation-filters="sRGB">` with the primitives inside, and reference it with
+ * `filter="url(#id)"` on the node's element. The region is in the node's own space.
+ */
+interface VectorRenderFilter {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    primitives: VectorFilterPrimitive[];
+}
+/**
+ * The SVG filter for `filters` over a node whose drawing covers `bounds` (its own space, strokes
+ * included), or null when none of them draws.
+ */
+declare function vectorFilterSvg(filters: readonly VectorFilter[], id: string, bounds: VectorBounds | null): VectorRenderFilter | null;
+/** A render filter as SVG markup (`extra` is added to the `<filter>` element's attributes). */
+declare function vectorFilterMarkup(filter: VectorRenderFilter, extra?: string): string;
+/** Labels of the filter types, for menus. */
+declare const VECTOR_FILTER_MENU: readonly {
+    type: VectorFilterType;
+    label: string;
+}[];
 
 /** True when `paint` is a gradient (any style). */
 declare function isVectorGradient(paint: VectorPaint | undefined): paint is VectorGradient;
@@ -847,6 +1226,13 @@ interface VectorRenderStrokeParts {
 }
 /** The stroke parts of a path whose stroke needs more than one element, in its own space (undefined otherwise). */
 declare function vectorStrokeSvgParts(node: VectorPathNode, clipId: string, precision?: number): VectorRenderStrokeParts | undefined;
+/**
+ * The box a node draws over in its own space (its `transform` not applied): its geometry as drawn
+ * (effects applied), padded by how far its strokes reach. Null when it draws nothing.
+ */
+declare function vectorNodeLocalPaintBounds(node: VectorNode): VectorBounds | null;
+/** A node's filter (`node.filters`) as render data with id `id`, or null when none draws. Cached per node. */
+declare function vectorNodeFilterSvg(node: VectorNode, id: string): VectorRenderFilter | null;
 /** A width profile as a data attribute: `t,left,right` points separated by `;`. */
 declare function widthProfileToAttribute(points: readonly VectorWidthPoint[], precision?: number): string;
 /** Reads `widthProfileToAttribute` output (invalid points are dropped). */
@@ -856,10 +1242,17 @@ declare function vectorDocumentToSvg(doc: VectorDocument, options?: VectorSvgExp
 interface VectorSvgImportOptions {
     /** Makes ids for elements without a usable `id` (default `node-1`, `node-2`, …). */
     createId?: () => string;
+    /**
+     * Merge neighbouring shapes with the same outline into one path with stacked fills and strokes,
+     * as design tools export several paints on one layer (default false: an SVG may hold identical
+     * shapes on purpose). Shapes merge only when the paint order stays the same (no stroke under a
+     * later fill) and they share opacity, visibility, filters and blend mode.
+     */
+    mergeStackedShapes?: boolean;
 }
 /** Parses an SVG `transform` attribute into one matrix. */
 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 { VECTOR_CORNER_KINDS as $, type VectorDefaults as A, type VectorStyle as B, type VectorHandleRef as C, type VectorSegmentRef as D, type VectorBlendOptions as E, type VectorModifiers as F, type VectorGradientPatch as G, type VectorAlign as H, type VectorDistribute as I, type VectorArrange as J, type VectorAverageAxis 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 VectorRenderStrokeParts as S, type VectorPaintDef as T, type VectorArrowAlign as U, type VectorDocument as V, type VectorBlend as W, type VectorMergeMode as X, type VectorLineJoin as Y, VECTOR_ARROWHEADS as Z, VECTOR_BLEND_SPACINGS as _, type VectorNode as a, vectorGradientAspect as a$, VECTOR_EFFECT_TYPES as a0, VECTOR_GRADIENT_INTERPOLATIONS as a1, VECTOR_GRADIENT_MAX_PERIODS as a2, VECTOR_GRADIENT_MIN_STOPS as a3, VECTOR_GRADIENT_SPREADS as a4, VECTOR_GRADIENT_TYPES as a5, VECTOR_MERGE_MODES as a6, VECTOR_PATHFINDER_OPERATIONS as a7, VECTOR_STROKE_GRADIENT_MODES as a8, VECTOR_TOOLS as a9, isVectorGradient as aA, mapVectorGradient as aB, mapVectorPaint as aC, moveVectorGradientHandle as aD, moveVectorGradientStop as aE, parseSvgTransform as aF, parseVectorColor as aG, parseVectorSvg as aH, patternAttrs as aI, periodicVectorGradientStops as aJ, pinVectorGradient as aK, removeVectorGradientStop as aL, reverseVectorGradient as aM, samplePlainStops as aN, sampleVectorGradient as aO, sampleVectorGradientAt as aP, sampleVectorPaintDefAt as aQ, sanitizeVectorGradient as aR, setVectorGradientVector as aS, sortedVectorGradientStops as aT, spanVectorGradientStops as aU, transformVectorGradient as aV, transformVectorPaint as aW, vectorBoxMatrix as aX, vectorCornersAttribute as aY, vectorDocumentToSvg as aZ, vectorGradientArea as a_, VECTOR_TRANSFORM_HANDLES as aa, type VectorCorner 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 VectorSvgImportOptions as ak, type VectorSvgPatternDef as al, type VectorSvgWrapper as am, type VectorWarpStyle as an, applyVectorCornersAttribute as ao, applyVectorGradientPatch as ap, applyVectorGradientSpread as aq, convertVectorGradient as ar, defaultVectorGradient as as, expandVectorGradientSpread as at, expandVectorGradientStops as au, explicitVectorGradient as av, gradientMidpointRemap as aw, hasExplicitGradientGeometry as ax, insertVectorGradientStop as ay, isCentredVectorGradient as az, type VectorBounds as b, vectorGradientFocalParam as b0, vectorGradientHandles as b1, vectorGradientMatrix as b2, vectorGradientMidpointFromPosition as b3, vectorGradientMidpointPosition as b4, vectorGradientNeedsExpansion as b5, vectorGradientParam as b6, vectorGradientPoints as b7, vectorGradientRamp as b8, vectorGradientSvgDefs as b9, vectorGradientTAt as ba, vectorGradientUnitsMatrix as bb, vectorPaintToSvg as bc, vectorPathLocalBounds as bd, vectorStrokeSvgParts as be, widthProfileFromAttribute as bf, widthProfileToAttribute as bg, type VectorSvgExportOptions as c, 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 VectorEffectType as q, type VectorEffectParamsMap as r, type VectorFillRule as s, type VectorBooleanOperation as t, type VectorEffect as u, type VectorWarpMesh as v, type VectorTransformHandle as w, type VectorAnchorRef as x, type VectorPathfinderOperation as y, type VectorTool as z };
+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 };