@hyperframes/parsers 0.7.15

package/dist/gsapSerialize-B_JRTCeV.d.ts

@@ -0,0 +1,535 @@
+import { PropertyGroupName } from './gsapConstants.js';
+
+interface Asset {
+    id: string;
+    url: string;
+    type: string;
+    is_reference?: boolean;
+    /** Duration in seconds for video/audio assets */
+    duration?: number;
+}
+type TimelineElementType = "video" | "image" | "text" | "audio" | "composition";
+type MediaElementType = "video" | "image" | "audio";
+declare const CANVAS_DIMENSIONS: {
+    readonly landscape: {
+        readonly width: 1920;
+        readonly height: 1080;
+    };
+    readonly portrait: {
+        readonly width: 1080;
+        readonly height: 1920;
+    };
+    readonly "landscape-4k": {
+        readonly width: 3840;
+        readonly height: 2160;
+    };
+    readonly "portrait-4k": {
+        readonly width: 2160;
+        readonly height: 3840;
+    };
+    readonly square: {
+        readonly width: 1080;
+        readonly height: 1080;
+    };
+    readonly "square-4k": {
+        readonly width: 2160;
+        readonly height: 2160;
+    };
+};
+type CanvasResolution = keyof typeof CANVAS_DIMENSIONS;
+declare const VALID_CANVAS_RESOLUTIONS: readonly CanvasResolution[];
+/**
+ * Map a user-facing resolution string (canonical name or alias) to a
+ * `CanvasResolution`. Returns undefined for unknown values so callers
+ * can produce their own "invalid" UX (CLI exit, route validation, etc.).
+ */
+declare function normalizeResolutionFlag(input: string | undefined): CanvasResolution | undefined;
+interface TimelineElementBase {
+    id: string;
+    type: TimelineElementType;
+    name: string;
+    startTime: number;
+    duration: number;
+    zIndex: number;
+    x?: number;
+    y?: number;
+    scale?: number;
+    opacity?: number;
+}
+interface TimelineMediaElement extends TimelineElementBase {
+    type: MediaElementType;
+    src: string;
+    mediaStartTime?: number;
+    sourceDuration?: number;
+    isAroll?: boolean;
+    sourceWidth?: number;
+    sourceHeight?: number;
+    volume?: number;
+    hasAudio?: boolean;
+}
+interface WaveformData {
+    peaks: number[];
+    duration: number;
+    sampleRate?: number;
+}
+interface TimelineTextElement extends TimelineElementBase {
+    type: "text";
+    content: string;
+    color?: string;
+    fontSize?: number;
+    textShadow?: boolean;
+    fontFamily?: string;
+    fontWeight?: number;
+    textOutline?: boolean;
+    textOutlineColor?: string;
+    textOutlineWidth?: number;
+    textHighlight?: boolean;
+    textHighlightColor?: string;
+    textHighlightPadding?: number;
+    textHighlightRadius?: number;
+}
+interface TimelineCompositionElement extends TimelineElementBase {
+    type: "composition";
+    src: string;
+    compositionId: string;
+    scale?: number;
+    sourceDuration?: number;
+    variableValues?: Record<string, string | number | boolean>;
+    sourceWidth?: number;
+    sourceHeight?: number;
+}
+type CompositionVariableType = "string" | "number" | "color" | "boolean" | "enum" | "font" | "image";
+/**
+ * Runtime list of every valid `CompositionVariableType`. Use this anywhere
+ * a Set/array of valid type strings is needed (lint rules, validators).
+ * The `satisfies` guard turns adding a new variant to the union without
+ * also adding it here into a compile error.
+ */
+declare const COMPOSITION_VARIABLE_TYPES: readonly ["string", "number", "color", "boolean", "enum", "font", "image"];
+interface CompositionVariableBase {
+    id: string;
+    type: CompositionVariableType;
+    label: string;
+    description?: string;
+}
+interface StringVariable extends CompositionVariableBase {
+    type: "string";
+    default: string;
+    placeholder?: string;
+    maxLength?: number;
+}
+interface NumberVariable extends CompositionVariableBase {
+    type: "number";
+    default: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+}
+interface ColorVariable extends CompositionVariableBase {
+    type: "color";
+    default: string;
+    /** Brand role identifier, e.g. "color:primary". */
+    brandRole?: string;
+}
+interface BooleanVariable extends CompositionVariableBase {
+    type: "boolean";
+    default: boolean;
+}
+interface EnumVariable extends CompositionVariableBase {
+    type: "enum";
+    default: string;
+    options: {
+        value: string;
+        label: string;
+    }[];
+}
+/**
+ * Font variable — value is a `{name, source}` object (object-valued; LOCKED §7).
+ * `default` is the fallback font-family name string.
+ * `source` is the font stylesheet URL (e.g. Google Fonts CSS).
+ * `default_name` / `default_source` are the CSS-level fallbacks when the
+ * brand font is absent.
+ */
+interface FontVariable extends CompositionVariableBase {
+    type: "font";
+    /** Fallback font-family name, e.g. "Inter". */
+    default: string;
+    /** Font stylesheet URL (e.g. Google Fonts CSS link). */
+    source?: string;
+    /** CSS font-family name to use when source is unavailable, e.g. "sans-serif". */
+    default_name?: string;
+    /** Fallback font stylesheet URL (empty string = system font). */
+    default_source?: string;
+}
+/**
+ * Image variable — value is a `{url, …}` object (object-valued; LOCKED §7).
+ * `default` is the fallback image URL string.
+ * `brandRole` is an optional semantic label, e.g. "logo:primary".
+ */
+interface ImageVariable extends CompositionVariableBase {
+    type: "image";
+    /** Fallback image URL. */
+    default: string;
+    /** Brand role identifier, e.g. "logo:primary". */
+    brandRole?: string;
+}
+type CompositionVariable = StringVariable | NumberVariable | ColorVariable | BooleanVariable | EnumVariable | FontVariable | ImageVariable;
+interface CompositionSpec {
+    id: string;
+    duration: number;
+    variables: CompositionVariable[];
+}
+type TimelineElement = TimelineMediaElement | TimelineTextElement | TimelineCompositionElement;
+declare function isTextElement(el: TimelineElement): el is TimelineTextElement;
+declare function isMediaElement(el: TimelineElement): el is TimelineMediaElement;
+declare function isCompositionElement(el: TimelineElement): el is TimelineCompositionElement;
+interface MediaFile {
+    id: string;
+    name: string;
+    type: TimelineElementType;
+    src: string;
+    file?: File;
+    duration?: number;
+    compositionId?: string;
+    sourceWidth?: number;
+    sourceHeight?: number;
+}
+declare const TIMELINE_COLORS: Record<TimelineElementType, string>;
+declare const DEFAULT_DURATIONS: Record<TimelineElementType, number>;
+interface CompositionAPI {
+    id: string;
+    duration: number;
+    seek(time: number): void;
+    getTime(): number;
+    getDuration(): number;
+}
+interface PlayerAPI {
+    play(): void;
+    pause(): void;
+    seek(time: number, options?: {
+        keepPlaying?: boolean;
+    }): void;
+    getTime(): number;
+    getDuration(): number;
+    isPlaying(): boolean;
+    getMainTimeline(): unknown;
+    getElementBounds(elementId: string): void;
+    getElementsAtPoint(x: number, y: number): void;
+    setElementPosition(elementId: string, x: number, y: number): void;
+    previewElementPosition(elementId: string, x: number, y: number): void;
+    setElementKeyframes(elementId: string, keyframes: Array<{
+        id: string;
+        time: number;
+        properties: {
+            x?: number;
+            y?: number;
+        };
+    }> | null): void;
+    setElementScale(elementId: string, scale: number): void;
+    setElementFontSize(elementId: string, fontSize: number): void;
+    setElementTextContent(elementId: string, content: string): void;
+    setElementTextColor(elementId: string, color: string): void;
+    setElementTextShadow(elementId: string, enabled: boolean): void;
+    setElementTextFontWeight(elementId: string, weight: number): void;
+    setElementTextFontFamily(elementId: string, fontFamily: string): void;
+    setElementTextOutline(elementId: string, enabled: boolean, color?: string, width?: number): void;
+    setElementTextHighlight(elementId: string, enabled: boolean, color?: string, padding?: number, radius?: number): void;
+    setElementVolume(elementId: string, volume: number): void;
+    setStageZoom(scale: number, focusX: number, focusY: number): void;
+    getStageZoom(): {
+        scale: number;
+        focusX: number;
+        focusY: number;
+    };
+    setStageZoomKeyframes(keyframes: Array<{
+        id: string;
+        time: number;
+        zoom: {
+            scale: number;
+            focusX: number;
+            focusY: number;
+        };
+        ease?: string;
+    }> | null): void;
+    getStageZoomKeyframes(): Array<{
+        id: string;
+        time: number;
+        zoom: {
+            scale: number;
+            focusX: number;
+            focusY: number;
+        };
+        ease?: string;
+    }>;
+    addElement(data: AddElementData): boolean;
+    removeElement(elementId: string): boolean;
+    updateElementTiming(elementId: string, start?: number, end?: number): boolean;
+    setElementTiming(elementId: string, startTime: number, duration: number, mediaStartTime?: number): void;
+    updateElementSrc(elementId: string, src: string): boolean;
+    updateElementLayer(elementId: string, zIndex: number): boolean;
+    updateElementBasePosition(elementId: string, x?: number, y?: number, scale?: number): boolean;
+    markTimelineDirty(): void;
+    isTimelineDirty(): boolean;
+    rebuildTimeline(): void;
+    ensureTimeline(): void;
+    enableRenderMode(): void;
+    disableRenderMode(): void;
+    renderSeek(time: number): void;
+    getElementVisibility(elementId: string): {
+        visible: boolean;
+        opacity?: number;
+    };
+    getVisibleElements(): Array<{
+        id: string;
+        tagName: string;
+        start: number;
+        end: number;
+    }>;
+    getRenderState(): {
+        time: number;
+        duration: number;
+        isPlaying: boolean;
+        renderMode: boolean;
+        timelineDirty: boolean;
+    };
+}
+interface AddElementData {
+    id: string;
+    type: "video" | "image" | "text" | "audio" | "composition";
+    name?: string;
+    src?: string;
+    content?: string;
+    start: number;
+    end: number;
+    zIndex?: number;
+    x?: number;
+    y?: number;
+    scale?: number;
+    fontSize?: number;
+    color?: string;
+    textShadow?: boolean;
+    fontWeight?: number;
+    textOutline?: boolean;
+    textOutlineColor?: string;
+    textOutlineWidth?: number;
+    textHighlight?: boolean;
+    textHighlightColor?: string;
+    textHighlightPadding?: number;
+    textHighlightRadius?: number;
+    compositionId?: string;
+    sourceWidth?: number;
+    sourceHeight?: number;
+    isAroll?: boolean;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+interface CompositionAsset {
+    id: string;
+    name: string;
+    type: "composition";
+    src: string;
+    duration: number;
+    compositionId: string;
+    thumbnail?: string;
+}
+interface Keyframe {
+    id: string;
+    time: number;
+    properties: Partial<KeyframeProperties>;
+    ease?: string;
+}
+interface KeyframeProperties {
+    x: number;
+    y: number;
+    opacity: number;
+    scale: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+    width: number;
+    height: number;
+}
+interface ElementKeyframes {
+    elementId: string;
+    keyframes: Keyframe[];
+}
+interface StageZoom {
+    scale: number;
+    focusX: number;
+    focusY: number;
+}
+interface StageZoomKeyframe {
+    id: string;
+    time: number;
+    zoom: StageZoom;
+    ease?: string;
+}
+declare function getDefaultStageZoom(resolution: CanvasResolution): StageZoom;
+
+/**
+ * Recast-free GSAP helpers: serialization, keyframe<->animation conversion,
+ * validation, and shared types.
+ *
+ * This module MUST NOT import recast / @babel/parser. It is part of the
+ * isomorphic core layer that the barrel and browser code depend on. AST
+ * parsing of GSAP source lives in the Node-only `./gsapParser` module.
+ */
+
+type GsapMethod = "set" | "to" | "from" | "fromTo";
+/** How a tween was constructed in source — drives display classification and editability. */
+type GsapProvenanceKind = "literal" | "helper" | "loop" | "runtime-dynamic";
+/**
+ * Origin of a parsed tween. `literal` tweens map 1:1 to a source call and edit
+ * directly; `helper`/`loop` tweens are expanded from a reused construct (unroll
+ * to edit); `runtime-dynamic` tweens come from live introspection (override to
+ * edit). Absent provenance is treated as `literal`.
+ */
+interface GsapProvenance {
+    kind: GsapProvenanceKind;
+    /** Helper function name (kind === "helper"). */
+    fn?: string;
+    /** 1-based ordinal of the originating call site / loop construct in source order. */
+    callSite?: number;
+    /** 0-based iteration index (kind === "loop"). */
+    iteration?: number;
+    /** Source offset [start, end] of the originating call/loop, when known. */
+    sourceRange?: [number, number];
+}
+/** How a tween's keyframes can be edited, derived from its provenance. */
+type KeyframeEditability = "direct" | "unroll" | "source";
+/**
+ * Map provenance to an editing strategy:
+ * - `direct` — literal tween, maps 1:1 to source; edit in place.
+ * - `unroll` — helper/loop expansion; unroll to literal tweens, then edit.
+ * - `source` — runtime-dynamic value; not statically editable, edit the code.
+ */
+declare function editabilityForProvenance(provenance?: GsapProvenance): KeyframeEditability;
+interface GsapAnimation {
+    id: string;
+    targetSelector: string;
+    method: GsapMethod;
+    position: number | string;
+    properties: Record<string, number | string>;
+    fromProperties?: Record<string, number | string>;
+    duration?: number;
+    ease?: string;
+    /** Non-editable GSAP config (stagger, yoyo, repeat, etc.) preserved for round-trips. */
+    extras?: Record<string, unknown>;
+    /** Native GSAP keyframes data — present when the tween uses keyframes: { ... }. */
+    keyframes?: GsapKeyframesData;
+    /** Arc motion path config — present when the tween uses motionPath for curved position interpolation. */
+    arcPath?: ArcPathConfig;
+    /** True when the tween has a `keyframes` property that couldn't be statically resolved (dynamic). */
+    hasUnresolvedKeyframes?: boolean;
+    /** True when the tween's target selector couldn't be statically resolved (dynamic). */
+    hasUnresolvedSelector?: boolean;
+    /** Absolute start time computed by walking the timeline chain (handles +=, -=, <, >, labels). */
+    resolvedStart?: number;
+    /** True when no position arg was authored — the tween is sequentially placed by GSAP. */
+    implicitPosition?: boolean;
+    /** Which property group this tween belongs to (position, scale, size, rotation, visual, other).
+     *  Undefined for legacy mixed tweens that bundle multiple groups. */
+    propertyGroup?: PropertyGroupName;
+    /** True for a base `gsap.set(...)` (a static hold that runs immediately, OFF the
+     *  timeline) rather than `tl.set(...)`. Carries no timeline position and shows no
+     *  keyframe marker — used to persist a static value (e.g. a 3D transform) without
+     *  introducing a 0% keyframe. */
+    global?: boolean;
+    /** How this tween was constructed in source. Absent ⇒ literal. */
+    provenance?: GsapProvenance;
+}
+interface GsapPercentageKeyframe {
+    percentage: number;
+    properties: Record<string, number | string>;
+    ease?: string;
+}
+type GsapKeyframeFormat = "percentage" | "object-array" | "simple-array";
+interface GsapKeyframesData {
+    format: GsapKeyframeFormat;
+    keyframes: GsapPercentageKeyframe[];
+    ease?: string;
+    easeEach?: string;
+}
+interface ArcPathSegment {
+    curviness: number;
+    cp1?: {
+        x: number;
+        y: number;
+    };
+    cp2?: {
+        x: number;
+        y: number;
+    };
+}
+interface ArcPathConfig {
+    enabled: boolean;
+    autoRotate: boolean | number;
+    segments: ArcPathSegment[];
+}
+interface MotionPathShape {
+    arcPath: ArcPathConfig;
+    waypoints: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+/**
+ * Build arcPath segments + waypoints from resolved path coordinates. Shared by
+ * the AST parser (coords from literal nodes) and the runtime scanner (coords
+ * from a live `vars.motionPath`), so both produce identical arc config.
+ */
+declare function buildArcPath(coords: Array<{
+    x: number;
+    y: number;
+}>, curviness: number, autoRotate: boolean | number, isCubic: boolean): MotionPathShape | undefined;
+interface ParsedGsap {
+    animations: GsapAnimation[];
+    timelineVar: string;
+    preamble: string;
+    postamble: string;
+    multipleTimelines?: boolean;
+    unsupportedTimelinePattern?: boolean;
+}
+
+interface SplitAnimationsOptions {
+    originalId: string;
+    newId: string;
+    splitTime: number;
+    elementStart: number;
+    elementDuration: number;
+}
+interface SplitAnimationsResult {
+    script: string;
+    /** Non-ID-selector animations that the engine cannot safely retarget. */
+    skippedSelectors: string[];
+}
+declare function serializeGsapAnimations(animations: GsapAnimation[], timelineVar?: string, options?: {
+    includeMediaSync?: boolean;
+    preamble?: string;
+    postamble?: string;
+}): string;
+/**
+ * Filter animations to those targeting `#<elementId>` (id-only match). For the
+ * studio panel's id-OR-selector matching, see `getAnimationsForElement` in
+ * `useGsapTweenCache.ts` — distinct on purpose, hence the distinct name.
+ */
+declare function getAnimationsForElementId(animations: GsapAnimation[], elementId: string): GsapAnimation[];
+declare function validateCompositionGsap(script: string): ValidationResult;
+declare function keyframesToGsapAnimations(elementId: string, keyframes: Keyframe[], elementStartTime: number, base?: {
+    x?: number;
+    y?: number;
+    scale?: number;
+}): GsapAnimation[];
+declare function gsapAnimationsToKeyframes(animations: GsapAnimation[], elementStartTime: number, options?: {
+    baseX?: number;
+    baseY?: number;
+    baseScale?: number;
+    clampTimeToZero?: boolean;
+    skipBaseSet?: boolean;
+}): Keyframe[];
+
+export { type TimelineElementType as $, type ArcPathConfig as A, type BooleanVariable as B, type CompositionVariable as C, type CompositionVariableBase as D, type CompositionVariableType as E, DEFAULT_DURATIONS as F, type GsapAnimation as G, type ElementKeyframes as H, type EnumVariable as I, type FontVariable as J, type KeyframeEditability as K, type ImageVariable as L, type MotionPathShape as M, type KeyframeProperties as N, type MediaElementType as O, type ParsedGsap as P, type MediaFile as Q, type NumberVariable as R, type SplitAnimationsOptions as S, type TimelineElement as T, type PlayerAPI as U, type ValidationResult as V, type StageZoom as W, type StringVariable as X, TIMELINE_COLORS as Y, type TimelineCompositionElement as Z, type TimelineElementBase as _, type ArcPathSegment as a, type TimelineMediaElement as a0, type TimelineTextElement as a1, VALID_CANVAS_RESOLUTIONS as a2, type WaveformData as a3, getDefaultStageZoom as a4, isCompositionElement as a5, isMediaElement as a6, isTextElement as a7, normalizeResolutionFlag as a8, type GsapKeyframesData as b, type GsapMethod as c, type GsapPercentageKeyframe as d, type GsapProvenance as e, type GsapProvenanceKind as f, type SplitAnimationsResult as g, editabilityForProvenance as h, getAnimationsForElementId as i, gsapAnimationsToKeyframes as j, keyframesToGsapAnimations as k, buildArcPath as l, type GsapKeyframeFormat as m, type CanvasResolution as n, type Keyframe as o, type StageZoomKeyframe as p, type AddElementData as q, type Asset as r, serializeGsapAnimations as s, CANVAS_DIMENSIONS as t, COMPOSITION_VARIABLE_TYPES as u, validateCompositionGsap as v, type ColorVariable as w, type CompositionAPI as x, type CompositionAsset as y, type CompositionSpec as z };

package/dist/gsapWriterAcorn.d.ts

@@ -0,0 +1,93 @@
+import { G as GsapAnimation, A as ArcPathConfig, S as SplitAnimationsOptions, g as SplitAnimationsResult, a as ArcPathSegment } from './gsapSerialize-B_JRTCeV.js';
+import './gsapConstants.js';
+
+declare function updateAnimationInScript(script: string, animationId: string, updates: Partial<GsapAnimation> & {
+    easeEach?: string;
+    resetKeyframeEases?: boolean;
+}): string;
+/**
+ * Shift every tween targeting `targetSelector` by `delta` seconds (clamped ≥0),
+ * rewriting each call's position argument. Mirrors recast's shiftPositionsInScript
+ * (used by timeline clip-move to keep GSAP positions in sync with the clip start).
+ */
+declare function shiftPositionsInScript(script: string, targetSelector: string, delta: number): string;
+/**
+ * Linearly remap every tween targeting `targetSelector` from the old clip
+ * [oldStart, oldDuration] onto the new [newStart, newDuration] (position and,
+ * when present, duration scaled by the duration ratio). Mirrors recast's
+ * scalePositionsInScript (used by timeline clip-resize).
+ */
+declare function scalePositionsInScript(script: string, targetSelector: string, oldStart: number, oldDuration: number, newStart: number, newDuration: number): string;
+declare function addAnimationToScript(script: string, animation: Omit<GsapAnimation, "id">): {
+    script: string;
+    id: string;
+};
+declare function removeAnimationFromScript(script: string, animationId: string): string;
+declare function updateKeyframeInScript(script: string, animationId: string, percentage: number, properties: Record<string, number | string>, ease?: string): string;
+declare function addKeyframeToScript(script: string, animationId: string, percentage: number, properties: Record<string, number | string>, ease?: string, backfillDefaults?: Record<string, number | string>): string;
+declare function removeKeyframeFromScript(script: string, animationId: string, percentage: number): string;
+declare function removePropertyFromAnimation(script: string, animationId: string, property: string, from?: boolean): string;
+/**
+ * Remove all keyframes from a tween, collapsing to a flat tween with one
+ * keyframe's properties: the first for `from()`, the last otherwise (the
+ * destination = the visible resting state).
+ */
+declare function removeAllKeyframesFromScript(script: string, animationId: string): string;
+/**
+ * Convert a flat tween (to/from/fromTo) to percentage-keyframes format.
+ * `resolvedFromValues` supplies the current DOM state: overrides the 0% endpoint
+ * for `to()`, the 100% endpoint for `from()`, or merges into toProps for `fromTo()`.
+ */
+declare function convertToKeyframesFromScript(script: string, animationId: string, resolvedFromValues?: Record<string, number | string>, setDuration?: number): string;
+/**
+ * Replace a dynamic or static keyframes expression with a fully-resolved
+ * percentage-keyframes object. Called when a user first edits a dynamically-
+ * generated keyframe in the studio so it becomes statically editable.
+ */
+declare function materializeKeyframesFromScript(script: string, animationId: string, keyframes: Array<{
+    percentage: number;
+    properties: Record<string, number | string>;
+    ease?: string;
+}>, easeEach?: string, resolvedSelector?: string): string;
+/** Insert a new keyframed `to()` call and return the new animation ID. */
+declare function addAnimationWithKeyframesToScript(script: string, targetSelector: string, position: number, duration: number, keyframes: Array<{
+    percentage: number;
+    properties: Record<string, number | string>;
+    ease?: string;
+    auto?: boolean;
+}>, ease?: string, easeEach?: string): {
+    script: string;
+    id: string;
+};
+/**
+ * Split a mixed-property tween into one tween per property group (position,
+ * scale, visual, etc.) so each group can be edited independently.
+ * Returns the updated script and the IDs of the newly-created tweens.
+ */
+declare function splitIntoPropertyGroupsFromScript(script: string, animationId: string): {
+    script: string;
+    ids: string[];
+};
+declare function addLabelToScript(script: string, name: string, position: number): string;
+declare function removeLabelFromScript(script: string, name: string): string;
+declare function setArcPathInScript(script: string, animationId: string, config: ArcPathConfig): string;
+declare function updateArcSegmentInScript(script: string, animationId: string, segmentIndex: number, update: Partial<ArcPathSegment>): string;
+declare function removeArcPathFromScript(script: string, animationId: string): string;
+declare function splitAnimationsInScript(script: string, opts: SplitAnimationsOptions): SplitAnimationsResult;
+type UnrollElement = {
+    selector: string;
+    keyframes: Array<{
+        percentage: number;
+        properties: Record<string, number | string>;
+    }>;
+    easeEach?: string;
+};
+/**
+ * Replace a dynamic loop that generates multiple tween calls with individual
+ * static `tl.to()` calls — one per element. Finds the loop containing the
+ * animation and replaces the loop with unrolled static calls, preserving every
+ * non-target statement in the loop body per iteration.
+ */
+declare function unrollDynamicAnimations(script: string, animationId: string, elements: UnrollElement[]): string;
+
+export { type UnrollElement, addAnimationToScript, addAnimationWithKeyframesToScript, addKeyframeToScript, addLabelToScript, convertToKeyframesFromScript, materializeKeyframesFromScript, removeAllKeyframesFromScript, removeAnimationFromScript, removeArcPathFromScript, removeKeyframeFromScript, removeLabelFromScript, removePropertyFromAnimation, scalePositionsInScript, setArcPathInScript, shiftPositionsInScript, splitAnimationsInScript, splitIntoPropertyGroupsFromScript, unrollDynamicAnimations, updateAnimationInScript, updateArcSegmentInScript, updateKeyframeInScript };