af-motion 0.0.0-stage → 1.0.0

package/dist/core/schema.d.ts

@@ -0,0 +1,185 @@
+/**
+ * AF Motion Unified Machine-Readable Schema Architecture
+ *
+ * Provides a standardized, extensible JSON Schema-compatible contract and validation engine
+ * allowing AI agents, MCP tools, and developer tools to inspect, configure, validate,
+ * and compose every AF Motion capability.
+ */
+export declare const SCHEMA_SPEC_VERSION = "1.0.0";
+export type SchemaPropertyType = "string" | "number" | "boolean" | "object" | "array" | "null";
+export type SchemaCapabilityCategory = "animation" | "core-animation" | "visual-effect" | "text-effect" | "background" | "pointer" | "scroll" | "svg" | "gesture" | "composition" | "react" | "preset" | "recipe" | "motion-dna" | "design-system" | "palette" | "choreography" | "visual-style" | "shader" | "graphics" | "3d" | "ai-motion-spec" | "ai-react-component" | "studio-config" | (string & {});
+export interface SchemaPropertyDescriptor {
+    readonly type: SchemaPropertyType | readonly SchemaPropertyType[];
+    readonly description?: string;
+    readonly default?: unknown;
+    readonly enum?: readonly (string | number | boolean)[];
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly items?: SchemaPropertyDescriptor | {
+        readonly type: string;
+    };
+    readonly properties?: Readonly<Record<string, SchemaPropertyDescriptor>>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean;
+    readonly dependsOn?: string;
+    readonly placeholder?: string;
+    readonly example?: unknown;
+}
+export interface CompatibilityMetadata {
+    readonly browser: boolean;
+    readonly ssr: boolean;
+    readonly requiresCanvas?: boolean;
+    readonly requiresDom?: boolean;
+}
+export interface CapabilityAccessibilityMetadata {
+    readonly considerations?: readonly string[];
+    readonly ariaAttributes?: readonly string[];
+    readonly keyboardSupport?: boolean;
+    readonly screenReaderSafe?: boolean;
+}
+export interface CapabilityDependencies {
+    readonly required?: readonly string[];
+    readonly optional?: readonly string[];
+}
+export interface CapabilityExample {
+    readonly title: string;
+    readonly description?: string;
+    readonly code: string;
+    readonly configuration?: Record<string, unknown>;
+}
+export type ReducedMotionBehavior = "skips-to-endpoint" | "disables-animation" | "static-fallback" | "respects-profile" | "not-applicable";
+export interface UnifiedMotionSchema {
+    readonly $schema?: string;
+    readonly $id: string;
+    readonly id?: string;
+    readonly schemaVersion: string;
+    readonly capabilityId: string;
+    readonly name: string;
+    readonly category: SchemaCapabilityCategory;
+    readonly description: string;
+    readonly type: "object";
+    readonly properties: Readonly<Record<string, SchemaPropertyDescriptor>>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean;
+    readonly defaultConfiguration?: Readonly<Record<string, unknown>>;
+    readonly compatibility?: CompatibilityMetadata;
+    readonly accessibility?: CapabilityAccessibilityMetadata;
+    readonly reducedMotion?: ReducedMotionBehavior;
+    readonly dependencies?: CapabilityDependencies;
+    readonly examples?: readonly CapabilityExample[];
+    readonly tags?: readonly string[];
+    readonly parameters?: readonly unknown[];
+    readonly schema?: {
+        readonly type: "object";
+        readonly properties: Readonly<Record<string, unknown>>;
+        readonly required?: readonly string[];
+        readonly additionalProperties?: boolean;
+    };
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export type ValidationRule = "required" | "type" | "range" | "enum" | "unknown" | "pattern" | "structure" | "length";
+export interface ConfigurationValidationError {
+    readonly path: string;
+    readonly property?: string;
+    readonly parameter?: string;
+    readonly message: string;
+    readonly received?: unknown;
+    readonly expected?: string;
+    readonly rule: ValidationRule;
+}
+export interface ConfigurationValidationOptions {
+    readonly allowUnknown?: boolean;
+    readonly coerceTypes?: boolean;
+    readonly strictRequired?: boolean;
+}
+export interface ConfigurationValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly ConfigurationValidationError[];
+    readonly resolvedConfiguration?: Readonly<Record<string, unknown>>;
+}
+export interface SchemaValidationError {
+    readonly field: string;
+    readonly message: string;
+}
+export interface SchemaValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly SchemaValidationError[];
+}
+export interface SchemasDocument {
+    readonly $schema: string;
+    readonly version: string;
+    readonly totalSchemas: number;
+    readonly schemas: readonly UnifiedMotionSchema[];
+}
+export interface SchemaFilterOptions {
+    readonly category?: string;
+    readonly tag?: string;
+    readonly version?: string;
+}
+/**
+ * Builds a canonical schema URI for a capability.
+ */
+export declare function createSchemaId(capabilityId: string): string;
+/**
+ * Validates a schema document structure before registration or distribution.
+ */
+export declare function validateSchema(schema: unknown): SchemaValidationResult;
+/**
+ * Validates a runtime configuration object against a UnifiedMotionSchema.
+ * Recursively inspects nested objects, array items, required fields, ranges, and enums.
+ */
+export declare function validateConfiguration(schema: UnifiedMotionSchema | {
+    readonly type: "object";
+    readonly properties: Record<string, unknown>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean;
+}, configuration: unknown, options?: ConfigurationValidationOptions): ConfigurationValidationResult;
+/**
+ * Pure function that resolves default values from a schema and merges them with user configurations.
+ * Recursively applies defaults to nested objects.
+ */
+export declare function resolveConfigurationDefaults<T = Record<string, unknown>>(schema: UnifiedMotionSchema | {
+    readonly properties?: Record<string, unknown>;
+    readonly defaultConfiguration?: Record<string, unknown>;
+}, configuration?: Record<string, unknown>): T;
+/**
+ * Creates a complete UnifiedMotionSchema for a capability, deriving schema properties from parameter descriptors if necessary.
+ */
+export declare function createUnifiedSchema(capability: {
+    readonly id: string;
+    readonly name: string;
+    readonly category: string;
+    readonly description: string;
+    readonly version?: string;
+    readonly schema?: {
+        readonly type: "object";
+        readonly properties: Record<string, unknown>;
+        readonly required?: readonly string[];
+        readonly additionalProperties?: boolean;
+    };
+    readonly parameters?: readonly {
+        readonly name: string;
+        readonly kind?: string;
+        readonly type: string;
+        readonly required?: boolean;
+        readonly default?: unknown;
+        readonly description?: string;
+        readonly range?: {
+            readonly min?: number;
+            readonly max?: number;
+        };
+        readonly enum?: readonly (string | number)[];
+        readonly itemType?: string;
+    }[];
+    readonly defaultConfiguration?: Readonly<Record<string, unknown>>;
+    readonly compatibility?: CompatibilityMetadata;
+    readonly accessibility?: CapabilityAccessibilityMetadata;
+    readonly reducedMotion?: ReducedMotionBehavior;
+    readonly dependencies?: CapabilityDependencies;
+    readonly examples?: readonly CapabilityExample[];
+    readonly tags?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}): UnifiedMotionSchema;

package/dist/core/scroll-intelligence/generator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Intelligent Scroll Plan Generator
+ *
+ * Deterministic generation of scroll-driven animation specifications, offsets,
+ * easing curves, parallax layers, 3D timelines, and accessibility fallbacks.
+ */
+import type { ScrollIntelligenceContext, ScrollIntelligenceResult } from "./types.js";
+/**
+ * Generates an intelligent, deterministic scroll animation plan.
+ */
+export declare function generateScrollPlan(context: ScrollIntelligenceContext): ScrollIntelligenceResult;

package/dist/core/scroll-intelligence/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Scroll Intelligence Module
+ *
+ * Intelligent scroll animation plan generation, intent classification,
+ * runtime progress evaluation, parallax, 2D-to-3D synchronization, and AI discovery.
+ */
+export * from "./types.js";
+export * from "./intent.js";
+export * from "./generator.js";
+export * from "./runtime.js";
+export * from "./schema.js";

package/dist/core/scroll-intelligence/intent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Scroll Intent Classifier
+ *
+ * Deterministic natural-language and context parser mapping user descriptions,
+ * component contexts, and page structure to AF Motion's 8 core scroll animation types.
+ */
+import type { ClassifiedScrollIntent, ScrollIntelligenceContext } from "./types.js";
+/**
+ * Classifies scroll animation intent from a prompt or context.
+ */
+export declare function classifyScrollIntent(input: string | Partial<ScrollIntelligenceContext>): ClassifiedScrollIntent;

package/dist/core/scroll-intelligence/runtime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AF Motion Scroll Intelligence Runtime Engine
+ *
+ * High-performance, framework-independent scroll engine with passive event
+ * listening, single-RAF batching, layout-cached metrics, and 2D-to-3D synchronization.
+ */
+import type { ScrollPlan, ScrollRuntimeCallbacks, ScrollRuntimeControls } from "./types.js";
+import type { ScrollSceneController } from "../../3d/scroll/controller.js";
+export declare class ScrollIntelligenceRuntime {
+    /**
+     * Binds a scroll plan to a target DOM element.
+     */
+    register(plan: ScrollPlan, target: HTMLElement, callbacks?: ScrollRuntimeCallbacks, options?: {
+        sync3DController?: ScrollSceneController;
+    }): ScrollRuntimeControls;
+    /**
+     * Interpolates and applies CSS properties onto the target element style.
+     */
+    private applyProperties;
+}
+export declare const scrollIntelligenceRuntime: ScrollIntelligenceRuntime;

package/dist/core/scroll-intelligence/schema.d.ts

@@ -0,0 +1,78 @@
+/**
+ * AF Motion Scroll Intelligence Schema & AI Motion Registry Integration
+ *
+ * Machine-readable capability definitions and discovery helpers for
+ * intelligent scroll-driven animation generation and runtime control.
+ */
+import { type ScrollAnimationType, type ScrollProgressMode } from "./types.js";
+export declare const SCROLL_INTELLIGENCE_CAPABILITY: {
+    id: string;
+    name: string;
+    category: "scroll";
+    description: string;
+    tags: string[];
+    version: string;
+    features: string[];
+    supportedTypes: readonly ScrollAnimationType[];
+    supportedProgressModes: readonly ScrollProgressMode[];
+    parameters: {
+        name: string;
+        kind: "positional";
+        type: string;
+        required: boolean;
+        description: string;
+    }[];
+    supportedTargets: string[];
+    signature: {
+        importStatement: string;
+        invocation: string;
+        exampleCode: string;
+    };
+    controls: string[];
+    callbacks: string[];
+    reducedMotion: "static-fallback";
+    compatibility: {
+        browser: boolean;
+        ssr: boolean;
+        requiresCanvas: boolean;
+    };
+};
+export declare function getScrollIntelligenceCapability(): {
+    id: string;
+    name: string;
+    category: "scroll";
+    description: string;
+    tags: string[];
+    version: string;
+    features: string[];
+    supportedTypes: readonly ScrollAnimationType[];
+    supportedProgressModes: readonly ScrollProgressMode[];
+    parameters: {
+        name: string;
+        kind: "positional";
+        type: string;
+        required: boolean;
+        description: string;
+    }[];
+    supportedTargets: string[];
+    signature: {
+        importStatement: string;
+        invocation: string;
+        exampleCode: string;
+    };
+    controls: string[];
+    callbacks: string[];
+    reducedMotion: "static-fallback";
+    compatibility: {
+        browser: boolean;
+        ssr: boolean;
+        requiresCanvas: boolean;
+    };
+};
+export declare function getAvailableScrollAnimationTypes(): readonly ScrollAnimationType[];
+export declare function getAvailableScrollProgressModes(): readonly ScrollProgressMode[];
+export declare function listSupportedScrollAnimationTypes(): readonly ScrollAnimationType[];
+export declare function listSupportedScrollProgressModes(): readonly ScrollProgressMode[];
+export declare function registerScrollIntelligenceCapability(registry: {
+    registerCapability: (cap: any, opts?: any) => void;
+}): void;

package/dist/core/scroll-intelligence/types.d.ts

@@ -0,0 +1,85 @@
+/**
+ * AF Motion Scroll Intelligence Contracts
+ *
+ * Framework-independent contracts for intelligent scroll animation generation,
+ * scroll intent classification, progress calculation modes, parallax, and 2D-to-3D synchronization.
+ */
+import type { AnimatableProperties } from "../animate.js";
+import type { ComponentCategory } from "../animation-intelligence/types.js";
+import type { ScrollSceneController } from "../../3d/scroll/controller.js";
+export declare const SCROLL_INTELLIGENCE_VERSION = "1.0.0";
+export type ScrollAnimationType = "reveal" | "parallax" | "sticky-story" | "progress-indicator" | "stagger-sequence" | "horizontal-section" | "scroll-typography" | "scroll-3d-sync";
+export declare const SCROLL_ANIMATION_TYPES: readonly ScrollAnimationType[];
+export type ScrollProgressMode = "viewport" | "element" | "container";
+export declare const SCROLL_PROGRESS_MODES: readonly ScrollProgressMode[];
+export type ScrollDirection = "down" | "up" | "both";
+export interface ScrollTriggerOffset {
+    readonly start?: string | number;
+    readonly end?: string | number;
+}
+export interface ScrollPlan {
+    readonly id: string;
+    readonly name: string;
+    readonly type: ScrollAnimationType;
+    readonly progressMode: ScrollProgressMode;
+    readonly startOffset: string | number;
+    readonly endOffset: string | number;
+    readonly properties: Readonly<AnimatableProperties>;
+    readonly easing?: string;
+    readonly reversible: boolean;
+    readonly clamp: boolean;
+    readonly stagger?: number;
+    readonly sync3DTimelineId?: string;
+    readonly compatibilityScore: number;
+    readonly explanation: string;
+    readonly respectReducedMotion: boolean;
+    readonly reducedMotionProperties?: Readonly<AnimatableProperties>;
+}
+export interface ScrollIntelligenceContext {
+    readonly intent?: string;
+    readonly type?: ScrollAnimationType;
+    readonly componentType?: ComponentCategory;
+    readonly visualStyle?: string;
+    readonly motionDNA?: string;
+    readonly container?: HTMLElement | Window;
+    readonly direction?: ScrollDirection;
+    readonly reversible?: boolean;
+    readonly progressMode?: ScrollProgressMode;
+    readonly startOffset?: string | number;
+    readonly endOffset?: string | number;
+    readonly stagger?: number;
+    readonly deviceTier?: "low" | "medium" | "high";
+    readonly reducedMotion?: boolean;
+    readonly sync3DController?: ScrollSceneController;
+}
+export interface ScrollIntelligenceResult {
+    readonly plan: ScrollPlan;
+    readonly alternatives: readonly ScrollPlan[];
+    readonly compatibilityScore: number;
+    readonly warnings: readonly string[];
+    readonly explanation: string;
+    readonly context: ScrollIntelligenceContext;
+}
+export interface ClassifiedScrollIntent {
+    readonly type: ScrollAnimationType;
+    readonly confidence: number;
+    readonly matchedKeywords: readonly string[];
+}
+export interface ScrollRuntimeProgressState {
+    readonly progress: number;
+    readonly rawProgress: number;
+    readonly direction: "down" | "up";
+    readonly velocity: number;
+    readonly inView: boolean;
+}
+export interface ScrollRuntimeControls {
+    readonly destroy: () => void;
+    readonly getState: () => ScrollRuntimeProgressState;
+    readonly pause: () => void;
+    readonly resume: () => void;
+}
+export interface ScrollRuntimeCallbacks {
+    readonly onProgress?: (state: ScrollRuntimeProgressState) => void;
+    readonly onEnter?: () => void;
+    readonly onLeave?: () => void;
+}

package/dist/core/spring.d.ts

@@ -0,0 +1,38 @@
+export interface SpringConfig {
+    /** Spring stiffness. Must be finite and greater than zero. Defaults to 170. */
+    stiffness?: number;
+    /** Friction coefficient. Must be finite and non-negative. Defaults to 26. */
+    damping?: number;
+    /** Mass. Must be finite and greater than zero. Defaults to 1. */
+    mass?: number;
+    /** Initial velocity in position units per second. Defaults to 0. */
+    initialVelocity?: number;
+    /** Position error at which the spring may settle. Defaults to 0.01. */
+    restDelta?: number;
+    /** Absolute velocity below which the spring may settle. Defaults to 0.01. */
+    restSpeed?: number;
+}
+export interface SpringUpdate {
+    position: number;
+    velocity: number;
+}
+export interface SpringOptions {
+    /** Starting position. Defaults to 0. */
+    from?: number;
+    /** Target position. Defaults to 1. */
+    to?: number;
+    /** Spring constants and settling thresholds. */
+    config?: SpringConfig;
+    /** Called on each shared animation frame with position and velocity. */
+    onUpdate: (state: SpringUpdate) => void;
+    /** Called once when the spring settles or reduced motion completes it. */
+    onComplete?: () => void;
+    /** Defaults to true. */
+    respectReducedMotion?: boolean;
+}
+export interface SpringControls {
+    /** Stops the spring and suppresses subsequent update and completion callbacks. */
+    cancel(): void;
+}
+/** Animates a scalar spring using the library's shared animation-frame scheduler. */
+export declare function animateSpring(options: SpringOptions): SpringControls;

package/dist/core/svg-morph/animator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AF Motion SVG Morph Animation Orchestrator
+ *
+ * Drives SVG path morphing using the core animation engine and frame scheduler.
+ */
+import type { MorphAnimationControls, MorphAnimationOptions } from "./types.js";
+/**
+ * Morphs an SVG path element or shape to a new path geometry or SVG shape.
+ */
+export declare function morphPath(target: SVGElement | string, to: string | SVGElement, options?: MorphAnimationOptions): MorphAnimationControls;

package/dist/core/svg-morph/arc-to-cubic.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Elliptical Arc to Cubic Bézier Converter
+ *
+ * Implements the W3C SVG Arc Endpoint-to-Center Parameterization (Annex F.6)
+ * and approximates arbitrary elliptical arcs using smooth cubic Bézier segments.
+ */
+import type { CubicSegment } from "./types.js";
+/**
+ * Converts an SVG elliptical arc into an array of equivalent Cubic Bézier segments.
+ */
+export declare function arcToCubic(x1: number, y1: number, rx: number, ry: number, angleDeg: number, largeArcFlag: number, sweepFlag: number, x2: number, y2: number): CubicSegment[];

package/dist/core/svg-morph/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AF Motion SVG Morphing Subsystem
+ */
+export * from "./types.js";
+export * from "./parser.js";
+export * from "./arc-to-cubic.js";
+export * from "./shapes.js";
+export * from "./normalize.js";
+export * from "./interpolate.js";
+export * from "./animator.js";

package/dist/core/svg-morph/interpolate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AF Motion SVG Morph Interpolation Engine
+ *
+ * Deterministic, high-performance coordinate interpolation between aligned paths
+ * with precision formatting and minimal allocation overhead.
+ */
+import type { Morph, MorphOptions, NormalizedPath } from "./types.js";
+/**
+ * Creates and compiles a Morph structure between two SVG paths or elements.
+ */
+export declare function createMorph(from: string | SVGElement, to: string | SVGElement, options?: MorphOptions): Morph;
+/**
+ * Formats a single NormalizedPath into an SVG path `d` string.
+ */
+export declare function formatNormalizedPath(path: NormalizedPath, precision?: number): string;
+/**
+ * Interpolates between two aligned paths at parameter progress (0 to 1).
+ */
+export declare function interpolateMorph(morph: Morph, progress: number): string;
+/**
+ * Clears the compiled morph cache.
+ */
+export declare function clearMorphCache(): void;

package/dist/core/svg-morph/normalize.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AF Motion SVG Path Normalization Engine
+ *
+ * Converts arbitrary SVG path commands into canonical Cubic Bézier segments,
+ * performs de Casteljau curve subdivision for segment-count alignment,
+ * aligns subpaths, and optimizes starting points on closed loops.
+ */
+import type { CanonicalSubpath, CubicSegment, NormalizedPath, NormalizeOptions, SVGPointTuple, SVGPathCommand } from "./types.js";
+type Point2D = SVGPointTuple;
+/**
+ * Splits a single cubic Bézier curve at parameter t = 0.5 using de Casteljau's algorithm.
+ */
+export declare function splitCubicAtHalf(start: Point2D, cubic: CubicSegment): [CubicSegment, CubicSegment];
+/**
+ * Converts raw parsed commands into canonical subpaths of M, C, and Z segments.
+ */
+export declare function toCanonicalSubpaths(commands: readonly SVGPathCommand[]): CanonicalSubpath[];
+/**
+ * Subdivides a subpath's cubic segments until it contains exactly targetCount cubics.
+ */
+export declare function subdivideSubpath(subpath: CanonicalSubpath, targetCount: number): CanonicalSubpath;
+/**
+ * Cyclically rotates a closed subpath's segments to minimize distance to a reference subpath.
+ */
+export declare function alignClosedSubpathStart(target: CanonicalSubpath, reference: CanonicalSubpath): CanonicalSubpath;
+/**
+ * Fully normalizes and aligns two paths so they share identical subpath and segment structure.
+ */
+export declare function alignPaths(pathA: NormalizedPath, pathB: NormalizedPath, options?: NormalizeOptions): [NormalizedPath, NormalizedPath];
+/**
+ * Converts a raw SVG path string or SVG element into a NormalizedPath.
+ */
+export declare function normalizeSVGPath(input: string | SVGElement, options?: NormalizeOptions): NormalizedPath;
+export {};

package/dist/core/svg-morph/parser.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AF Motion Robust SVG Path Parser
+ *
+ * Implements strict compliance with the W3C SVG path specification:
+ * supports absolute/relative commands, repeated parameter sequences,
+ * negative numbers without whitespace, scientific notation, and multiple subpaths.
+ */
+import type { SVGPathCommand } from "./types.js";
+/**
+ * Parses raw SVG path data into an array of discrete SVG commands and numeric parameters.
+ * Throws TypeError on malformed or unsupported path data.
+ */
+export declare function parseSVGPath(d: string): SVGPathCommand[];

package/dist/core/svg-morph/shapes.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AF Motion SVG Shape to Path Converter
+ *
+ * Converts SVG primitives (circle, rect, ellipse, polygon, polyline, line)
+ * into mathematically equivalent SVG path data strings for seamless morphing.
+ */
+import type { SVGCircleProps, SVGEllipseProps, SVGPolygonProps, SVGPolylineProps, SVGRectProps } from "./types.js";
+/**
+ * Converts a circle into a closed path with 4 cubic Bézier curves.
+ */
+export declare function circleToPath(circle: SVGCircleProps): string;
+/**
+ * Converts an ellipse into a closed path with 4 cubic Bézier curves.
+ */
+export declare function ellipseToPath(ellipse: SVGEllipseProps): string;
+/**
+ * Converts a rectangle (with optional rounded corners) into a closed path.
+ */
+export declare function rectToPath(rect: SVGRectProps): string;
+/**
+ * Converts a polygon into a closed SVG path.
+ */
+export declare function polygonToPath(polygon: SVGPolygonProps): string;
+/**
+ * Converts a polyline into an open SVG path.
+ */
+export declare function polylineToPath(polyline: SVGPolylineProps): string;
+/**
+ * Converts any DOM SVG element (path, circle, rect, ellipse, polygon, polyline, line)
+ * into a canonical path data string.
+ */
+export declare function svgElementToPath(element: SVGElement): string;