@svgsketch/core 0.7.0 → 1.0.0

package/dist/index.d.mts

@@ -269,6 +269,43 @@ interface SerializedAnimationTimeline {
             x: number;
             y: number;
         };
+        /**
+         * CSS selector for a DOM element to animate directly, used when the
+         * animation target is not an editor Shape — e.g. an `<animateTransform
+         * xlink:href="#rect1"/>` whose target lives inside a `<clipPath>`
+         * definition. The track's `shapeId` is a synthetic `__dom__<id>` in
+         * this case (no editor Shape exists to bind to). Without this field,
+         * the SMIL exporter has no way to re-locate the target after a
+         * save/reload round-trip and silently drops every clip/mask-internal
+         * animation.
+         */
+        domTargetSelector?: string;
+        /**
+         * For `property === 'domTransformStack'` tracks: the original
+         * `<animateTransform>` `type` function (`translate` / `scale` /
+         * `rotate` / `skewX` / `skewY` / `matrix`). The SMIL exporter
+         * (`addDomTransformStackEntry`) early-returns when this is missing,
+         * silently dropping every stacked DOM-transform animation across
+         * save/reload. Per SVG Animation §19.4.2 the export must re-emit
+         * the same `type` — and per SMIL §4.2 the document-order index
+         * (`transformStackIndex`) controls additive composition of the
+         * stack. Both are essential for clip/mask internal animations.
+         */
+        transformFunction?: 'translate' | 'scale' | 'rotate' | 'skewX' | 'skewY' | 'matrix';
+        /**
+         * For `property === 'domTransformStack'` tracks: document-order
+         * index within the target element's `<animateTransform>` stack.
+         * The renderer sorts tracks by this index before applying the
+         * SMIL animation sandwich (SVG 2 §19.2.7).
+         */
+        transformStackIndex?: number;
+        /**
+         * For `property === 'domTransformStack'` tracks: the target
+         * element's pre-animation `transform` attribute value (the
+         * underlying value in the SMIL animation sandwich). Captured at
+         * import time.
+         */
+        transformBaseValue?: string;
         keyframes: {
             time: number;
             value: number | string;
@@ -312,7 +349,7 @@ interface AnimatablePropertyDescriptor {
  * Only enums referenced by SerializedShape or HistorySnapshot live here.
  * Editor-only enums (Mode, ControlPointPosition, etc.) stay in the editor.
  */
-declare enum SplineCurveType {
+declare enum PathCurveType {
     LINEAR = "linear",
     QUADRATIC = "quadratic",
     CUBIC = "cubic",
@@ -321,7 +358,7 @@ declare enum SplineCurveType {
     BASIS = "basis",
     MIXED = "mixed"
 }
-declare enum SplinePointType {
+declare enum PathPointType {
     SMOOTH = "smooth",
     CORNER = "corner",
     SYMMETRIC = "symmetric"
@@ -419,6 +456,14 @@ interface RadialGradient {
     r: number;
     ry: number;
     rotation: number;
+    /**
+     * Focal-circle radius (SVG 2 §14.2.3.1 `fr`). When present and > 0, the
+     * gradient's first stop is rendered along this circle (not at a single
+     * focal point) — produces a "donut" radial gradient. Same coordinate
+     * space as `r` (i.e. governed by `gradientUnits`). Defaults to 0
+     * when omitted, matching the spec's initial value and pre-SVG-2 behaviour.
+     */
+    fr?: number;
     stops: GradientStop[];
     spreadMethod: GradientSpreadMethod;
     opacity: number;
@@ -563,7 +608,7 @@ interface CustomPatternDef {
     /** Tile height in userSpaceOnUse coordinates. */
     height: number;
 }
-type FilterType = 'drop-shadow' | 'inner-shadow' | 'gaussian-blur' | 'motion-blur' | 'point-light' | 'spot-light' | 'diffuse-lighting' | 'specular-lighting' | 'outline' | 'sharpen' | 'pixelate' | 'warp' | 'morphology' | 'contouring-discrete' | 'contouring-table' | 'round-edges' | 'grayscale' | 'channel-painter' | 'brightness' | 'contrast' | 'opacity' | 'invert' | 'hue-rotate' | 'saturate' | 'black-and-white' | 'sepia' | 'duotone' | 'xray' | 'noise' | 'emboss' | 'film-grain' | 'watercolor' | 'gouache' | 'ink-blot' | 'crumpled-plastic' | 'riddled' | 'glow' | 'inner-glow' | 'raw-svg';
+type FilterType = 'drop-shadow' | 'inner-shadow' | 'gaussian-blur' | 'motion-blur' | 'point-light' | 'spot-light' | 'diffuse-lighting' | 'specular-lighting' | 'outline' | 'sharpen' | 'pixelate' | 'warp' | 'morphology' | 'contouring-discrete' | 'contouring-table' | 'round-edges' | 'grayscale' | 'channel-painter' | 'brightness' | 'contrast' | 'opacity' | 'invert' | 'hue-rotate' | 'saturate' | 'black-and-white' | 'sepia' | 'duotone' | 'xray' | 'noise' | 'emboss' | 'film-grain' | 'watercolor' | 'gouache' | 'ink-blot' | 'crumpled-plastic' | 'riddled' | 'glow' | 'inner-glow' | 'raw-svg' | 'svg-primitive-chain';
 type BlurQuality = 'normal' | 'high';
 interface BaseFilter {
     id: string;
@@ -831,14 +876,265 @@ interface RawSvgFilter extends BaseFilter {
     floodOpacity?: string;
     lightingColor?: string;
 }
-type ShapeFilter = DropShadowFilter | InnerShadowFilter | GaussianBlurFilter | MotionBlurFilter | PointLightFilter | SpotLightFilter | DiffuseLightingFilter | SpecularLightingFilter | OutlineFilter | SharpenFilter | PixelateFilter | WarpFilter | MorphologyFilter | ContouringDiscreteFilter | ContouringTableFilter | RoundEdgesFilter | GrayscaleFilter | ChannelPainterFilter | BrightnessFilter | ContrastFilter | OpacityFilter | InvertFilter | HueRotateFilter | SaturateFilter | BlackAndWhiteFilter | SepiaFilter | DuotoneFilter | XrayFilter | NoiseFilter | EmbossFilter | FilmGrainFilter | WatercolorFilter | GouacheFilter | InkBlotFilter | CrumpledPlasticFilter | RiddledFilter | GlowFilter | InnerGlowFilter | RawSvgFilter;
-type SegmentCurveType = 'LINEAR' | 'CUBIC' | 'QUADRATIC' | 'ARC';
-interface SplinePoint {
+type ShapeFilter = DropShadowFilter | InnerShadowFilter | GaussianBlurFilter | MotionBlurFilter | PointLightFilter | SpotLightFilter | DiffuseLightingFilter | SpecularLightingFilter | OutlineFilter | SharpenFilter | PixelateFilter | WarpFilter | MorphologyFilter | ContouringDiscreteFilter | ContouringTableFilter | RoundEdgesFilter | GrayscaleFilter | ChannelPainterFilter | BrightnessFilter | ContrastFilter | OpacityFilter | InvertFilter | HueRotateFilter | SaturateFilter | BlackAndWhiteFilter | SepiaFilter | DuotoneFilter | XrayFilter | NoiseFilter | EmbossFilter | FilmGrainFilter | WatercolorFilter | GouacheFilter | InkBlotFilter | CrumpledPlasticFilter | RiddledFilter | GlowFilter | InnerGlowFilter | RawSvgFilter | SvgPrimitiveChainFilter;
+/** Common attributes on every filter primitive (FE1 §7.2). */
+interface BaseFilterPrimitive {
+    /** Editor-only stable id; not serialized to SVG. */
+    id: string;
+    /** SourceGraphic | SourceAlpha | BackgroundImage | BackgroundAlpha |
+     *  FillPaint | StrokePaint | <filter-primitive-reference>. Omitted ⇒
+     *  defaults to previous primitive's result (or SourceGraphic if first). */
+    in?: string;
+    /** Custom result name for forward references. Omitted ⇒ implicit. */
+    result?: string;
+    /** Filter primitive subregion (FE1 §7.3). */
+    x?: string;
+    y?: string;
+    width?: string;
+    height?: string;
+    /** Per-primitive override of color-interpolation-filters. */
+    colorInterpolationFilters?: 'auto' | 'sRGB' | 'linearRGB';
+    /** Carry of attributes the editor doesn't model (style, class, data-*,
+     *  unknown spec attrs). Re-emitted verbatim. Keys exclude attrs already
+     *  modeled on this primitive. */
+    unknownAttrs?: Record<string, string>;
+    /** SMIL animation children attached to this primitive — preserved
+     *  verbatim. Each entry is the outerHTML of an <animate>, <set>,
+     *  <animateTransform>, or <animateMotion> element. */
+    animations?: string[];
+}
+/** Blend modes per Compositing 1 §3 + the FE1-specific extensions. */
+type FilterBlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity' | 'plus-darker' | 'plus-lighter';
+interface FeBlendPrimitive extends BaseFilterPrimitive {
+    type: 'feBlend';
+    in2?: string;
+    mode?: FilterBlendMode;
+    /** FE1 extension — boolean attribute, presence-based. */
+    noComposite?: boolean;
+}
+interface FeColorMatrixPrimitive extends BaseFilterPrimitive {
+    type: 'feColorMatrix';
+    matrixType?: 'matrix' | 'saturate' | 'hueRotate' | 'luminanceToAlpha';
+    /** Verbatim attribute string so we preserve the exact author spelling
+     *  (matrix arg counts, whitespace inside). Omitted ⇒ spec defaults
+     *  apply (matrix=identity, saturate=1, hueRotate=0). */
+    values?: string;
+}
+type TransferFunc = {
+    type: 'identity';
+} | {
+    type: 'table' | 'discrete';
+    tableValues: number[];
+} | {
+    type: 'linear';
+    slope?: number;
+    intercept?: number;
+} | {
+    type: 'gamma';
+    amplitude?: number;
+    exponent?: number;
+    offset?: number;
+};
+interface FeComponentTransferPrimitive extends BaseFilterPrimitive {
+    type: 'feComponentTransfer';
+    funcR?: TransferFunc;
+    funcG?: TransferFunc;
+    funcB?: TransferFunc;
+    funcA?: TransferFunc;
+}
+interface FeCompositePrimitive extends BaseFilterPrimitive {
+    type: 'feComposite';
+    in2?: string;
+    operator?: 'over' | 'in' | 'out' | 'atop' | 'xor' | 'lighter' | 'arithmetic';
+    k1?: number;
+    k2?: number;
+    k3?: number;
+    k4?: number;
+}
+interface FeConvolveMatrixPrimitive extends BaseFilterPrimitive {
+    type: 'feConvolveMatrix';
+    /** <number-optional-number>; preserved as authored (e.g. "3" or "3 3"). */
+    order?: string;
+    /** Space-separated kernel values, preserved as authored. */
+    kernelMatrix?: string;
+    divisor?: number;
+    bias?: number;
+    targetX?: number;
+    targetY?: number;
+    edgeMode?: 'duplicate' | 'wrap' | 'none';
+    /** <number-optional-number>; preserved as authored. */
+    kernelUnitLength?: string;
+    preserveAlpha?: boolean;
+}
+/** Light source elements (FE1 §16) — never appear at <filter> top level,
+ *  only as children of feDiffuseLighting/feSpecularLighting. */
+type FilterLightSource = {
+    kind: 'feDistantLight';
+    azimuth?: number;
+    elevation?: number;
+} | {
+    kind: 'fePointLight';
+    x?: number;
+    y?: number;
+    z?: number;
+} | {
+    kind: 'feSpotLight';
+    x?: number;
+    y?: number;
+    z?: number;
+    pointsAtX?: number;
+    pointsAtY?: number;
+    pointsAtZ?: number;
+    specularExponent?: number;
+    limitingConeAngle?: number;
+};
+interface FeDiffuseLightingPrimitive extends BaseFilterPrimitive {
+    type: 'feDiffuseLighting';
+    surfaceScale?: number;
+    diffuseConstant?: number;
+    /** <number-optional-number>; preserved as authored. */
+    kernelUnitLength?: string;
+    lightingColor?: string;
+    lightSource?: FilterLightSource;
+}
+interface FeSpecularLightingPrimitive extends BaseFilterPrimitive {
+    type: 'feSpecularLighting';
+    surfaceScale?: number;
+    specularConstant?: number;
+    specularExponent?: number;
+    kernelUnitLength?: string;
+    lightingColor?: string;
+    lightSource?: FilterLightSource;
+}
+interface FeDisplacementMapPrimitive extends BaseFilterPrimitive {
+    type: 'feDisplacementMap';
+    in2?: string;
+    scale?: number;
+    xChannelSelector?: 'R' | 'G' | 'B' | 'A';
+    yChannelSelector?: 'R' | 'G' | 'B' | 'A';
+}
+interface FeDropShadowPrimitive extends BaseFilterPrimitive {
+    type: 'feDropShadow';
+    dx?: number;
+    dy?: number;
+    /** <number-optional-number>; preserved as authored. */
+    stdDeviation?: string;
+    floodColor?: string;
+    /** Numeric value or the literal 'inherit'. */
+    floodOpacity?: string;
+}
+interface FeFloodPrimitive extends BaseFilterPrimitive {
+    type: 'feFlood';
+    floodColor?: string;
+    floodOpacity?: string;
+}
+interface FeGaussianBlurPrimitive extends BaseFilterPrimitive {
+    type: 'feGaussianBlur';
+    /** <number-optional-number>; preserved as authored (e.g. "3" or "3 1"). */
+    stdDeviation?: string;
+    edgeMode?: 'duplicate' | 'wrap' | 'none';
+}
+interface FeImagePrimitive extends BaseFilterPrimitive {
+    type: 'feImage';
+    /** Canonical (SVG 2). */
+    href?: string;
+    /** Back-compat alias re-emitted only when the original used xlink:href
+     *  and no href was authored. */
+    xlinkHref?: string;
+    preserveAspectRatio?: string;
+    crossorigin?: 'anonymous' | 'use-credentials';
+}
+interface FeMergePrimitive extends BaseFilterPrimitive {
+    type: 'feMerge';
+    /** <feMergeNode> children inlined. */
+    nodes: {
+        in?: string;
+    }[];
+}
+interface FeMorphologyPrimitive extends BaseFilterPrimitive {
+    type: 'feMorphology';
+    operator?: 'erode' | 'dilate';
+    /** <number-optional-number>; preserved as authored. */
+    radius?: string;
+}
+interface FeOffsetPrimitive extends BaseFilterPrimitive {
+    type: 'feOffset';
+    dx?: number;
+    dy?: number;
+}
+interface FeTilePrimitive extends BaseFilterPrimitive {
+    type: 'feTile';
+}
+interface FeTurbulencePrimitive extends BaseFilterPrimitive {
+    type: 'feTurbulence';
+    /** <number-optional-number>; preserved as authored. */
+    baseFrequency?: string;
+    numOctaves?: number;
+    seed?: number;
+    stitchTiles?: 'stitch' | 'noStitch';
+    turbulenceType?: 'fractalNoise' | 'turbulence';
+}
+type FilterPrimitive = FeBlendPrimitive | FeColorMatrixPrimitive | FeComponentTransferPrimitive | FeCompositePrimitive | FeConvolveMatrixPrimitive | FeDiffuseLightingPrimitive | FeSpecularLightingPrimitive | FeDisplacementMapPrimitive | FeDropShadowPrimitive | FeFloodPrimitive | FeGaussianBlurPrimitive | FeImagePrimitive | FeMergePrimitive | FeMorphologyPrimitive | FeOffsetPrimitive | FeTilePrimitive | FeTurbulencePrimitive;
+type FilterPrimitiveType = FilterPrimitive['type'];
+/**
+ * A `<filter>` element modeled as an ordered list of editable primitives.
+ *
+ * This variant is the parser's default when no curated stylized preset
+ * matches — it preserves every spec primitive 1:1 so imported third-party
+ * SVG round-trips with semantic equivalence and remains editable in the
+ * filters panel. Distinct from `RawSvgFilter` (which is opaque XML
+ * passthrough); this one walks the primitives.
+ */
+interface SvgPrimitiveChainFilter extends BaseFilter {
+    type: 'svg-primitive-chain';
+    /** <filter> wrapper attributes — all optional; omitted ⇒ UA spec default. */
+    filterUnits?: 'userSpaceOnUse' | 'objectBoundingBox';
+    primitiveUnits?: 'userSpaceOnUse' | 'objectBoundingBox';
+    x?: string;
+    y?: string;
+    width?: string;
+    height?: string;
+    filterColorInterpolation?: 'auto' | 'sRGB' | 'linearRGB';
+    /** Inheritable presentation attrs author placed on <filter> so child
+     *  primitives can resolve them via the CSS `inherit` keyword. */
+    floodColor?: string;
+    floodOpacity?: string;
+    lightingColor?: string;
+    /** <title> child text, captured for a11y/round-trip. */
+    filterTitle?: string;
+    filterDescription?: string;
+    /** SMIL animation children directly on <filter> (rare). */
+    filterAnimations?: string[];
+    /** The primitive chain. Order is significant — implicit input chains
+     *  match document order. */
+    primitives: FilterPrimitive[];
+}
+/**
+ * Per-segment command hint, recording the SVG path command the segment
+ * was authored with. Lets the serializer emit the original command form
+ * (H, V, S, T, A) when the current geometry still satisfies its
+ * constraints — and auto-demote to L/C/Q when a user edit invalidates
+ * the shorthand condition. Replaces the old `originalD` round-trip
+ * cache with a property of the geometry itself.
+ *
+ *  - LINEAR            → `L` (default for handle-less segments)
+ *  - HORIZONTAL        → `H`; valid when `from.y === to.y`
+ *  - VERTICAL          → `V`; valid when `from.x === to.x`
+ *  - CUBIC             → `C`
+ *  - SMOOTH_CUBIC      → `S`; valid when `to.handleIn` reflects the previous
+ *                        segment's exit-tangent about the previous endpoint
+ *  - QUADRATIC         → `Q`
+ *  - SMOOTH_QUADRATIC  → `T`; valid when the implicit control reflects the
+ *                        previous quadratic's control about the current point
+ *  - ARC               → `A`
+ */
+type SegmentCurveType = 'LINEAR' | 'HORIZONTAL' | 'VERTICAL' | 'CUBIC' | 'SMOOTH_CUBIC' | 'QUADRATIC' | 'SMOOTH_QUADRATIC' | 'ARC';
+interface PathPoint {
     x: number;
     y: number;
     handleIn?: Point;
     handleOut?: Point;
-    pointType: SplinePointType;
+    pointType: PathPointType;
     isSubpathStart?: boolean;
     segmentType?: SegmentCurveType;
     arcParams?: ArcParams$1;
@@ -850,6 +1146,12 @@ interface ArcParams$1 {
     largeArc: boolean;
     sweep: boolean;
 }
+/**
+ * Hyperlink target per SVG 2 §16.2. Kept for UI convenience — the four
+ * well-known keywords plus any authored `<XML-Name>` (custom named
+ * browsing context). Hyperlink shapes themselves store target as a plain
+ * string so arbitrary names round-trip.
+ */
 type LinkTarget = '_self' | '_blank' | '_parent' | '_top';
 type AriaRole = '' | 'img' | 'button' | 'link' | 'presentation' | 'none' | 'graphics-document' | 'graphics-object' | 'graphics-symbol';
 interface ShapeMetadata {
@@ -859,9 +1161,14 @@ interface ShapeMetadata {
     description: string;
     role: AriaRole;
     ariaLabel: string;
-    linkUrl: string;
-    linkTarget: LinkTarget;
     customData: Record<string, string>;
+    /**
+     * Hyperlink target — when set, the shape is rendered inside an SVG `<a>`
+     * element with `href="${linkUrl}"`. Round-trips through SVG import/export.
+     */
+    linkUrl?: string;
+    /** Hyperlink target window — maps to `<a target="...">`. */
+    linkTarget?: LinkTarget;
     /**
      * Lossless carrier for any `<metadata>` elements that appeared as children
      * of this shape's SVG element. Stored as a serialized string containing
@@ -1028,6 +1335,24 @@ interface DocumentStyle {
 }
 /** Type of a template variable's value. */
 type TemplateVariableType = 'string' | 'color' | 'number';
+/**
+ * How the variable participates in export. Two genuinely different
+ * substitution mechanisms — declaring intent up-front lets the export
+ * pipeline pick the right one.
+ *
+ *   - `live`     → emitted as `var(--name, fallback)` references; the
+ *                  variable definition rides along in a `<style>` block,
+ *                  so consumers can re-theme the SVG at runtime via the
+ *                  CSS cascade.
+ *   - `stamped`  → resolved to its literal value at export time. Used
+ *                  for `{{name}}` template-style stamping, and for
+ *                  attributes (`width`, `x`, geometry) where `var()`
+ *                  in attribute values has uneven interop.
+ *
+ * Defaults to `live` for `color` (well-supported in browsers), `stamped`
+ * for `number`/`string` (where attribute-level var() is unreliable).
+ */
+type TemplateVariableMode = 'live' | 'stamped';
 /**
  * Where a TemplateVariable came from. `user` is hand-authored in the
  * Variables panel; `palette` is auto-generated by the palette-token
@@ -1074,7 +1399,19 @@ interface TemplateVariable {
      * settings palette.
      */
     source?: TemplateVariableSource;
+    /**
+     * Substitution mode at export time. When omitted, callers should
+     * apply the type-based default in `defaultVariableMode()`:
+     * `color` → `live`, `number`/`string` → `stamped`.
+     */
+    mode?: TemplateVariableMode;
 }
+/**
+ * Type-based default substitution mode. Color variables work reliably as
+ * runtime `var()` references in browsers; numbers and strings are far
+ * better baked into literal attribute values at export time.
+ */
+declare function defaultVariableMode(type: TemplateVariableType): TemplateVariableMode;
 interface Guide {
     id: string;
     orientation: 'horizontal' | 'vertical';
@@ -1148,11 +1485,31 @@ interface SerializedShape {
         textDirection?: 'ltr' | 'rtl';
         unicodeBidi?: 'normal' | 'embed' | 'bidi-override' | 'isolate' | 'isolate-override' | 'plaintext';
         fontVariationSettings?: Record<string, number>;
-        charOffsets?: {
+        /**
+         * Per-glyph positioning data, mirroring SVG 2 §11.2's five attribute
+         * lists (`x`, `y`, `dx`, `dy`, `rotate`).
+         *
+         *  - `x`/`y` are absolute user coordinates; `null` means "no
+         *    override at this glyph — the cursor advances naturally".
+         *  - `dx`/`dy` are additive shifts on top of natural advance.
+         *  - `rotate` is per-glyph rotation in degrees.
+         *
+         * For backward compatibility, the legacy three-field shape
+         * `{x, y, rotate}` (produced before the spec-aligned model shipped)
+         * is still accepted on read; its `x`/`y` are interpreted as the
+         * additive shifts (`dx`/`dy`).
+         */
+        charOffsets?: ({
+            x: number | null;
+            y: number | null;
+            dx: number;
+            dy: number;
+            rotate: number;
+        } | {
             x: number;
             y: number;
             rotate: number;
-        }[];
+        })[];
         linePositions?: {
             x: number;
             dy: number;
@@ -1181,9 +1538,29 @@ interface SerializedShape {
         borderColor?: string;
         borderWidth?: number | string;
         strokeOpacity?: number;
+        /**
+         * Inherit `fill` from the ancestor cascade rather than emit an explicit
+         * attribute. Set at import for shapes inside `<defs>`/`<symbol>` that
+         * have no own `fill` — they're reachable only via `<use>`, whose shadow
+         * tree inherits paint from the `<use>` element itself (SVG 2 §5.5.4).
+         * Baking the SVG-default black onto the inner shape would block the
+         * `<use fill="…">` cascade and render the instance override dead.
+         */
+        inheritFill?: boolean;
+        /** See {@link inheritFill}. */
+        inheritStroke?: boolean;
         /** CSS `paint-order` (SVG 2). Canonical SVG token string, e.g.
          *  'stroke fill markers'. Omitted when equivalent to default 'normal'. */
         paintOrder?: string;
+        /**
+         * CSS Transforms 2 §6.2 — `transform-box` reference box. SVG
+         * default is `view-box`; persisted on the shape so authored values
+         * (`fill-box`, `stroke-box`) survive round-trip. The editor bakes
+         * `transform-origin` into a numeric pivot at import using the
+         * resolved box, so this field exists for export fidelity rather
+         * than rendering.
+         */
+        transformBox?: 'view-box' | 'fill-box' | 'stroke-box' | 'content-box' | 'border-box';
         /** Marker id applied as `marker-start` (rendered `url(#id)` in SVG). */
         markerStart?: string;
         /** Marker id applied as `marker-mid`. */
@@ -1304,17 +1681,49 @@ interface SerializedShape {
         /** @deprecated v2 — see `filterX`. */
         filterHeight?: string;
         rawTransform?: string;
-        splinePoints?: SplinePoint[];
-        splineCurveType?: SplineCurveType;
-        splineClosed?: boolean;
-        splineTension?: number;
-        splineArcParams?: ArcParams$1[];
+        ancestorTransform?: number[];
+        pathPoints?: PathPoint[];
+        pathCurveType?: PathCurveType;
+        pathClosed?: boolean;
+        pathTension?: number;
+        pathArcParams?: ArcParams$1[];
+        /**
+         * SVG 2 §6 `pathLength` — author's stated total length of the path.
+         * Used to scale distance-along-a-path computations (text-on-path,
+         * `<animateMotion>`, `stroke-dasharray`) by `pathLength / actualLength`.
+         * A non-negative number; negative values are an error per spec.
+         */
+        pathLength?: number;
+        /**
+         * CSS Vector Effects — `vector-effect` property. `non-scaling-stroke`
+         * keeps stroke width constant under zoom/transforms (heavily used in
+         * CAD/diagram SVGs). Applies to any graphic element, not just paths;
+         * persists at the SerializedShape state level so all shape types can
+         * round-trip it.
+         */
+        vectorEffect?: 'none' | 'non-scaling-stroke' | 'non-scaling-size' | 'non-rotation' | 'fixed-position';
         polylinePoints?: Point[];
         polylineClosed?: boolean;
         href?: string;
         originalWidth?: number;
         originalHeight?: number;
+        /**
+         * Editor-internal flag controlling whether interactive resize keeps
+         * the image's natural aspect ratio. NOT the SVG `preserveAspectRatio`
+         * attribute — this is purely a UX behavior switch on the resize
+         * handles. Persisted so the user's setting survives reload.
+         */
         preserveAspectRatio?: boolean;
+        /**
+         * SVG 2 §8.7 — verbatim `preserveAspectRatio` attribute value
+         * (e.g. `'xMidYMid slice'`, `'defer xMidYMid meet'`, `'none'`). When
+         * unset, the spec default applies. The editor canvas always renders
+         * `<image>` with `preserveAspectRatio="none"` so the visible box
+         * matches the resize handles; this field carries the author's
+         * intent through round-trip and is restored on export by
+         * `SvgExportFinalizer`.
+         */
+        specPreserveAspectRatio?: string;
         imageOpacity?: number;
         mediaKind?: 'audio' | 'video';
         mediaMimeType?: string;
@@ -1350,12 +1759,36 @@ interface SerializedShape {
          * soundtracks / captioned video versions.
          */
         systemLanguage?: string;
+        /**
+         * Space-separated list of required IRI references that the user agent
+         * must support for this shape to be rendered. SVG 2 §15.4 conditional
+         * processing — typically `http://www.w3.org/TR/SVG11/feature#…` strings.
+         * Persisted alongside `systemLanguage` so `<switch>` content round-trips.
+         */
+        requiredExtensions?: string;
         shapeInsideRef?: string;
         shapePadding?: number;
         isTextPath?: boolean;
-        textPathPoints?: SplinePoint[];
+        textPathPoints?: PathPoint[];
+        /**
+         * Curve type used to interpolate `textPathPoints` into a renderable
+         * path. Mirrors `pathCurveType` for plain path shapes; persisted
+         * separately so author-set text-path curves don't have to share the
+         * shape's geometry curve type.
+         */
+        textPathCurveType?: PathCurveType;
         textPathStartOffset?: number;
+        textPathStartOffsetUnit?: '%' | 'user';
         textPathSide?: 'left' | 'right';
+        textPathMethod?: 'align' | 'stretch';
+        textPathSpacing?: 'auto' | 'exact';
+        textPathLengthAdjust?: 'spacing' | 'spacingAndGlyphs';
+        textPathLength?: number;
+        textPathLengthUnit?: '%' | 'user';
+        textPathInlineFormat?: 'defs-path' | 'path-attr';
+        textPathRefShapeId?: string;
+        /** Transient: import-time href target id, resolved away by ImportExportManager. */
+        textPathImportRefId?: string;
         fillRule?: 'nonzero' | 'evenodd';
         strokeLinejoin?: 'miter' | 'round' | 'bevel';
         strokeLinecap?: 'butt' | 'round' | 'square';
@@ -1382,6 +1815,33 @@ interface SerializedShape {
          * variant (`def.shapes`). Only meaningful on `symbol-instance` shapes.
          */
         variantKey?: string;
+        /**
+         * Per-instance presentation cascade (SVG 2 §5.5.4): attributes set on
+         * the source `<use>` element that are inherited into the symbol shadow
+         * tree on render and re-emitted on export. Keyed by the SVG attribute
+         * name in its canonical kebab-case form (`fill`, `stroke-width`,
+         * `color-interpolation-filters`, `paint-order`, etc.). Values are the
+         * verbatim attribute string — numeric parsing happens at the edit /
+         * render boundary, not at storage time.
+         *
+         * The map is the single source of truth: importing a `<use>` stores
+         * every presentation-class attribute the author wrote, applying it
+         * mirrors every entry onto the wrapper `<g>`, and exporting emits
+         * every entry back onto the `<use>`. No whitelist — any attribute the
+         * SVG cascade honors round-trips.
+         *
+         * Special case: `transform` is composed with the editor's geometry
+         * (position / rotation / skew / scale) rather than applied raw to the
+         * wrapper. See `SymbolInstance.buildTransformString`.
+         *
+         * Legacy (pre-refactor) documents may carry camelCase keys
+         * (`fillOpacity`, `strokeWidth`, …). `SymbolInstance.createFromSerialized`
+         * normalises them to kebab-case on load; no runtime readers of this
+         * field should assume either form.
+         *
+         * Only meaningful on `symbol-instance` shapes.
+         */
+        instancePresentation?: Record<string, string>;
         /**
          * Id of the canvas shape this `shape-reference` (Linked Copy) targets.
          * A Linked Copy renders as a live clone of another top-level shape and
@@ -1446,6 +1906,44 @@ interface SerializedShape {
         topWidthPercent?: number;
         /** Document shape: wave amplitude as a % of height. */
         waveAmplitudePercent?: number;
+        /** View shape: viewBox X component (animatable axis of the 4-tuple). */
+        viewBoxX?: number;
+        /** View shape: viewBox Y component (animatable axis of the 4-tuple). */
+        viewBoxY?: number;
+        /** View shape: viewBox width component (animatable axis of the 4-tuple). */
+        viewBoxWidth?: number;
+        /** View shape: viewBox height component (animatable axis of the 4-tuple). */
+        viewBoxHeight?: number;
+        /** View shape: name used as `<view id="...">` and fragment URL target. */
+        viewName?: string;
+        /** View shape: optional preserveAspectRatio (SVG 2 §7.8 — animatable). */
+        viewPreserveAspectRatio?: string;
+        /** View shape: SVG 1.1 §16.5 zoomAndPan. */
+        viewZoomAndPan?: 'disable' | 'magnify';
+        /** View shape: deprecated SVG 1.1 viewTarget — preserved verbatim. */
+        viewTarget?: string;
+        /** View shape: when true, this View's viewBox becomes the root SVG viewBox. */
+        isHomeView?: boolean;
+        /** SvgShape: viewBox X component (animatable). */
+        svgViewBoxX?: number;
+        /** SvgShape: viewBox Y component (animatable). */
+        svgViewBoxY?: number;
+        /** SvgShape: viewBox width component (animatable). */
+        svgViewBoxWidth?: number;
+        /** SvgShape: viewBox height component (animatable). */
+        svgViewBoxHeight?: number;
+        /** SvgShape: preserveAspectRatio (SVG 2 §7.8 — animatable, discrete). */
+        svgPreserveAspectRatio?: string;
+        /** SvgShape: outermost = intrinsic doc size, embedded = viewport rect width. */
+        svgWidth?: number;
+        /** SvgShape: outermost = intrinsic doc size, embedded = viewport rect height. */
+        svgHeight?: number;
+        /** SvgShape: x position (no effect on outermost per §5.1.4 ¶3, embedded only). */
+        svgX?: number;
+        /** SvgShape: y position (no effect on outermost per §5.1.4 ¶3, embedded only). */
+        svgY?: number;
+        /** SvgShape: marks the singleton root <svg> shape (one per document). */
+        isRootSvg?: boolean;
     };
 }
 type SerializedViewbox = Viewbox;
@@ -1507,6 +2005,18 @@ interface HistorySnapshot {
      * MarkerManager and are NOT persisted here — only user-authored defs are.
      */
     library?: LibraryDef[];
+    /**
+     * Raw XML fragments for `<mask>` / `<clipPath>` defs that live in editor
+     * defs but have no typed entry in `library`. Populated by paste pipelines
+     * that clone source paint-server defs verbatim (preserving original ids so
+     * `url(#id)` refs resolve). Without this field, the save/reload cycle
+     * drops the masks entirely because `library` has no kind for them; shapes
+     * that reference those ids render without their mask.
+     *
+     * Each entry is a serialised fragment (`<mask id="…">…</mask>`) ready to
+     * `innerHTML`-append into editor defs on restore.
+     */
+    rawPaintServerDefs?: string[];
     /** @deprecated v2 — use `library`. Read-only: v1 docs migrate into `library`. */
     customPatterns?: CustomPatternDef[];
     /** @deprecated v2 — use `library`. Read-only: v1 docs migrate into `library`. */
@@ -1556,6 +2066,14 @@ interface SerializedGroup {
     parentId: string | null;
     /** CSS transform-origin value (e.g. "50px 50px") for group animations */
     transformOrigin?: string;
+    /**
+     * SVG `<g>` transform attribute (e.g. "matrix(...)" or "scale(2,1)").
+     * Preserved verbatim from import so the group carries its ancestor/own
+     * transform through serialization (clipboard, undo/redo, collab).
+     * Shapes inside stay in the group's local frame — the browser composes
+     * `groupTransform × child` natively at render.
+     */
+    transform?: string;
     /**
      * Zero-based position of this group among its parent container's
      * children (including both sibling groups and sibling shape nodes).
@@ -1700,7 +2218,28 @@ interface LibraryDefBase {
  */
 interface SymbolLibraryDef extends LibraryDefBase {
     kind: 'symbol';
+    /**
+     * Source SVG element form for round-trip fidelity. Most symbols are
+     * authored as `<symbol>` (SVG 2 §5.5.1); `<defs><g id="X"/>` referenced
+     * by `<use href="#X"/>` is a legally distinct pattern that the editor
+     * also models as a SymbolLibraryDef but must export as `<g>` to remain
+     * spec-faithful — `<symbol>` would silently introduce viewport-
+     * establishment (SVG 2 §5.5.2) and `overflow: hidden` defaulting that
+     * the source `<g>` does not have. Default `'symbol'` for backward
+     * compatibility with documents authored before this field existed.
+     */
+    defKind?: 'symbol' | 'group';
     viewBox: string;
+    /**
+     * Wrapper attributes from the source `<g id="X">` def root that apply to
+     * the def's contents (transform, opacity, fill cascade, mask, filter,
+     * clip-path). Re-emitted on the exported `<g id="X">` when `defKind === 'group'`
+     * — `<symbol>` doesn't legally accept these attributes per SVG 2 §5.5.1.
+     * Without this, `<use href="#X"/>` would silently render the children at
+     * their unwrapped local coords / paint, losing every non-id attribute on
+     * the source `<g>` def root.
+     */
+    wrapperAttrs?: Record<string, string>;
     /**
      * Default variant shapes. When `variantAxes` is present this represents the
      * variant where every axis is at its first value.
@@ -1858,6 +2397,7 @@ interface CommonNodeProps {
     filterWidth: string | null;
     filterHeight: string | null;
     rawTransform: string | null;
+    ancestorTransform: number[] | null;
     metadata: unknown | null;
     cssClipPath: string | null;
     cssMaskProperties: Record<string, string> | null;
@@ -1933,11 +2473,22 @@ interface TextNodeProps extends CommonNodeProps {
     scaleAnchor: Point | null;
     useRichText: boolean;
     richTextData: unknown | null;
-    charOffsets: {
+    /**
+     * Per-glyph positioning data — see `SerializedShape['state'].charOffsets`
+     * in `serialized.ts` for full semantics.  Legacy `{x, y, rotate}` form
+     * accepted on read for back-compat with pre-spec-aligned saves.
+     */
+    charOffsets: ({
+        x: number | null;
+        y: number | null;
+        dx: number;
+        dy: number;
+        rotate: number;
+    } | {
         x: number;
         y: number;
         rotate: number;
-    }[] | null;
+    })[] | null;
     fontVariationSettings: Record<string, number>;
     isTextPath: boolean;
     textPathPoints: unknown[] | null;
@@ -1957,14 +2508,14 @@ interface ImageNodeProps extends CommonNodeProps {
     preserveAspectRatio: boolean;
     imageOpacity: number;
 }
-interface SplineNodeProps extends CommonNodeProps {
+interface PathNodeProps extends CommonNodeProps {
     x: number;
     y: number;
     width: number;
     height: number;
-    splinePoints: unknown[];
-    splineArcParams: unknown[];
-    splineControlBounds: {
+    pathPoints: unknown[];
+    pathArcParams: unknown[];
+    pathControlBounds: {
         x: number;
         y: number;
         width: number;
@@ -2042,7 +2593,7 @@ interface NodeTypePropsMap {
     line: LineNodeProps;
     text: TextNodeProps;
     image: ImageNodeProps;
-    spline: SplineNodeProps;
+    path: PathNodeProps;
     polyline: PolylineNodeProps;
     triangle: TriangleNodeProps;
     ngon: NGonNodeProps;
@@ -2057,7 +2608,7 @@ interface NodeTypePropsMap {
     document: DocumentNodeProps;
 }
 /** Union of all node prop types. */
-type AnyNodeProps = RectangleNodeProps | SquareNodeProps | CircleNodeProps | EllipseNodeProps | LineNodeProps | TextNodeProps | ImageNodeProps | SplineNodeProps | PolylineNodeProps | TriangleNodeProps | NGonNodeProps | StarNodeProps | CrossNodeProps | RingNodeProps | SpiralNodeProps | GearNodeProps | ArrowNodeProps | SymbolInstanceNodeProps | GroupNodeProps | DocumentNodeProps;
+type AnyNodeProps = RectangleNodeProps | SquareNodeProps | CircleNodeProps | EllipseNodeProps | LineNodeProps | TextNodeProps | ImageNodeProps | PathNodeProps | PolylineNodeProps | TriangleNodeProps | NGonNodeProps | StarNodeProps | CrossNodeProps | RingNodeProps | SpiralNodeProps | GearNodeProps | ArrowNodeProps | SymbolInstanceNodeProps | GroupNodeProps | DocumentNodeProps;
 
 /**
  * @svgsketch/core — Schema migrations.
@@ -2452,6 +3003,28 @@ declare function renderToSvg(snapshot: HistorySnapshot, options?: RenderOptions)
  * @packageDocumentation
  */
 
+/**
+ * Render a single `FilterPrimitive` to its SVG element string.
+ *
+ * Walks every modeled spec attribute and re-emits it. Author-preserved
+ * attributes (e.g. <number-optional-number> spellings, kernelMatrix
+ * whitespace) are stored as strings on the primitive and emitted verbatim,
+ * so import → render produces semantically equivalent output.
+ *
+ * `unknownAttrs` are emitted last (alphabetised) so re-export is stable.
+ * `animations` children are appended inside the element.
+ */
+declare function renderFilterPrimitive(p: FilterPrimitive): string;
+/**
+ * Render an `SvgPrimitiveChainFilter` as a complete `<filter>` element.
+ *
+ * Wrapper attributes are author-faithful: omitted ⇒ unset on the element ⇒
+ * UA spec defaults apply (filterUnits=objectBoundingBox, primitiveUnits=
+ * userSpaceOnUse, region -10%/-10%/120%/120%, color-interpolation-filters=
+ * linearRGB). The chain is emitted in document order with no synthetic
+ * `in`/`result` rewriting.
+ */
+declare function renderSvgPrimitiveChainFilter(filterId: string, f: SvgPrimitiveChainFilter): string;
 /**
  * Render SVG filter primitive string(s) for a single filter.
  *
@@ -3600,26 +4173,26 @@ declare class Arrow extends PolygonShapeBuilder<Arrow> {
     /** Set the arrow shaft width as a percent (0–100). */
     shaftWidth(percent: number): Arrow;
 }
-declare class Spline extends ShapeBuilder<Spline> {
-    constructor(points?: (Point | SplinePoint)[]);
+declare class Path extends ShapeBuilder<Path> {
+    constructor(points?: (Point | PathPoint)[]);
     /** Set the spline points. */
-    points(pts: (Point | SplinePoint)[]): Spline;
+    points(pts: (Point | PathPoint)[]): Path;
     /** Add a point to the spline. */
-    addPoint(x: number, y: number): Spline;
+    addPoint(x: number, y: number): Path;
     /** Set the curve type. */
-    curveType(type: SplineCurveType): Spline;
+    curveType(type: PathCurveType): Path;
     /** Set whether the spline is closed. */
-    closed(value?: boolean): Spline;
+    closed(value?: boolean): Path;
     /** Set the tension for Catmull-Rom curves (0–1). */
-    tension(value: number): Spline;
+    tension(value: number): Path;
     /** Set arc params for ARC curve type. */
-    arcParams(params: ArcParams$1[]): Spline;
+    arcParams(params: ArcParams$1[]): Path;
     /** Set the start endpoint marker. */
-    markerStart(style: EndpointStyle): Spline;
+    markerStart(style: EndpointStyle): Path;
     /** Set the end endpoint marker. */
-    markerEnd(style: EndpointStyle): Spline;
+    markerEnd(style: EndpointStyle): Path;
     /** Convenience: set both markers. */
-    markers(start: EndpointStyle, end: EndpointStyle): Spline;
+    markers(start: EndpointStyle, end: EndpointStyle): Path;
 }
 declare class Polyline extends ShapeBuilder<Polyline> {
     constructor(points?: Point[]);
@@ -3746,7 +4319,7 @@ declare class Track {
      *
      * @example
      * ```ts
-     * const curve = new Spline(...).id('curve');
+     * const curve = new Path(...).id('curve');
      * doc.add(curve);
      *
      * const track = new Track('rect-1', 'pathMotion')
@@ -4178,4 +4751,4 @@ declare class Document {
     private _ensureMetadata;
 }
 
-export { type AnimatablePropertyDescriptor, type AnimationKeyframe, type AnimationTimeline, type AnimationTrack, type AnimationTrigger, type AnimationTriggerType, type AnyNodeProps, type ArcParams$1 as ArcParams, type AriaRole, Arrow, type ArrowNodeProps, BUILTIN_MARKER_ID_MAP, type BaseFilter, type BlackAndWhiteFilter, type BlurQuality, type BrightnessFilter, CURRENT_SCHEMA_VERSION, type ChannelPainterFilter, Circle, type CircleNodeProps, type CodeFormat, type CodegenOptions, type CommonNodeProps, type ConnectionDirection, type ConnectionPoint, type ContouringDiscreteFilter, type ContouringTableFilter, type ContrastFilter, type CornerShapeValue, type CreateDocumentOptions, type CreateShapeOptions, Cross, type CrossNodeProps, type CrumpledPlasticFilter, type CustomPatternDef, type CycleBehavior, DEFAULT_COORDINATE_PRECISION, type DiffuseLightingFilter, Document, type DocumentMetadata, type DocumentNodeProps, type DocumentOptions, type DocumentScript, type DocumentStyle, type DropShadowFilter, type DuotoneFilter, EASING_CURVES, EVENT_TRIGGER_OPTIONS, EasingType, Ellipse, type EllipseNodeProps, type EmbossFilter, type ExtractedVariables, type FillType, type FilmGrainFilter, type FilterLibraryDef, type FilterType, type GaussianBlurFilter, Gear, type GearNodeProps, type GlowFilter, type GouacheFilter, type GradientDefinition, type GradientSpreadMethod, type GradientStop, type GradientUnits, type GrayscaleFilter, type GroupNodeProps, type Guide, type HistorySnapshot, type HueRotateFilter, type ImageAttribution, type ImageNodeProps, ImageShape, type InkBlotFilter, type InnerGlowFilter, type InnerShadowFilter, type InvertFilter, LIBRARY_EMIT_ORDER, type LibraryDef, type LibraryDefBase, type LibraryDefOfKind, type LibraryKind, type LicenseType, type LightSource, Line, type LineEndpointValue, type LineNodeProps, type LinearEasingPoint, type LinearGradient, LinearGradientBuilder, type LinearGradientLibraryDef, type LinkTarget, MARKER_HEIGHT, MARKER_VIEWBOX, MARKER_WIDTH, MAX_COORDINATE_PRECISION, MIGRATIONS, type MarkerDescriptor, type MarkerLibraryDef, type Measurement, type Migration, type MorphologyFilter, type MorphologyOperator, type MotionBlurFilter, NGon, type NGonNodeProps, type NodeTypePropsMap, type NoiseFilter, type OpacityFilter, type OutlineFilter, type OutlinePosition, type ParseOptions, PatternBuilder, type PatternElement, type PatternFill, type PatternLibraryDef, type PatternParams, type PatternSvgContentResult, type PatternType, type PixelateFilter, type Point, type PointLightFilter, type PolygonBaseNodeProps, Polyline, type PolylineNodeProps, type RadialGradient, RadialGradientBuilder, type RadialGradientLibraryDef, type RawSvgFilter, Rectangle, type RectangleNodeProps, type RenderOptions, type RichTextData, type RichTextLine, type RichTextSegment, type RichTextSegmentStyle, type RiddledFilter, Ring, type RingNodeProps, type RoundEdgesFilter, type SaturateFilter, type SegmentCurveType, type SepiaFilter, type SerializedAnimationTimeline, type SerializedClipMaskGroup, type SerializedGroup, type SerializedMarkerDef, type SerializedShape, type SerializedSymbolDef, type SerializedVariantAxis, type SerializedViewbox, ShapeBuilder, type ShapeFilter, type ShapeMetadata, type SharpenFilter, type SpecularLightingFilter, Spiral, type SpiralNodeProps, Spline, SplineCurveType, type SplineNodeProps, type SplinePoint, SplinePointType, type SpotLightFilter, Square, type SquareNodeProps, Star, type StarNodeProps, type StepPosition, type StepsParams, type StringifyOptions, type StrokeType, type SymbolInstanceNodeProps, type SymbolLibraryDef, type TemplateVariable, type TemplateVariableSource, type TemplateVariableType, Text, type TextNodeProps, Timeline, Track, Triangle, type TriangleNodeProps, type ValidationError, type ValidationResult, type VariableMap, type Viewbox, type WarpFilter, type WarpType, type WatercolorFilter, type XrayFilter, collectReferencedLibraryIds, computeArrowVertices, computeCloudPath, computeCrossVertices, computeDashArray, computeGearPath, computeGearVertices, computeHeartPath, computeLightningVertices, computePolygonVertices, computeRectanglePath, computeRingPath, computeSpeechBubbleVertices, computeSpiralPath, computeSplinePath, computeStarVertices, createDocument, createShape, createViewbox, escXml, extractVariables, filterAttr, generateCode, generateCssCode, generateD3Code, generateId, generatePatternSvgContent, generateReactCode, generateSvgCode, generateVueCode, getBuiltInMarkerDefs, getEasingCubicBezier, getEffectivePrecision, getMarkerDescriptors, getPatternElements, linearGradient, migrateSnapshot, parseDocument, parseVariableArgs, pattern, radialGradient, renderAnimationElements, renderBuiltinMarkerDefs, renderCircle, renderEllipse, renderFilterDefs, renderFilterLibraryDef, renderFilterPrimitivesForType, renderImage, renderLibraryDef, renderLibraryDefs, renderLine, renderLinearGradientLibraryDef, renderMarkerLibraryDef, renderPatternLibraryDef, renderPolygonShape, renderPolyline, renderRadialGradientLibraryDef, renderRectangle, renderReferencedLibraryDefs, renderShape, renderSpline, renderSymbolLibraryDef, renderText, renderToSvg, roundCoord, roundNumberString, roundSerializedShape, roundSnapshot, stringifyDocument, substituteString, substituteVariables, validateSnapshot, verticesToPath };
+export { type AnimatablePropertyDescriptor, type AnimationKeyframe, type AnimationTimeline, type AnimationTrack, type AnimationTrigger, type AnimationTriggerType, type AnyNodeProps, type ArcParams$1 as ArcParams, type AriaRole, Arrow, type ArrowNodeProps, BUILTIN_MARKER_ID_MAP, type BaseFilter, type BaseFilterPrimitive, type BlackAndWhiteFilter, type BlurQuality, type BrightnessFilter, CURRENT_SCHEMA_VERSION, type ChannelPainterFilter, Circle, type CircleNodeProps, type CodeFormat, type CodegenOptions, type CommonNodeProps, type ConnectionDirection, type ConnectionPoint, type ContouringDiscreteFilter, type ContouringTableFilter, type ContrastFilter, type CornerShapeValue, type CreateDocumentOptions, type CreateShapeOptions, Cross, type CrossNodeProps, type CrumpledPlasticFilter, type CustomPatternDef, type CycleBehavior, DEFAULT_COORDINATE_PRECISION, type DiffuseLightingFilter, Document, type DocumentMetadata, type DocumentNodeProps, type DocumentOptions, type DocumentScript, type DocumentStyle, type DropShadowFilter, type DuotoneFilter, EASING_CURVES, EVENT_TRIGGER_OPTIONS, EasingType, Ellipse, type EllipseNodeProps, type EmbossFilter, type ExtractedVariables, type FeBlendPrimitive, type FeColorMatrixPrimitive, type FeComponentTransferPrimitive, type FeCompositePrimitive, type FeConvolveMatrixPrimitive, type FeDiffuseLightingPrimitive, type FeDisplacementMapPrimitive, type FeDropShadowPrimitive, type FeFloodPrimitive, type FeGaussianBlurPrimitive, type FeImagePrimitive, type FeMergePrimitive, type FeMorphologyPrimitive, type FeOffsetPrimitive, type FeSpecularLightingPrimitive, type FeTilePrimitive, type FeTurbulencePrimitive, type FillType, type FilmGrainFilter, type FilterBlendMode, type FilterLibraryDef, type FilterLightSource, type FilterPrimitive, type FilterPrimitiveType, type FilterType, type GaussianBlurFilter, Gear, type GearNodeProps, type GlowFilter, type GouacheFilter, type GradientDefinition, type GradientSpreadMethod, type GradientStop, type GradientUnits, type GrayscaleFilter, type GroupNodeProps, type Guide, type HistorySnapshot, type HueRotateFilter, type ImageAttribution, type ImageNodeProps, ImageShape, type InkBlotFilter, type InnerGlowFilter, type InnerShadowFilter, type InvertFilter, LIBRARY_EMIT_ORDER, type LibraryDef, type LibraryDefBase, type LibraryDefOfKind, type LibraryKind, type LicenseType, type LightSource, Line, type LineEndpointValue, type LineNodeProps, type LinearEasingPoint, type LinearGradient, LinearGradientBuilder, type LinearGradientLibraryDef, type LinkTarget, MARKER_HEIGHT, MARKER_VIEWBOX, MARKER_WIDTH, MAX_COORDINATE_PRECISION, MIGRATIONS, type MarkerDescriptor, type MarkerLibraryDef, type Measurement, type Migration, type MorphologyFilter, type MorphologyOperator, type MotionBlurFilter, NGon, type NGonNodeProps, type NodeTypePropsMap, type NoiseFilter, type OpacityFilter, type OutlineFilter, type OutlinePosition, type ParseOptions, Path, PathCurveType, type PathNodeProps, type PathPoint, PathPointType, PatternBuilder, type PatternElement, type PatternFill, type PatternLibraryDef, type PatternParams, type PatternSvgContentResult, type PatternType, type PixelateFilter, type Point, type PointLightFilter, type PolygonBaseNodeProps, Polyline, type PolylineNodeProps, type RadialGradient, RadialGradientBuilder, type RadialGradientLibraryDef, type RawSvgFilter, Rectangle, type RectangleNodeProps, type RenderOptions, type RichTextData, type RichTextLine, type RichTextSegment, type RichTextSegmentStyle, type RiddledFilter, Ring, type RingNodeProps, type RoundEdgesFilter, type SaturateFilter, type SegmentCurveType, type SepiaFilter, type SerializedAnimationTimeline, type SerializedClipMaskGroup, type SerializedGroup, type SerializedMarkerDef, type SerializedShape, type SerializedSymbolDef, type SerializedVariantAxis, type SerializedViewbox, ShapeBuilder, type ShapeFilter, type ShapeMetadata, type SharpenFilter, type SpecularLightingFilter, Spiral, type SpiralNodeProps, type SpotLightFilter, Square, type SquareNodeProps, Star, type StarNodeProps, type StepPosition, type StepsParams, type StringifyOptions, type StrokeType, type SvgPrimitiveChainFilter, type SymbolInstanceNodeProps, type SymbolLibraryDef, type TemplateVariable, type TemplateVariableMode, type TemplateVariableSource, type TemplateVariableType, Text, type TextNodeProps, Timeline, Track, type TransferFunc, Triangle, type TriangleNodeProps, type ValidationError, type ValidationResult, type VariableMap, type Viewbox, type WarpFilter, type WarpType, type WatercolorFilter, type XrayFilter, collectReferencedLibraryIds, computeArrowVertices, computeCloudPath, computeCrossVertices, computeDashArray, computeGearPath, computeGearVertices, computeHeartPath, computeLightningVertices, computePolygonVertices, computeRectanglePath, computeRingPath, computeSpeechBubbleVertices, computeSpiralPath, computeSplinePath, computeStarVertices, createDocument, createShape, createViewbox, defaultVariableMode, escXml, extractVariables, filterAttr, generateCode, generateCssCode, generateD3Code, generateId, generatePatternSvgContent, generateReactCode, generateSvgCode, generateVueCode, getBuiltInMarkerDefs, getEasingCubicBezier, getEffectivePrecision, getMarkerDescriptors, getPatternElements, linearGradient, migrateSnapshot, parseDocument, parseVariableArgs, pattern, radialGradient, renderAnimationElements, renderBuiltinMarkerDefs, renderCircle, renderEllipse, renderFilterDefs, renderFilterLibraryDef, renderFilterPrimitive, renderFilterPrimitivesForType, renderImage, renderLibraryDef, renderLibraryDefs, renderLine, renderLinearGradientLibraryDef, renderMarkerLibraryDef, renderPatternLibraryDef, renderPolygonShape, renderPolyline, renderRadialGradientLibraryDef, renderRectangle, renderReferencedLibraryDefs, renderShape, renderSpline, renderSvgPrimitiveChainFilter, renderSymbolLibraryDef, renderText, renderToSvg, roundCoord, roundNumberString, roundSerializedShape, roundSnapshot, stringifyDocument, substituteString, substituteVariables, validateSnapshot, verticesToPath };