@kitsra/kavio-builder 0.1.0

package/dist/index.js

@@ -0,0 +1,1670 @@
+import { validateComposition } from "@kitsra/kavio-schema";
+const propPattern = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+const animatableProperties = ["opacity", "x", "y", "scale", "rotation"];
+export class PropReference {
+    name;
+    metadata;
+    constructor(name, metadata) {
+        if (!propPattern.test(name)) {
+            throw new Error(`Invalid Kavio prop name "${name}".`);
+        }
+        this.name = name;
+        if (metadata !== undefined) {
+            this.metadata = metadata;
+        }
+    }
+    toString() {
+        return interpolationFor(this.name);
+    }
+    toJSON() {
+        return interpolationFor(this.name);
+    }
+}
+export class AssetReference {
+    id;
+    type;
+    definition;
+    constructor(id, type, src, options = {}) {
+        assertId(id, "asset");
+        this.id = id;
+        this.type = type;
+        this.definition = compactObject({
+            type,
+            src,
+            ...options
+        });
+    }
+    toDefinition() {
+        return { ...this.definition };
+    }
+    toString() {
+        return this.id;
+    }
+    toJSON() {
+        return this.id;
+    }
+}
+export class LayerBuilder {
+    layer;
+    constructor(layer) {
+        this.layer = layer;
+    }
+    animate(property, frames) {
+        return this.motion({ [property]: frames });
+    }
+    motion(frames) {
+        const existing = isRecord(this.layer.keyframes) ? this.layer.keyframes : {};
+        const next = { ...existing };
+        for (const property of animatableProperties) {
+            const propertyFrames = frames[property];
+            if (propertyFrames !== undefined) {
+                next[property] = propertyFrames.map((frame) => ({ ...frame }));
+            }
+        }
+        this.layer.keyframes = next;
+        return this;
+    }
+    transitionIn(definition) {
+        this.layer.transitionIn = { ...definition };
+        return this;
+    }
+    transitionOut(definition) {
+        this.layer.transitionOut = { ...definition };
+        return this;
+    }
+    enter(definition) {
+        return this.transitionIn(definition);
+    }
+    exit(definition) {
+        return this.transitionOut(definition);
+    }
+    toInput() {
+        return cloneAuthorObject(this.layer);
+    }
+    toJSON() {
+        return normalizeStandalone(this.layer);
+    }
+    get id() {
+        return String(this.layer.id);
+    }
+}
+export class TrackBuilder {
+    definition;
+    constructor(id, clips = []) {
+        assertId(id, "track");
+        this.definition = {
+            id,
+            clips: clips.map((clip) => cloneTrackClip(clip))
+        };
+    }
+    clip(id, options) {
+        this.definition.clips.push(trackClip(id, options));
+        return this;
+    }
+    toInput() {
+        return {
+            id: this.definition.id,
+            clips: this.definition.clips.map((clip) => cloneTrackClip(clip))
+        };
+    }
+    toJSON() {
+        return normalizeStandalone(this.toInput());
+    }
+}
+export class VideoBuilder {
+    composition;
+    metadata;
+    propDefinitions = new Map();
+    assetDefinitions = new Map();
+    layers = [];
+    trackDefinitions = [];
+    audioTracks = [];
+    exportDefinitions = [];
+    constructor(composition, options = {}) {
+        this.composition = { ...composition };
+        if (options.metadata !== undefined) {
+            this.metadata = options.metadata;
+        }
+    }
+    prop(reference) {
+        this.registerProp(reference);
+        return this;
+    }
+    props(...references) {
+        for (const reference of references) {
+            this.registerProp(reference);
+        }
+        return this;
+    }
+    asset(reference) {
+        this.registerAsset(reference);
+        return this;
+    }
+    assets(...references) {
+        for (const reference of references) {
+            this.registerAsset(reference);
+        }
+        return this;
+    }
+    add(...layers) {
+        for (const layer of layers) {
+            this.layers.push(layer.toInput());
+        }
+        return this;
+    }
+    addTrack(...tracks) {
+        for (const entry of tracks) {
+            this.trackDefinitions.push(entry instanceof TrackBuilder ? entry.toInput() : cloneTrack(entry));
+        }
+        return this;
+    }
+    tracks(...tracks) {
+        return this.addTrack(...tracks);
+    }
+    audio(options) {
+        const entry = compactObject({
+            ...options,
+            id: options.id ?? (options.asset instanceof AssetReference ? options.asset.id : undefined)
+        });
+        this.audioTracks.push(entry);
+        return this;
+    }
+    addExport(definition) {
+        this.exportDefinitions.push(compactObject(definition));
+        return this;
+    }
+    exports(...definitions) {
+        for (const definition of definitions) {
+            this.addExport(definition);
+        }
+        return this;
+    }
+    toJSON() {
+        const props = this.normalizeProps();
+        const document = {
+            version: "0.1",
+            ...(this.metadata === undefined ? {} : { metadata: this.normalize(this.metadata) }),
+            composition: this.normalize(this.composition),
+            ...(Object.keys(props).length === 0 ? {} : { props }),
+            assets: this.normalizeAssets(),
+            layers: this.layers.map((layer) => this.normalize(layer)),
+            ...(this.trackDefinitions.length === 0
+                ? {}
+                : { tracks: this.trackDefinitions.map((track) => this.normalize(track)) }),
+            audio: this.audioTracks.map((track) => this.normalize(track)),
+            exports: this.exportDefinitions.map((definition) => this.normalize(definition))
+        };
+        return structuredClone(document);
+    }
+    validate() {
+        return validateComposition(this.toJSON());
+    }
+    registerAsset(reference) {
+        this.assetDefinitions.set(reference.id, reference.toDefinition());
+    }
+    registerProp(reference) {
+        if (reference.metadata === undefined) {
+            return;
+        }
+        const existing = this.propDefinitions.get(reference.name) ?? {};
+        this.propDefinitions.set(reference.name, { ...existing, ...reference.metadata });
+    }
+    normalizeProps() {
+        const output = {};
+        for (const [name, metadata] of this.propDefinitions) {
+            output[name] = this.normalize(metadata);
+        }
+        return output;
+    }
+    normalizeAssets() {
+        const output = {};
+        for (const [id, definition] of this.assetDefinitions) {
+            output[id] = this.normalize(definition);
+        }
+        return output;
+    }
+    normalize(value) {
+        if (value instanceof PropReference) {
+            this.registerProp(value);
+            return interpolationFor(value.name);
+        }
+        if (value instanceof AssetReference) {
+            this.registerAsset(value);
+            return value.id;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.normalize(item));
+        }
+        if (isRecord(value)) {
+            const output = {};
+            for (const [key, nested] of Object.entries(value)) {
+                if (nested !== undefined) {
+                    output[key] = this.normalize(nested);
+                }
+            }
+            return output;
+        }
+        return value;
+    }
+}
+export function video(composition, options) {
+    return new VideoBuilder(composition, options);
+}
+export function prop(name, metadata) {
+    return new PropReference(name, metadata);
+}
+export function validate(input) {
+    return validateComposition(input instanceof VideoBuilder ? input.toJSON() : input);
+}
+export const asset = {
+    video(id, src, options) {
+        return new AssetReference(id, "video", src, options);
+    },
+    image(id, src, options) {
+        return new AssetReference(id, "image", src, options);
+    },
+    audio(id, src, options) {
+        return new AssetReference(id, "audio", src, options);
+    },
+    font(id, src, options) {
+        return new AssetReference(id, "font", src, options);
+    }
+};
+export function clip(id, options) {
+    return buildLayer(id, "video", options);
+}
+export function videoLayer(id, options) {
+    return clip(id, options);
+}
+export function image(id, options) {
+    return buildLayer(id, "image", options);
+}
+export function text(id, options) {
+    return buildLayer(id, "text", options);
+}
+export function shape(id, options) {
+    return buildLayer(id, "shape", { shape: "rect", ...options });
+}
+export function caption(id, options) {
+    return buildLayer(id, "caption", options);
+}
+export function trackClip(id, options) {
+    assertId(id, "track clip");
+    const definition = {
+        id,
+        layerId: layerIdFor(options.layerId),
+        startFrame: options.startFrame,
+        durationFrames: options.durationFrames
+    };
+    if (options.transitionFromPrevious !== undefined) {
+        definition.transitionFromPrevious = transitionSeries.fromPrevious(options.transitionFromPrevious);
+    }
+    return definition;
+}
+export function track(id, clips = []) {
+    return new TrackBuilder(id, clips);
+}
+export const layers = {
+    video: videoLayer,
+    clip,
+    image,
+    text,
+    shape,
+    caption
+};
+export const transition = {
+    fade(options) {
+        return transitionDefinition("fade", options);
+    },
+    slide(options) {
+        return transitionDefinition("slide", options);
+    },
+    wipe(options) {
+        return transitionDefinition("wipe", options);
+    },
+    crossfade(options) {
+        return transitionDefinition("crossfade", options);
+    },
+    zoom(options = { durationFrames: 12 }) {
+        return transitionDefinition("zoom", options);
+    },
+    push(options) {
+        return transitionDefinition("push", options);
+    },
+    spin(options = { durationFrames: 12 }) {
+        return transitionDefinition("spin", options);
+    },
+    rotate(options = { durationFrames: 12 }) {
+        return transitionDefinition("rotate", options);
+    },
+    flip(options = { durationFrames: 12 }) {
+        return transitionDefinition("flip", options);
+    },
+    blurDissolve(options = { durationFrames: 12 }) {
+        return transitionDefinition("blurDissolve", options);
+    },
+    colorDissolve(options = { durationFrames: 12 }) {
+        return transitionDefinition("colorDissolve", options);
+    },
+    dip(options = { durationFrames: 12 }) {
+        return transitionDefinition("dip", options);
+    },
+    iris(options = { durationFrames: 12 }) {
+        return transitionDefinition("iris", options);
+    },
+    stretch(options = { durationFrames: 12 }) {
+        return transitionDefinition("stretch", options);
+    },
+    squeeze(options = { durationFrames: 12 }) {
+        return transitionDefinition("squeeze", options);
+    },
+    clockWipe(options = { durationFrames: 12 }) {
+        return transitionDefinition("clockWipe", options);
+    },
+    barWipe(options = { durationFrames: 12 }) {
+        return transitionDefinition("barWipe", options);
+    },
+    gridWipe(options = { durationFrames: 12 }) {
+        return transitionDefinition("gridWipe", options);
+    },
+    tileReveal(options = { durationFrames: 12 }) {
+        return transitionDefinition("tileReveal", options);
+    },
+    radialBlur(options = { durationFrames: 12 }) {
+        return transitionDefinition("radialBlur", options);
+    },
+    zoomBlur(options = { durationFrames: 12 }) {
+        return transitionDefinition("zoomBlur", options);
+    },
+    bookFlip(options = { durationFrames: 12 }) {
+        return transitionDefinition("bookFlip", options);
+    },
+    pageCurlLite(options = { durationFrames: 12 }) {
+        return transitionDefinition("pageCurlLite", options);
+    },
+    skewSlide(options = { durationFrames: 12 }) {
+        return transitionDefinition("skewSlide", options);
+    },
+    expandMask(options = { durationFrames: 12 }) {
+        return transitionDefinition("expandMask", options);
+    },
+    letterboxReveal(options = { durationFrames: 12 }) {
+        return transitionDefinition("letterboxReveal", options);
+    },
+    filmFlash(options = { durationFrames: 6 }) {
+        return transitionDefinition("filmFlash", options);
+    },
+    cameraWhip(options = { durationFrames: 8 }) {
+        return transitionDefinition("cameraWhip", options);
+    }
+};
+export const transitions = transition;
+export const transitionSeries = {
+    fromPrevious(definition) {
+        if (isTransitionSeriesDefinition(definition)) {
+            return cloneTransitionSeriesDefinition(definition);
+        }
+        return transitionSeriesDefinition(definition);
+    }
+};
+export const camera = {
+    kenBurns(options) {
+        const amount = cameraTravelAmount(options, 36);
+        const direction = options.direction ?? "right";
+        const frames = zoomMotion(options, 1, 1 + cameraIntensity(options, 0.08));
+        if (direction === "left" || direction === "right") {
+            frames.x = cameraAxisFrames({
+                durationFrames: options.durationFrames,
+                easing: options.easing,
+                axis: "x",
+                direction,
+                amount,
+                restingValue: options.restingX ?? 0,
+                subjectAnchor: options.subjectAnchor
+            });
+        }
+        else if (direction === "up" || direction === "down") {
+            frames.y = cameraAxisFrames({
+                durationFrames: options.durationFrames,
+                easing: options.easing,
+                axis: "y",
+                direction,
+                amount,
+                restingValue: options.restingY ?? 0,
+                subjectAnchor: options.subjectAnchor
+            });
+        }
+        return frames;
+    },
+    pushIn(options) {
+        return zoomMotion(options, options.fromScale ?? 1, options.toScale ?? 1 + cameraIntensity(options, 0.08));
+    },
+    pullBack(options) {
+        return zoomMotion(options, options.fromScale ?? 1 + cameraIntensity(options, 0.08), options.toScale ?? 1);
+    },
+    pan(options) {
+        const direction = options.direction ?? "left";
+        const amount = cameraTravelAmount(options, 72);
+        const scale = options.scale ?? 1 + cameraIntensity(options, 0.04);
+        const frames = {
+            x: cameraAxisFrames({
+                durationFrames: options.durationFrames,
+                easing: options.easing,
+                axis: "x",
+                direction,
+                amount,
+                restingValue: options.restingX ?? 0,
+                fromValue: options.fromX,
+                toValue: options.toX,
+                subjectAnchor: options.subjectAnchor
+            })
+        };
+        if (scale !== 1) {
+            frames.scale = cameraTrack(options.durationFrames, scale, scale);
+        }
+        return frames;
+    },
+    tilt(options) {
+        const direction = options.direction ?? "up";
+        const amount = cameraTravelAmount(options, 72);
+        const scale = options.scale ?? 1 + cameraIntensity(options, 0.04);
+        const frames = {
+            y: cameraAxisFrames({
+                durationFrames: options.durationFrames,
+                easing: options.easing,
+                axis: "y",
+                direction,
+                amount,
+                restingValue: options.restingY ?? 0,
+                fromValue: options.fromY,
+                toValue: options.toY,
+                subjectAnchor: options.subjectAnchor
+            })
+        };
+        if (scale !== 1) {
+            frames.scale = cameraTrack(options.durationFrames, scale, scale);
+        }
+        return frames;
+    },
+    parallax(options) {
+        const direction = options.direction ?? "right";
+        const amount = cameraTravelAmount(options, 48);
+        const frames = zoomMotion(options, options.fromScale ?? 1.02, options.toScale ?? 1.02 + cameraIntensity(options, 0.04));
+        if (direction === "left" || direction === "right") {
+            frames.x = cameraAxisFrames({
+                durationFrames: options.durationFrames,
+                easing: options.easing,
+                axis: "x",
+                direction,
+                amount,
+                restingValue: options.restingX ?? 0,
+                fromValue: options.fromX,
+                toValue: options.toX,
+                subjectAnchor: options.subjectAnchor
+            });
+        }
+        else if (direction === "up" || direction === "down") {
+            frames.y = cameraAxisFrames({
+                durationFrames: options.durationFrames,
+                easing: options.easing,
+                axis: "y",
+                direction,
+                amount,
+                restingValue: options.restingY ?? 0,
+                fromValue: options.fromY,
+                toValue: options.toY,
+                subjectAnchor: options.subjectAnchor
+            });
+        }
+        return frames;
+    },
+    orbitLite(options) {
+        const endFrame = cameraEndFrame(options.durationFrames);
+        const middleFrame = Math.floor(endFrame / 2);
+        const amount = cameraTravelAmount(options, 42);
+        const halfAmount = amount / 2;
+        const verticalAmount = cameraTravelAmount({ ...options, amount: options.verticalAmount ?? 18 }, 18);
+        const rotationAmount = options.rotationAmount ?? 1.8 * (1 + cameraIntensity(options, 0));
+        const directionSign = (options.direction ?? "right") === "left" ? -1 : 1;
+        const restingX = options.restingX ?? 0;
+        const restingY = options.restingY ?? 0;
+        const restingRotation = options.restingRotation ?? 0;
+        const frames = {
+            x: cameraThreePointTrack(options.durationFrames, restingX - directionSign * halfAmount, restingX, restingX + directionSign * halfAmount, options.easing),
+            scale: cameraThreePointTrack(options.durationFrames, options.fromScale ?? 1.02, Math.max(options.fromScale ?? 1.02, options.toScale ?? 1.05), options.toScale ?? 1.02, options.easing),
+            rotation: cameraTrack(options.durationFrames, restingRotation - directionSign * rotationAmount, restingRotation + directionSign * rotationAmount, options.easing)
+        };
+        if (endFrame > 1 && verticalAmount !== 0) {
+            frames.y = [
+                compactObject({ frame: 0, value: restingY + verticalAmount / 2, easing: options.easing }),
+                compactObject({ frame: middleFrame, value: restingY - verticalAmount / 2, easing: options.easing }),
+                { frame: endFrame, value: restingY + verticalAmount / 2 }
+            ];
+        }
+        return frames;
+    },
+    handheld(options) {
+        const amount = cameraTravelAmount(options, 8);
+        const rotationAmount = options.rotationAmount ?? 0.8 * (1 + cameraIntensity(options, 0));
+        const scale = options.scale ?? 1 + cameraIntensity(options, 0.02);
+        const frames = {
+            x: cameraJitterTrack({
+                durationFrames: options.durationFrames,
+                seed: options.seed ?? 1,
+                intervalFrames: options.intervalFrames ?? 6,
+                restingValue: options.restingX ?? 0,
+                amount,
+                easing: options.easing ?? "inOutQuad"
+            }),
+            y: cameraJitterTrack({
+                durationFrames: options.durationFrames,
+                seed: (options.seed ?? 1) + 101,
+                intervalFrames: options.intervalFrames ?? 6,
+                restingValue: options.restingY ?? 0,
+                amount: amount * 0.65,
+                easing: options.easing ?? "inOutQuad"
+            }),
+            rotation: cameraJitterTrack({
+                durationFrames: options.durationFrames,
+                seed: (options.seed ?? 1) + 211,
+                intervalFrames: options.intervalFrames ?? 6,
+                restingValue: options.restingRotation ?? 0,
+                amount: rotationAmount,
+                easing: options.easing ?? "inOutQuad"
+            })
+        };
+        if (scale !== 1) {
+            frames.scale = cameraTrack(options.durationFrames, scale, scale);
+        }
+        return frames;
+    },
+    crashZoom(options) {
+        const direction = options.direction ?? "in";
+        const intensityValue = cameraIntensity(options, 0.28);
+        const fromScale = options.fromScale ?? (direction === "in" ? 1 : 1 + intensityValue);
+        const toScale = options.toScale ?? (direction === "in" ? 1 + intensityValue : 1);
+        const overshootDirection = direction === "in" ? 1 : -1;
+        const overshootScale = options.overshootScale ?? toScale + overshootDirection * intensityValue * 0.2;
+        return {
+            scale: cameraCrashZoomTrack({
+                durationFrames: options.durationFrames,
+                easing: options.easing ?? "outCubic",
+                fromScale,
+                overshootScale,
+                toScale,
+                impactFrame: options.impactFrame
+            })
+        };
+    },
+    dollyZoomLite(options) {
+        const direction = options.direction ?? "out";
+        const intensityValue = cameraIntensity(options, 0.12);
+        const fromScale = options.fromScale ?? (direction === "out" ? 1 + intensityValue : 1);
+        const toScale = options.toScale ?? (direction === "out" ? 1 : 1 + intensityValue);
+        const amount = cameraTravelAmount(options, 28);
+        const xBias = anchorBias(options.subjectAnchor, "x");
+        const yBias = anchorBias(options.subjectAnchor, "y");
+        const directionSign = direction === "out" ? 1 : -1;
+        const frames = zoomMotion(options, fromScale, toScale);
+        if (options.fromX !== undefined || options.toX !== undefined || xBias !== 0) {
+            const restingX = options.restingX ?? 0;
+            frames.x = cameraTrack(options.durationFrames, options.fromX ?? restingX - xBias * amount * directionSign, options.toX ?? restingX + xBias * amount * directionSign, options.easing);
+        }
+        if (options.fromY !== undefined || options.toY !== undefined || yBias !== 0) {
+            const restingY = options.restingY ?? 0;
+            frames.y = cameraTrack(options.durationFrames, options.fromY ?? restingY - yBias * amount * directionSign, options.toY ?? restingY + yBias * amount * directionSign, options.easing);
+        }
+        return frames;
+    }
+};
+export const cinematic = {
+    zoomPush(options = {}) {
+        const durationFrames = options.durationFrames ?? 14;
+        return compactObject({
+            transitionIn: transition.zoom({
+                durationFrames,
+                amount: options.intensity ?? 0.18,
+                easing: options.easing ?? "outCubic"
+            }),
+            transitionOut: transition.push({
+                direction: options.direction ?? "left",
+                durationFrames,
+                easing: options.easing ?? "inCubic"
+            })
+        });
+    },
+    whipPan(options = {}) {
+        return compactObject({
+            transitionIn: transition.push({
+                direction: options.direction ?? "left",
+                durationFrames: options.durationFrames ?? 8,
+                easing: options.easing ?? "inOutCubic",
+                intensity: options.intensity
+            })
+        });
+    },
+    filmFlash(options = {}) {
+        return compactObject({
+            transitionIn: transition.colorDissolve({
+                color: options.color ?? "#ffffff",
+                durationFrames: options.durationFrames ?? 6,
+                amount: options.intensity ?? 1,
+                easing: options.easing ?? "outQuad"
+            })
+        });
+    },
+    dreamyBlur(options = {}) {
+        return compactObject({
+            transitionIn: transition.blurDissolve({
+                durationFrames: options.durationFrames ?? 18,
+                amount: options.intensity ?? 18,
+                easing: options.easing ?? "outCubic"
+            })
+        });
+    },
+    broadcastDip(options = {}) {
+        return compactObject({
+            transitionIn: transition.dip({
+                color: options.color ?? "#05070a",
+                durationFrames: options.durationFrames ?? 10,
+                amount: options.intensity ?? 1,
+                easing: options.easing ?? "inOutCubic"
+            })
+        });
+    },
+    irisOpen(options = {}) {
+        return compactObject({
+            transitionIn: transition.iris({
+                shape: options.shape ?? "circle",
+                durationFrames: options.durationFrames ?? 16,
+                intensity: options.intensity,
+                easing: options.easing ?? "outCubic"
+            })
+        });
+    },
+    flipCard(options = {}) {
+        return compactObject({
+            transitionIn: transition.flip({
+                axis: options.axis ?? "y",
+                direction: options.direction,
+                durationFrames: options.durationFrames ?? 14,
+                amount: options.intensity ?? 90,
+                easing: options.easing ?? "outCubic"
+            })
+        });
+    },
+    glitchCut(options = {}) {
+        const durationFrames = options.durationFrames ?? 8;
+        const endFrame = cameraEndFrame(durationFrames);
+        const direction = options.direction ?? "left";
+        const directionSign = direction === "right" || direction === "down" ? 1 : -1;
+        const axis = direction === "up" || direction === "down" ? "y" : "x";
+        const offset = roundMotionValue((options.intensity ?? 1) * 14 * directionSign);
+        const jitter = roundMotionValue((seedToUnit(normalizeSeed(options.seed ?? 17)) * 2 - 1) * 6 * (options.intensity ?? 1));
+        const settleFrame = Math.min(endFrame, 3);
+        return compactObject({
+            transitionIn: transition.skewSlide({
+                direction,
+                durationFrames,
+                intensity: 12 * (options.intensity ?? 1),
+                easing: options.easing ?? "outExpo"
+            }),
+            keyframes: compactObject({
+                [axis]: keyframes([
+                    { frame: 0, value: offset, timing: timing.steps({ steps: 2, direction: "end" }) },
+                    { frame: 1, value: roundMotionValue(-offset * 0.45 + jitter), timing: timing.steps({ steps: 2, direction: "end" }) },
+                    { frame: settleFrame, value: 0, easing: options.easing ?? "outExpo" }
+                ]),
+                opacity: keyframes([
+                    { frame: 0, value: 0.72, timing: timing.steps({ steps: 2, direction: "end" }) },
+                    { frame: settleFrame, value: 1 }
+                ])
+            })
+        });
+    },
+    lightLeak(options = {}) {
+        const durationFrames = options.durationFrames ?? 14;
+        const easingValue = options.easing ?? "outQuad";
+        const drift = roundMotionValue(10 * (options.intensity ?? 1));
+        return compactObject({
+            transitionIn: transition.colorDissolve({
+                color: options.color ?? "#fff1b8",
+                durationFrames,
+                amount: options.intensity ?? 0.72,
+                easing: easingValue
+            }),
+            keyframes: compactObject({
+                x: cameraTrack(durationFrames, -drift, drift, easingValue),
+                opacity: keyframes([
+                    [0, 0.82, easingValue],
+                    [Math.max(1, durationFrames - 1), 1]
+                ])
+            })
+        });
+    },
+    kenBurns(options = {}) {
+        const durationFrames = options.durationFrames ?? 90;
+        const subjectStart = options.subject === undefined
+            ? undefined
+            : options.easing === undefined
+                ? { frame: 0, x: options.subject.fromX, y: options.subject.fromY }
+                : { frame: 0, x: options.subject.fromX, y: options.subject.fromY, easing: options.easing };
+        const subjectCropOptions = options.subject === undefined
+            ? undefined
+            : {
+                keyframes: [subjectStart, { frame: durationFrames, x: options.subject.toX, y: options.subject.toY }],
+                ...(options.subject.smoothingFrames === undefined ? {} : { smoothingFrames: options.subject.smoothingFrames }),
+                ...(options.subject.source === undefined ? {} : { source: options.subject.source })
+            };
+        return compactObject({
+            keyframes: compactObject({
+                scale: keyframes([
+                    [0, options.fromScale ?? 1.04, options.easing ?? "outCubic"],
+                    [durationFrames, options.toScale ?? 1.14]
+                ]),
+                x: options.fromX === undefined && options.toX === undefined
+                    ? undefined
+                    : keyframes([
+                        [0, options.fromX ?? 0, options.easing ?? "outCubic"],
+                        [durationFrames, options.toX ?? 0]
+                    ]),
+                y: options.fromY === undefined && options.toY === undefined
+                    ? undefined
+                    : keyframes([
+                        [0, options.fromY ?? 0, options.easing ?? "outCubic"],
+                        [durationFrames, options.toY ?? 0]
+                    ])
+            }),
+            crop: subjectCropOptions === undefined ? undefined : crop.subject(subjectCropOptions)
+        });
+    },
+    logoSting(options = {}) {
+        const durationFrames = options.durationFrames ?? 18;
+        const easingValue = options.easing ?? "outBack";
+        const rotationDirection = options.direction === "right" || options.direction === "down" ? 1 : -1;
+        return compactObject({
+            transitionIn: transition.zoom({
+                durationFrames: Math.max(1, Math.round(durationFrames * 0.6)),
+                amount: options.intensity ?? 0.12,
+                easing: easingValue
+            }),
+            transitionOut: transition.fade({
+                durationFrames: Math.max(1, Math.round(durationFrames * 0.45)),
+                easing: "inCubic"
+            }),
+            keyframes: compactObject({
+                scale: cameraThreePointTrack(durationFrames, 0.92, 1 + cameraIntensity(options, 0.04), 1, easingValue),
+                rotation: cameraTrack(durationFrames, rotationDirection * -2, 0, options.easing ?? "outCubic")
+            })
+        });
+    },
+    productReveal(options = {}) {
+        const durationFrames = options.durationFrames ?? 24;
+        const easingValue = options.easing ?? "outCubic";
+        return compactObject({
+            transitionIn: transition.wipe({
+                direction: options.direction ?? "up",
+                durationFrames,
+                easing: easingValue
+            }),
+            keyframes: compactObject({
+                scale: cameraTrack(durationFrames, 0.96, 1 + cameraIntensity(options, 0.02), easingValue),
+                opacity: entranceOpacityKeyframes(Math.max(1, Math.round(durationFrames * 0.6)), easingValue)
+            })
+        });
+    },
+    socialHook(options = {}) {
+        const durationFrames = options.durationFrames ?? 16;
+        const easingValue = options.easing ?? "outCubic";
+        return compactObject({
+            transitionIn: transition.colorDissolve({
+                color: options.color ?? "#ffffff",
+                durationFrames: Math.max(1, Math.round(durationFrames * 0.45)),
+                amount: options.intensity ?? 0.7,
+                easing: "outQuad"
+            }),
+            transitionOut: transition.push({
+                direction: options.direction ?? "left",
+                durationFrames: Math.max(1, Math.round(durationFrames * 0.5)),
+                easing: "inCubic"
+            }),
+            keyframes: compactObject({
+                scale: cameraCrashZoomTrack({
+                    durationFrames,
+                    easing: easingValue,
+                    fromScale: 1 + cameraIntensity(options, 0.16),
+                    overshootScale: 0.98,
+                    toScale: 1
+                })
+            })
+        });
+    },
+    titleSequence(options = {}) {
+        const durationFrames = options.durationFrames ?? 30;
+        const easingValue = options.easing ?? "outCubic";
+        return compactObject({
+            transitionIn: transition.slide({
+                direction: options.direction ?? "up",
+                durationFrames,
+                easing: easingValue
+            }),
+            transitionOut: transition.slide({
+                direction: options.exitDirection ?? "down",
+                durationFrames: Math.max(1, Math.round(durationFrames * 0.55)),
+                easing: "inCubic"
+            }),
+            keyframes: compactObject({
+                opacity: entranceOpacityKeyframes(durationFrames, easingValue)
+            })
+        });
+    },
+    endCard(options = {}) {
+        const durationFrames = options.durationFrames ?? 20;
+        const easingValue = options.easing ?? "outCubic";
+        const horizontalDirection = options.direction === "left" || options.direction === "right" ? options.direction : undefined;
+        const verticalDirection = options.direction === "up" || options.direction === "down" ? options.direction : undefined;
+        return compactObject({
+            transitionIn: transition.dip({
+                color: options.color ?? "#05070a",
+                durationFrames,
+                amount: options.intensity ?? 1,
+                easing: "inOutCubic"
+            }),
+            transitionOut: transition.fade({
+                durationFrames: Math.max(1, Math.round(durationFrames * 0.5)),
+                easing: "inCubic"
+            }),
+            keyframes: compactObject({
+                scale: cameraTrack(durationFrames, 0.98, 1, easingValue),
+                x: horizontalDirection === undefined
+                    ? undefined
+                    : cameraAxisFrames({
+                        durationFrames,
+                        easing: easingValue,
+                        axis: "x",
+                        direction: horizontalDirection,
+                        amount: 20 * (1 + cameraIntensity(options, 0)),
+                        restingValue: 0
+                    }),
+                y: verticalDirection === undefined
+                    ? undefined
+                    : cameraAxisFrames({
+                        durationFrames,
+                        easing: easingValue,
+                        axis: "y",
+                        direction: verticalDirection,
+                        amount: 20 * (1 + cameraIntensity(options, 0)),
+                        restingValue: 0
+                    })
+            })
+        });
+    }
+};
+export const cinematicPresets = cinematic;
+function textMotionPreset(type, options, defaults) {
+    return {
+        textMotion: compactObject({
+            type,
+            split: options.split ?? defaults.split,
+            durationFrames: options.durationFrames ?? defaults.durationFrames,
+            easing: options.easing ?? defaults.easing,
+            staggerFrames: options.staggerFrames ?? defaults.staggerFrames,
+            origin: options.origin,
+            seed: options.seed,
+            preserveLayout: options.preserveLayout ?? true,
+            restingBox: options.restingBox,
+            direction: options.direction,
+            amount: options.amount,
+            intensity: options.intensity,
+            color: options.color
+        })
+    };
+}
+export const textMotion = {
+    rise(options = {}) {
+        const durationFrames = options.durationFrames ?? 14;
+        const easingValue = options.easing ?? "outCubic";
+        return {
+            transitionIn: transition.slide({
+                direction: options.direction ?? "up",
+                durationFrames,
+                easing: easingValue
+            }),
+            keyframes: {
+                opacity: entranceOpacityKeyframes(durationFrames, easingValue)
+            }
+        };
+    },
+    blurIn(options = {}) {
+        return {
+            transitionIn: transition.blurDissolve({
+                durationFrames: options.durationFrames ?? 12,
+                amount: options.amount,
+                intensity: options.intensity,
+                easing: options.easing ?? "outCubic"
+            })
+        };
+    },
+    typeOn(options = {}) {
+        return textMotionPreset("typeOn", options, {
+            split: "char",
+            durationFrames: 18,
+            easing: "linear",
+            staggerFrames: 1
+        });
+    },
+    cascade(options = {}) {
+        return textMotionPreset("cascade", options, {
+            split: "word",
+            durationFrames: 14,
+            easing: "outCubic",
+            staggerFrames: 2
+        });
+    },
+    scramble(options = {}) {
+        return textMotionPreset("scramble", options, {
+            split: "char",
+            durationFrames: 18,
+            easing: "outCubic",
+            staggerFrames: 1
+        });
+    },
+    highlightSweep(options = {}) {
+        return textMotionPreset("highlightSweep", options, {
+            split: "word",
+            durationFrames: 18,
+            easing: "outCubic",
+            staggerFrames: 0
+        });
+    },
+    trackingIn(options = {}) {
+        return textMotionPreset("trackingIn", options, {
+            split: "char",
+            durationFrames: 16,
+            easing: "outCubic",
+            staggerFrames: 1
+        });
+    }
+};
+export const textMotions = textMotion;
+export const effect = {};
+export const presetNamespaces = {
+    transition,
+    cinematic,
+    textMotion,
+    camera,
+    effect
+};
+export function keyframes(frames) {
+    return frames.map((frame) => {
+        if (isKeyframeTuple(frame)) {
+            const [frameNumber, value, ease] = frame;
+            return compactObject({
+                frame: frameNumber,
+                value,
+                easing: ease
+            });
+        }
+        return compactObject({
+            frame: frame.frame,
+            value: frame.value,
+            easing: frame.easing,
+            timing: frame.timing
+        });
+    });
+}
+export const easing = {
+    linear: "linear",
+    inQuad: "inQuad",
+    outQuad: "outQuad",
+    inOutQuad: "inOutQuad",
+    inCubic: "inCubic",
+    outCubic: "outCubic",
+    inOutCubic: "inOutCubic",
+    inCirc: "inCirc",
+    outCirc: "outCirc",
+    inOutCirc: "inOutCirc",
+    inExpo: "inExpo",
+    outExpo: "outExpo",
+    inOutExpo: "inOutExpo",
+    anticipate: "anticipate",
+    back: "back",
+    inBack: "inBack",
+    outBack: "outBack",
+    inOutBack: "inOutBack",
+    inElastic: "inElastic",
+    outElastic: "outElastic",
+    inOutElastic: "inOutElastic",
+    inBounce: "inBounce",
+    outBounce: "outBounce",
+    inOutBounce: "inOutBounce",
+    cubicBezier(x1, y1, x2, y2) {
+        return `cubic-bezier(${x1},${y1},${x2},${y2})`;
+    }
+};
+export const timing = {
+    tween(options = {}) {
+        assertOptionalPositiveInteger(options.durationFrames, "tween durationFrames");
+        return compactObject({
+            type: "tween",
+            durationFrames: options.durationFrames,
+            easing: options.easing
+        });
+    },
+    spring(options = {}) {
+        assertOptionalPositiveInteger(options.durationFrames, "spring durationFrames");
+        assertOptionalPositiveNumber(options.stiffness, "spring stiffness");
+        assertOptionalPositiveNumber(options.damping, "spring damping");
+        assertOptionalPositiveNumber(options.mass, "spring mass");
+        assertOptionalNonNegativeNumber(options.restSpeed, "spring restSpeed");
+        assertOptionalRange(options.bounce, "spring bounce", 0, 1);
+        return compactObject({
+            type: "spring",
+            durationFrames: options.durationFrames,
+            stiffness: options.stiffness,
+            damping: options.damping,
+            mass: options.mass,
+            restSpeed: options.restSpeed,
+            bounce: options.bounce
+        });
+    },
+    steps(options) {
+        assertOptionalPositiveInteger(options.durationFrames, "steps durationFrames");
+        assertPositiveInteger(options.steps, "steps");
+        return compactObject({
+            type: "steps",
+            durationFrames: options.durationFrames,
+            steps: options.steps,
+            direction: options.direction
+        });
+    },
+    sequence(segments) {
+        if (segments.length === 0) {
+            throw new Error("sequence timing requires at least one segment.");
+        }
+        return {
+            type: "sequence",
+            segments: segments.map((segment) => {
+                assertPositiveInteger(segment.durationFrames, "sequence segment durationFrames");
+                return compactObject({
+                    durationFrames: segment.durationFrames,
+                    timing: segment.timing,
+                    from: segment.from,
+                    to: segment.to
+                });
+            })
+        };
+    },
+    stagger(options) {
+        assertPositiveInteger(options.childCount, "stagger childCount");
+        assertNonNegativeInteger(options.eachFrames, "stagger eachFrames");
+        assertOptionalNonNegativeInteger(options.childIndex, "stagger childIndex");
+        if (options.childIndex !== undefined && options.childIndex >= options.childCount) {
+            throw new Error("stagger childIndex must be lower than childCount.");
+        }
+        return compactObject({
+            type: "stagger",
+            timing: options.timing,
+            childCount: options.childCount,
+            eachFrames: options.eachFrames,
+            childIndex: options.childIndex,
+            from: options.from
+        });
+    }
+};
+export const exportPreset = {
+    vertical(options = {}) {
+        return exportDefinition({
+            name: "vertical-9x16",
+            format: "mp4",
+            codec: "h264",
+            width: 1080,
+            height: 1920,
+            ...options
+        });
+    },
+    reels(options = {}) {
+        return exportDefinition({
+            name: "reels",
+            format: "mp4",
+            codec: "h264",
+            width: 1080,
+            height: 1920,
+            ...options
+        });
+    },
+    instagramReels(options = {}) {
+        return exportDefinition({
+            name: "instagram-reels-9x16",
+            format: "mp4",
+            codec: "h264",
+            width: 1080,
+            height: 1920,
+            ...options
+        });
+    },
+    tiktok(options = {}) {
+        return exportDefinition({
+            name: "tiktok-9x16",
+            format: "mp4",
+            codec: "h264",
+            width: 1080,
+            height: 1920,
+            ...options
+        });
+    },
+    youtubeShorts(options = {}) {
+        return exportDefinition({
+            name: "youtube-shorts-9x16",
+            format: "mp4",
+            codec: "h264",
+            width: 1080,
+            height: 1920,
+            ...options
+        });
+    },
+    facebookReels(options = {}) {
+        return exportDefinition({
+            name: "facebook-reels-9x16",
+            format: "mp4",
+            codec: "h264",
+            width: 1080,
+            height: 1920,
+            ...options
+        });
+    },
+    square(options = {}) {
+        return exportDefinition({
+            name: "square",
+            format: "mp4",
+            codec: "h264",
+            width: 1080,
+            height: 1080,
+            ...options
+        });
+    },
+    portrait(options = {}) {
+        return exportDefinition({
+            name: "portrait-4x5",
+            format: "mp4",
+            codec: "h264",
+            width: 1080,
+            height: 1350,
+            ...options
+        });
+    },
+    landscape(options = {}) {
+        return exportDefinition({
+            name: "landscape",
+            format: "mp4",
+            codec: "h264",
+            width: 1920,
+            height: 1080,
+            ...options
+        });
+    },
+    social(options = {}) {
+        return compactArray([
+            options.instagramReels === false ? undefined : exportPreset.instagramReels(options.instagramReels ?? {}),
+            options.tiktok === false ? undefined : exportPreset.tiktok(options.tiktok ?? {}),
+            options.youtubeShorts === false ? undefined : exportPreset.youtubeShorts(options.youtubeShorts ?? {}),
+            options.facebookReels === false ? undefined : exportPreset.facebookReels(options.facebookReels ?? {}),
+            options.reels === undefined || options.reels === false
+                ? undefined
+                : exportPreset.reels({ name: "reels-9x16", ...options.reels }),
+            options.square === false ? undefined : exportPreset.square({ name: "square-1x1", ...(options.square ?? {}) }),
+            options.portrait === false ? undefined : exportPreset.portrait(options.portrait ?? {}),
+            options.landscape === false
+                ? undefined
+                : exportPreset.landscape({ name: "landscape-16x9", ...(options.landscape ?? {}) })
+        ]);
+    },
+    custom(options) {
+        return exportDefinition({
+            format: "mp4",
+            codec: "h264",
+            ...options
+        });
+    }
+};
+export const exportPresets = exportPreset;
+export const vertical = exportPreset.vertical;
+export const reels = exportPreset.reels;
+export const instagramReels = exportPreset.instagramReels;
+export const tiktok = exportPreset.tiktok;
+export const youtubeShorts = exportPreset.youtubeShorts;
+export const facebookReels = exportPreset.facebookReels;
+export const square = exportPreset.square;
+export const portrait = exportPreset.portrait;
+export const landscape = exportPreset.landscape;
+export const social = exportPreset.social;
+export const customExport = exportPreset.custom;
+export const socialMediaPresets = [
+    socialPresetDefinition("instagram-reels", "Instagram Reels", "Instagram", "9:16", exportPreset.instagramReels()),
+    socialPresetDefinition("tiktok", "TikTok", "TikTok", "9:16", exportPreset.tiktok()),
+    socialPresetDefinition("youtube-shorts", "YouTube Shorts", "YouTube", "9:16", exportPreset.youtubeShorts()),
+    socialPresetDefinition("facebook-reels", "Facebook Reels", "Facebook", "9:16", exportPreset.facebookReels()),
+    socialPresetDefinition("instagram-feed-portrait", "Instagram Feed Portrait", "Instagram", "4:5", exportPreset.portrait()),
+    socialPresetDefinition("square-feed", "Square Feed", "Generic social", "1:1", exportPreset.square({ name: "square-1x1" })),
+    socialPresetDefinition("landscape-feed", "Landscape Feed", "Generic social", "16:9", exportPreset.landscape({ name: "landscape-16x9" }))
+];
+export const crop = {
+    center() {
+        return { mode: "center" };
+    },
+    subject(options) {
+        return compactObject({
+            mode: "subject",
+            x: options.x,
+            y: options.y,
+            keyframes: options.keyframes === undefined ? undefined : options.keyframes.map((frame) => ({ ...frame })),
+            smoothingFrames: options.smoothingFrames,
+            source: options.source
+        });
+    }
+};
+function buildLayer(id, type, options) {
+    assertId(id, "layer");
+    const { x, y, width, height, ...rest } = options;
+    const layer = compactObject({
+        id,
+        type,
+        ...rest
+    });
+    if (layer.position === undefined && (x !== undefined || y !== undefined)) {
+        layer.position = compactObject({ x, y });
+    }
+    if (layer.size === undefined && (width !== undefined || height !== undefined)) {
+        layer.size = compactObject({ width, height });
+    }
+    return new LayerBuilder(layer);
+}
+function transitionDefinition(type, options) {
+    return compactObject({
+        type,
+        durationFrames: options.durationFrames,
+        direction: options.direction,
+        axis: options.axis,
+        shape: options.shape,
+        color: options.color,
+        amount: options.amount,
+        intensity: options.intensity,
+        easing: options.easing,
+        timing: options.timing
+    });
+}
+function transitionSeriesDefinition(definition) {
+    return {
+        presentation: compactObject({
+            type: definition.type,
+            direction: definition.direction,
+            axis: definition.axis,
+            shape: definition.shape,
+            color: definition.color,
+            amount: definition.amount,
+            intensity: definition.intensity,
+            rows: definition.rows,
+            columns: definition.columns
+        }),
+        timing: compactObject({
+            type: "tween",
+            durationFrames: definition.durationFrames,
+            easing: definition.easing
+        })
+    };
+}
+function entranceOpacityKeyframes(durationFrames, easingValue) {
+    if (durationFrames <= 1) {
+        return [{ frame: 0, value: 1 }];
+    }
+    return keyframes([
+        [0, 0, easingValue],
+        [durationFrames - 1, 1]
+    ]);
+}
+function zoomMotion(options, fallbackFromScale, fallbackToScale) {
+    return {
+        scale: cameraTrack(options.durationFrames, options.fromScale ?? fallbackFromScale, options.toScale ?? fallbackToScale, options.easing)
+    };
+}
+function cameraTrack(durationFrames, fromValue, toValue, easing) {
+    const endFrame = cameraEndFrame(durationFrames);
+    if (endFrame === 0) {
+        return [{ frame: 0, value: fromValue }];
+    }
+    const firstFrame = compactObject({
+        frame: 0,
+        value: fromValue,
+        easing
+    });
+    return [firstFrame, { frame: endFrame, value: toValue }];
+}
+function cameraThreePointTrack(durationFrames, fromValue, middleValue, toValue, easing) {
+    const endFrame = cameraEndFrame(durationFrames);
+    if (endFrame === 0) {
+        return [{ frame: 0, value: fromValue }];
+    }
+    const middleFrame = Math.floor(endFrame / 2);
+    if (middleFrame === 0 || middleFrame === endFrame) {
+        return cameraTrack(durationFrames, fromValue, toValue, easing);
+    }
+    return [
+        compactObject({ frame: 0, value: fromValue, easing }),
+        compactObject({ frame: middleFrame, value: middleValue, easing }),
+        { frame: endFrame, value: toValue }
+    ];
+}
+function cameraCrashZoomTrack(options) {
+    const endFrame = cameraEndFrame(options.durationFrames);
+    if (endFrame === 0) {
+        return [{ frame: 0, value: options.fromScale }];
+    }
+    const fallbackImpactFrame = Math.max(1, Math.floor(endFrame * 0.35));
+    const impactFrame = clampInteger(options.impactFrame ?? fallbackImpactFrame, 1, endFrame);
+    if (impactFrame === endFrame) {
+        return keyframes([
+            [0, options.fromScale, options.easing],
+            [endFrame, options.toScale]
+        ]);
+    }
+    return keyframes([
+        [0, options.fromScale, options.easing],
+        [impactFrame, options.overshootScale, "outBack"],
+        [endFrame, options.toScale]
+    ]);
+}
+function cameraJitterTrack(options) {
+    const endFrame = cameraEndFrame(options.durationFrames);
+    const intervalFrames = clampInteger(options.intervalFrames, 1, Math.max(1, endFrame));
+    const frames = [];
+    let state = normalizeSeed(options.seed);
+    for (let frame = 0; frame <= endFrame; frame += intervalFrames) {
+        state = nextSeed(state);
+        const value = roundMotionValue(options.restingValue + (seedToUnit(state) * 2 - 1) * options.amount);
+        frames.push(compactObject({
+            frame,
+            value,
+            easing: frame === endFrame ? undefined : options.easing
+        }));
+    }
+    if (frames[frames.length - 1]?.frame !== endFrame) {
+        state = nextSeed(state);
+        frames.push({
+            frame: endFrame,
+            value: roundMotionValue(options.restingValue + (seedToUnit(state) * 2 - 1) * options.amount)
+        });
+    }
+    if (frames.length === 1) {
+        frames[0] = { frame: 0, value: options.restingValue };
+    }
+    return frames;
+}
+function cameraAxisFrames(options) {
+    const halfAmount = options.amount / 2;
+    const directionSign = options.direction === "left" || options.direction === "up" ? -1 : 1;
+    const subjectBias = anchorBias(options.subjectAnchor, options.axis) * halfAmount * 0.5;
+    const fromValue = options.fromValue ?? options.restingValue - directionSign * halfAmount + subjectBias;
+    const toValue = options.toValue ?? options.restingValue + directionSign * halfAmount + subjectBias;
+    return cameraTrack(options.durationFrames, fromValue, toValue, options.easing);
+}
+function cameraIntensity(options, fallback) {
+    return Math.max(0, options.intensity ?? fallback);
+}
+function cameraTravelAmount(options, fallback) {
+    const baseAmount = options.amount ?? fallback * (1 + cameraIntensity(options, 0));
+    return baseAmount * safeAreaMultiplier(options.safeArea);
+}
+function cameraEndFrame(durationFrames) {
+    if (!Number.isInteger(durationFrames) || durationFrames < 1) {
+        throw new Error("Camera motion durationFrames must be a positive integer.");
+    }
+    return durationFrames - 1;
+}
+function safeAreaMultiplier(safeArea) {
+    if (safeArea === undefined) {
+        return 1;
+    }
+    if (typeof safeArea === "number") {
+        return 1 - clamp(safeArea, 0, 0.45) * 2;
+    }
+    const largestInset = Math.max(safeArea.top ?? 0, safeArea.right ?? 0, safeArea.bottom ?? 0, safeArea.left ?? 0);
+    return 1 - clamp(largestInset, 0, 0.45) * 2;
+}
+function anchorBias(anchor, axis) {
+    if (anchor === undefined) {
+        return 0;
+    }
+    if (typeof anchor === "object") {
+        const value = axis === "x" ? anchor.x : anchor.y;
+        return clamp(value, 0, 1) * 2 - 1;
+    }
+    if (axis === "x") {
+        if (anchor.endsWith("left")) {
+            return -1;
+        }
+        if (anchor.endsWith("right")) {
+            return 1;
+        }
+        return 0;
+    }
+    if (anchor.startsWith("top")) {
+        return -1;
+    }
+    if (anchor.startsWith("bottom")) {
+        return 1;
+    }
+    return 0;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function clampInteger(value, min, max) {
+    return Math.min(max, Math.max(min, Math.round(value)));
+}
+function normalizeSeed(seed) {
+    const normalized = Math.trunc(seed) % 2147483647;
+    return normalized <= 0 ? normalized + 2147483646 : normalized;
+}
+function nextSeed(seed) {
+    return (seed * 16807) % 2147483647;
+}
+function seedToUnit(seed) {
+    return (seed - 1) / 2147483646;
+}
+function roundMotionValue(value) {
+    return Math.round(value * 1000) / 1000;
+}
+function exportDefinition(definition) {
+    return compactObject(definition);
+}
+function socialPresetDefinition(id, label, platform, aspectRatio, preset) {
+    const definition = {
+        id,
+        label,
+        platform,
+        aspectRatio,
+        width: preset.width ?? 0,
+        height: preset.height ?? 0,
+        defaultName: preset.name ?? id,
+        preset
+    };
+    if (preset.fps !== undefined) {
+        definition.fps = preset.fps;
+    }
+    return definition;
+}
+function isKeyframeTuple(frame) {
+    return Array.isArray(frame);
+}
+function interpolationFor(name) {
+    return `{{${name}}}`;
+}
+function assertId(id, kind) {
+    if (id.trim() === "") {
+        throw new Error(`Kavio ${kind} id must not be empty.`);
+    }
+}
+function assertPositiveInteger(value, name) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`${name} must be a positive integer.`);
+    }
+}
+function assertOptionalPositiveInteger(value, name) {
+    if (value !== undefined) {
+        assertPositiveInteger(value, name);
+    }
+}
+function assertNonNegativeInteger(value, name) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${name} must be a non-negative integer.`);
+    }
+}
+function assertOptionalNonNegativeInteger(value, name) {
+    if (value !== undefined) {
+        assertNonNegativeInteger(value, name);
+    }
+}
+function assertOptionalPositiveNumber(value, name) {
+    if (value !== undefined && (!Number.isFinite(value) || value <= 0)) {
+        throw new Error(`${name} must be a positive number.`);
+    }
+}
+function assertOptionalNonNegativeNumber(value, name) {
+    if (value !== undefined && (!Number.isFinite(value) || value < 0)) {
+        throw new Error(`${name} must be a non-negative number.`);
+    }
+}
+function assertOptionalRange(value, name, min, max) {
+    if (value !== undefined && (!Number.isFinite(value) || value < min || value > max)) {
+        throw new Error(`${name} must be between ${min} and ${max}.`);
+    }
+}
+function compactObject(input) {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined) {
+            output[key] = value;
+        }
+    }
+    return output;
+}
+function compactArray(input) {
+    return input.filter((item) => item !== undefined);
+}
+function layerIdFor(value) {
+    return value instanceof LayerBuilder ? value.id : value;
+}
+function cloneTrack(track) {
+    return {
+        id: track.id,
+        clips: track.clips.map((clip) => cloneTrackClip(clip))
+    };
+}
+function cloneTrackClip(clip) {
+    const output = {
+        id: clip.id,
+        layerId: clip.layerId,
+        startFrame: clip.startFrame,
+        durationFrames: clip.durationFrames
+    };
+    if (clip.transitionFromPrevious !== undefined) {
+        output.transitionFromPrevious = cloneTransitionSeriesDefinition(clip.transitionFromPrevious);
+    }
+    return output;
+}
+function cloneTransitionSeriesDefinition(definition) {
+    const output = {
+        presentation: {
+            type: definition.presentation.type
+        },
+        timing: {
+            type: "tween",
+            durationFrames: definition.timing.durationFrames
+        }
+    };
+    if (definition.presentation.direction !== undefined) {
+        output.presentation.direction = definition.presentation.direction;
+    }
+    if (definition.presentation.axis !== undefined) {
+        output.presentation.axis = definition.presentation.axis;
+    }
+    if (definition.presentation.shape !== undefined) {
+        output.presentation.shape = definition.presentation.shape;
+    }
+    if (definition.presentation.color !== undefined) {
+        output.presentation.color = definition.presentation.color;
+    }
+    if (definition.presentation.amount !== undefined) {
+        output.presentation.amount = definition.presentation.amount;
+    }
+    if (definition.presentation.intensity !== undefined) {
+        output.presentation.intensity = definition.presentation.intensity;
+    }
+    if (definition.presentation.rows !== undefined) {
+        output.presentation.rows = definition.presentation.rows;
+    }
+    if (definition.presentation.columns !== undefined) {
+        output.presentation.columns = definition.presentation.columns;
+    }
+    if (definition.timing.easing !== undefined) {
+        output.timing.easing = definition.timing.easing;
+    }
+    return output;
+}
+function isTransitionSeriesDefinition(value) {
+    return isRecord(value) && isRecord(value.presentation) && isRecord(value.timing);
+}
+function cloneAuthorObject(input) {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value instanceof PropReference || value instanceof AssetReference || value === undefined) {
+            output[key] = value;
+        }
+        else if (Array.isArray(value)) {
+            output[key] = value.map((item) => cloneAuthorValue(item));
+        }
+        else if (isRecord(value)) {
+            output[key] = cloneAuthorObject(value);
+        }
+        else {
+            output[key] = value;
+        }
+    }
+    return output;
+}
+function cloneAuthorValue(value) {
+    if (value instanceof PropReference || value instanceof AssetReference || value === undefined) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneAuthorValue(item));
+    }
+    if (isRecord(value)) {
+        return cloneAuthorObject(value);
+    }
+    return value;
+}
+function normalizeStandalone(value) {
+    if (value instanceof PropReference) {
+        return interpolationFor(value.name);
+    }
+    if (value instanceof AssetReference) {
+        return value.id;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeStandalone(item));
+    }
+    if (isRecord(value)) {
+        const output = {};
+        for (const [key, nested] of Object.entries(value)) {
+            if (nested !== undefined) {
+                output[key] = normalizeStandalone(nested);
+            }
+        }
+        return output;
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}