framefields 2.0.9 → 2.0.11

package/dist/{program-C797QMRL.mjs → program-BmNKgzja.mjs}

@@ -1,6 +1,6 @@
-import { bt as getActiveMediaMetadata, ft as createVirtualMedia } from "./dist-B9Afsv83.mjs";
-import { t as ColorSchema } from "./dist-DzUJmIHt.mjs";
-import { nt as signalRegistry } from "./dist-DgfykO99.mjs";
+import { Bt as parseCssColor, Lt as mixColors, Vt as parseCssGradient, ht as createVirtualMedia, l as Color, wt as getActiveMediaMetadata } from "./dist-CbG3QxDw.mjs";
+import { t as ColorSchema } from "./dist-BYqNNwsl.mjs";
+import { rt as signalRegistry } from "./dist-Cxi68OuY.mjs";
 import { z } from "zod";
 import { loadYoga } from "yoga-layout/load";
 
@@ -385,6 +385,36 @@ function collectInlineSignals(nodes, out = {}) {
 	}
 	return out;
 }
+const isKeyframeTrack = (t) => !t.source || t.source.type === "keyframe";
+/**
+* Merges keyframe tracks that animate the same prop into one sorted track,
+* the later key winning on a shared frame. Procedural tracks (signal,
+* wiggle, spring…) pass through untouched.
+*/
+function mergeAnimationTracks(tracks) {
+	const out = [];
+	const byProp = /* @__PURE__ */ new Map();
+	for (const t of tracks) {
+		if (!isKeyframeTrack(t)) {
+			out.push(t);
+			continue;
+		}
+		const existing = byProp.get(t.prop);
+		if (!existing) {
+			const copy = {
+				...t,
+				keyframes: [...t.keyframes ?? []]
+			};
+			byProp.set(t.prop, copy);
+			out.push(copy);
+			continue;
+		}
+		const frames = new Map(existing.keyframes.map((k) => [k.frame, k]));
+		for (const k of t.keyframes ?? []) frames.set(k.frame, k);
+		existing.keyframes = [...frames.values()].sort((a, b) => a.frame - b.frame);
+	}
+	return out;
+}
 function evaluateEasingProgress(ease, t) {
 	if (!ease) return t;
 	const ref = parseEase(ease);
@@ -586,12 +616,15 @@ var LayerAnimation = class LayerAnimation$1 {
 			this.tracks.push(track);
 		}
 		const parsedEase = parseEase(ease);
-		track.keyframes.push({
+		const kf = {
 			id: `k_${track.keyframes.length}_f${frame}`,
 			frame,
 			value,
 			...parsedEase && { ease: parsedEase }
-		});
+		};
+		const at = track.keyframes.findIndex((k) => k.frame === frame);
+		if (at >= 0) track.keyframes[at] = kf;
+		else track.keyframes.push(kf);
 		track.keyframes.sort((a, b) => a.frame - b.frame);
 		return this;
 	}
@@ -968,6 +1001,19 @@ var LayerAnimation = class LayerAnimation$1 {
 		return node;
 	}
 	/**
+	* Folds other animations into this one. Keyframe tracks on the same prop
+	* merge into one track (a later key wins on a shared frame), so separate
+	* behaviours — an entrance, presses, a wave — can be authored apart:
+	* `LayerAnimation.merge(rainIn, presses, wave)`.
+	*/
+	merge(...others) {
+		this.tracks = mergeAnimationTracks([...this.tracks, ...others.flatMap((o) => o.tracks)]);
+		return this;
+	}
+	static merge(...anims) {
+		return new LayerAnimation$1().merge(...anims);
+	}
+	/**
 	* Returns the validated LayerAnimation specification object.
 	*/
 	toSpec() {
@@ -1467,17 +1513,9 @@ function parseHexColor(hex) {
 		1
 	];
 }
+/** Color keyframes blend perceptually (OKLab) and accept any CSS color. */
 function lerpColor(c1, c2, t) {
-	if (!c1.startsWith("#") || !c2.startsWith("#")) return t < .5 ? c1 : c2;
-	const [r1, g1, b1, a1] = parseHexColor(c1);
-	const [r2, g2, b2, a2] = parseHexColor(c2);
-	const r = Math.round(lerp(r1, r2, t));
-	const g = Math.round(lerp(g1, g2, t));
-	const b = Math.round(lerp(b1, b2, t));
-	const a = lerp(a1, a2, t);
-	const toHex = (n) => n.toString(16).padStart(2, "0");
-	if (a >= .999) return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-	return `rgba(${r}, ${g}, ${b}, ${Math.round(a * 100) / 100})`;
+	return mixColors(c1, c2, t);
 }
 function hueToRgb(p, q, t) {
 	let tt = t;
@@ -1529,7 +1567,7 @@ function rotateHue(hex, delta) {
 	if (a >= .999) return `#${toHex(newR)}${toHex(newG)}${toHex(newB)}`;
 	return `rgba(${Math.round(newR * 255)}, ${Math.round(newG * 255)}, ${Math.round(newB * 255)}, ${Math.round(a * 100) / 100})`;
 }
-const COLOR_PROPS = new Set([
+const COLOR_PROPS$1 = new Set([
 	"fill",
 	"fillColor",
 	"strokeColor",
@@ -1589,7 +1627,7 @@ function evaluateTrackAtFrame(track, frame, fps = 24, context = {}) {
 		}
 		case "signal": {
 			const sigVal = evaluateSignal(source, frame, fps, context.signals);
-			if (COLOR_PROPS.has(track.prop)) {
+			if (COLOR_PROPS$1.has(track.prop)) {
 				const src = source;
 				const colorA = src.colorA ?? "#ffffff";
 				const colorB = src.colorB ?? "#ffffff";
@@ -1613,6 +1651,160 @@ function evaluateAnimationAtFrame(animation, frame, fps = 24, context = {}) {
 	return result;
 }
 /**
+* Static checks for things that render "fine" but not as intended: a color
+* the parser can't read (drawn transparent), text that disappears into its
+* background, a layer parked off-canvas, a shadow on a light that can't cast
+* one. Pure and fast; `renderVideo({ qa })` folds the findings into its report.
+*/
+const COLOR_PROPS = [
+	"background",
+	"fill",
+	"fillColor",
+	"strokeColor",
+	"borderColor",
+	"gradientEndColor",
+	"emissive",
+	"color"
+];
+/** Contrast below this makes text hard to read (WCAG large-text minimum). */
+const MIN_TEXT_CONTRAST = 3;
+function tracksOf(node) {
+	return node.animation?.tracks ?? [];
+}
+const animates = (node, props) => tracksOf(node).some((t) => props.includes(t.prop));
+const CONTAINERS = new Set([
+	"box",
+	"flex",
+	"block",
+	"group"
+]);
+/** Whether a layer puts pixels behind whatever is drawn after it (text over text aside). */
+function paints(node) {
+	if (node.kind === "text" || node.kind === "light" || node.kind === "camera") return false;
+	if (!CONTAINERS.has(String(node.kind))) return true;
+	const bg = node.background;
+	if (typeof bg === "string" && bg !== "" && bg !== "transparent") return true;
+	return (node.children ?? []).some(paints);
+}
+const byZ = (nodes) => [...nodes].sort((a, b) => (Number(a.zIndex) || 0) - (Number(b.zIndex) || 0));
+function solidColor(value) {
+	if (typeof value !== "string" || value.includes("gradient(")) return null;
+	const c = parseCssColor(value);
+	return c && c[3] > .99 ? value : null;
+}
+function lintComposition(config) {
+	const out = [];
+	const push = (severity, code, message, layerId) => out.push({
+		severity,
+		code,
+		message,
+		...layerId && { layerId }
+	});
+	const W = config.width;
+	const H = config.height;
+	let hasEnvironment = false;
+	const ambientLights = [];
+	let has3D = false;
+	const pbrNodes = [];
+	const shadowLights = [];
+	const visit = (node, backdrop, atRoot) => {
+		const id = String(node.id ?? "?");
+		for (const prop of COLOR_PROPS) {
+			const v = node[prop];
+			if (typeof v !== "string" || v === "" || v === "transparent") continue;
+			if (v.includes("gradient(")) {
+				if (!parseCssGradient(v)) push("error", "invalid_gradient", `\`${prop}\` on '${id}' is not a gradient this renderer reads: ${v}. It draws nothing.`, id);
+			} else if (!parseCssColor(v)) push("warning", "unknown_color", `\`${prop}: "${v}"\` on '${id}' is not a color (hex, rgb(), hsl(), oklch() or a CSS name). It draws transparent.`, id);
+		}
+		if (node.kind === "light") {
+			const type = node.lightType ?? "directional";
+			if (type === "environment") hasEnvironment = true;
+			if (type === "ambient") ambientLights.push(id);
+			if (node.castShadow) if (type === "directional" || type === "spot") shadowLights.push(id);
+			else push("warning", "shadow_unsupported_light", `'${id}' is a ${String(type)} light: only directional and spot lights cast shadows.`, id);
+			return;
+		}
+		if (node.kind === "camera") return;
+		const is3D = Boolean(node.is3D) || typeof node.z === "number" && node.z !== 0;
+		if (is3D || node.kind === "model3d") has3D = true;
+		if (node.roughness !== void 0 || node.metallic !== void 0) pbrNodes.push(id);
+		if (node.kind === "text" && backdrop && !animates(node, ["fill", "color"])) {
+			const fg = solidColor(node.fill ?? node.color);
+			const behind = solidColor(node.background) ?? backdrop;
+			if (fg) {
+				const ratio = Color.contrast(fg, behind);
+				if (ratio < MIN_TEXT_CONTRAST) push("warning", "low_contrast_text", `Text '${id}' (${fg}) on ${behind} has contrast ${ratio.toFixed(2)}:1 (aim for ≥ ${MIN_TEXT_CONTRAST}; ${Color.readableOn(behind)} reads well).`, id);
+			}
+		}
+		if (atRoot && !is3D && node.position === "absolute" && typeof node.x === "number" && typeof node.y === "number" && typeof node.width === "number" && typeof node.height === "number" && !animates(node, [
+			"x",
+			"y",
+			"translateX",
+			"translateY",
+			"scale",
+			"rotation"
+		])) {
+			const { x, y, width, height } = node;
+			if (x + width <= 0 || y + height <= 0 || x >= W || y >= H) push("warning", "offscreen_layer", `'${id}' sits entirely outside the ${W}×${H} canvas (x ${x}, y ${y}) and never moves in.`, id);
+		}
+		for (const t of tracksOf(node)) {
+			const kfs = t.keyframes ?? [];
+			if ((!t.source || t.source.type === "keyframe") && kfs.length >= 2 && kfs.every((k) => JSON.stringify(k.value) === JSON.stringify(kfs[0].value))) push("info", "static_track", `'${id}' animates \`${t.prop}\` but every keyframe holds ${JSON.stringify(kfs[0].value)}.`, id);
+		}
+		const ownBackdrop = solidColor(node.background) ?? backdrop;
+		const children = node.children;
+		const fullFrame = node.x === 0 && node.y === 0 && node.width === W && node.height === H;
+		visitLevel(children ?? [], ownBackdrop, atRoot && fullFrame);
+	};
+	const visitLevel = (nodes, backdrop, atRoot) => {
+		let known = backdrop;
+		for (const n of byZ(nodes)) {
+			visit(n, known, atRoot);
+			if (paints(n)) known = null;
+		}
+	};
+	const rootBackdrop = solidColor(config.backgroundColor) ?? null;
+	visitLevel(config.layout, rootBackdrop, true);
+	if (hasEnvironment && ambientLights.length > 0) push("info", "ambient_with_environment", `The environment already fills shadows with light; ambient light ${ambientLights.join(", ")} adds flat light on top (remove it, or lower it, if the scene looks washed out).`);
+	if (shadowLights.length > 1) push("info", "multiple_shadow_lights", `${shadowLights.length} lights cast shadows (${shadowLights.join(", ")}); only the first one does.`);
+	if (has3D && pbrNodes.length > 0 && !hasEnvironment) push("info", "pbr_without_environment", `roughness / metallic are set (${pbrNodes.slice(0, 3).join(", ")}${pbrNodes.length > 3 ? ", …" : ""}) but the scene has no Layer.environment(): add one for physically based shading, reflections and tone mapping.`);
+	return out;
+}
+const GEOMETRY = [
+	"x",
+	"y",
+	"width",
+	"height"
+];
+function hoistOne(owner) {
+	const matte = owner.matte;
+	const { matte: _drop, ...rest } = owner;
+	const self = { ...rest };
+	if (Array.isArray(self.children)) self.children = hoistMattes(self.children);
+	if (!matte?.node) return [self];
+	const src = matte.node;
+	const id = src.id ?? `${String(owner.id)}__matte`;
+	const node = {
+		position: "absolute",
+		...src,
+		id,
+		matteOf: String(owner.id),
+		matteMode: matte.mode ?? "alpha"
+	};
+	if (GEOMETRY.every((k) => src[k] === void 0)) {
+		for (const k of GEOMETRY) if (typeof owner[k] === "number") node[k] = owner[k];
+	}
+	node.startFrame = (typeof owner.startFrame === "number" ? owner.startFrame : 0) + (typeof src.startFrame === "number" ? src.startFrame : 0);
+	if (src.durationFrames === void 0 && owner.durationFrames !== void 0) node.durationFrames = owner.durationFrames;
+	if (Array.isArray(node.children)) node.children = hoistMattes(node.children);
+	self.matteId = id;
+	return [self, node];
+}
+/** Returns the tree with every `matte` turned into a sibling matte layer. */
+function hoistMattes(nodes) {
+	return nodes.flatMap((n) => hoistOne(n));
+}
+/**
 * Fluent Builder for Extended Text Animators.
 */
 var AdvancedTextAnimatorBuilder = class AdvancedTextAnimatorBuilder$1 {
@@ -3984,7 +4176,16 @@ const AnimatablePropSchema = z.enum([
 	"animationSpeed",
 	"wireframe",
 	"scaleX",
-	"scaleY"
+	"scaleY",
+	"emissive",
+	"emissiveIntensity",
+	"exposure"
+]);
+const MatteModeSchema = z.enum([
+	"alpha",
+	"alpha-inverted",
+	"luma",
+	"luma-inverted"
 ]);
 const MaterialTypeSchema = z.enum([
 	"lit",
@@ -4283,6 +4484,16 @@ const BaseNodeFields = {
 	dispersion: z.number().min(0).max(1).optional(),
 	fresnelPower: z.number().min(1).max(10).optional(),
 	envIntensity: z.number().min(0).max(10).optional(),
+	emissive: ColorSchema.optional(),
+	emissiveIntensity: z.number().min(0).optional(),
+	castShadow: z.boolean().optional(),
+	matte: z.object({
+		node: z.custom((v) => typeof v === "object" && v !== null),
+		mode: MatteModeSchema.optional()
+	}).optional(),
+	matteId: z.string().optional(),
+	matteOf: z.string().optional(),
+	matteMode: MatteModeSchema.optional(),
 	animation: LayerAnimationSchema.default({ tracks: [] }),
 	vision: z.unknown().optional(),
 	relighting: z.unknown().optional()
@@ -4445,8 +4656,34 @@ const LightTypeSchema = z.enum([
 	"ambient",
 	"directional",
 	"point",
-	"spot"
+	"spot",
+	"environment"
 ]);
+const EnvironmentPresetSchema = z.enum([
+	"studio",
+	"soft",
+	"sunset",
+	"night",
+	"neutral"
+]);
+const ToneMappingSchema = z.enum([
+	"neutral",
+	"agx",
+	"aces",
+	"none"
+]);
+const EnvironmentFogSchema = z.object({
+	color: ColorSchema,
+	start: z.number().min(0),
+	end: z.number().min(0),
+	opacity: z.number().min(0).max(1).optional()
+}).strict();
+const BloomConfigSchema = z.object({
+	intensity: z.number().min(0).max(10).optional(),
+	threshold: z.number().min(0).max(16).optional(),
+	knee: z.number().min(0).max(1).optional(),
+	radius: z.number().min(1).max(8).optional()
+}).strict();
 const LightNodeSchema = z.object({
 	id: z.string().min(1),
 	kind: z.literal("light"),
@@ -4468,6 +4705,20 @@ const LightNodeSchema = z.object({
 	decay: z.number().min(0).default(2),
 	angle: z.number().min(0).max(180).default(45),
 	penumbra: z.number().min(0).max(1).default(.2),
+	castShadow: z.boolean().optional(),
+	shadowSoftness: z.number().min(0).max(64).optional(),
+	shadowDarkness: z.number().min(0).max(1).optional(),
+	shadowMapSize: z.number().int().min(256).max(8192).optional(),
+	preset: EnvironmentPresetSchema.optional(),
+	top: ColorSchema.optional(),
+	horizon: ColorSchema.optional(),
+	bottom: ColorSchema.optional(),
+	softboxes: z.number().min(0).optional(),
+	rotation: z.number().optional(),
+	exposure: z.number().min(-16).max(16).optional(),
+	toneMapping: ToneMappingSchema.optional(),
+	fog: EnvironmentFogSchema.optional(),
+	bloom: z.union([z.boolean(), BloomConfigSchema]).optional(),
 	startFrame: z.number().int().min(0).default(0),
 	durationFrames: z.number().int().min(1).optional(),
 	animation: LayerAnimationSchema.default({ tracks: [] })
@@ -4761,7 +5012,10 @@ const Model3DNodeSchema = z.object({
 	scaleX: z.number().default(1),
 	scaleY: z.number().default(1),
 	audioDeform: z.record(z.string(), z.unknown()).optional(),
-	text3dOptions: z.unknown().optional()
+	color: ColorSchema.optional(),
+	colorTint: ColorSchema.optional(),
+	text3dOptions: z.unknown().optional(),
+	primitive3d: z.unknown().optional()
 }).strict();
 const LayoutNodeSchema = z.lazy(() => z.union([
 	FlexNodeSchema,
@@ -4798,6 +5052,10 @@ const CompositorProgramSchema = z.object({
 */
 /**
 * Camera Transition Type across scene boundaries.
+*
+* @deprecated Recorded on scenes but not rendered. Use framefields'
+* `Layer.sequence([...])` with `Transition.push` / `wipe` / `iris` /
+* `crossfade` / `zoom` / `whip`, which render as keyframes and mattes.
 */
 const SceneTransitionTypeSchema = z.enum([
 	"cut",
@@ -5143,7 +5401,7 @@ function compositorToProgram(config, options) {
 			},
 			...(config.onRequestFrame || options.onRequestFrame) && { onRequestFrame: config.onRequestFrame ?? options.onRequestFrame }
 		},
-		children: config.layout.map((n) => nodeToVirtualMedia(n, resolveMedia, fps, 0, durationMs))
+		children: hoistMattes(config.layout).map((n) => nodeToVirtualMedia(n, resolveMedia, fps, 0, durationMs))
 	};
 	const effectsList = Array.isArray(options.effects) ? options.effects : Array.isArray(config.effects) ? config.effects : [];
 	for (const eff of effectsList) {
@@ -5184,5 +5442,5 @@ function collectNodeOps(nodes) {
 }
 
 //#endregion
-export { TextPathBuilder as $, MaterialTypeSchema as A, evaluateAnimationAtFrame as At, SelectorUnitsSchema as B, evaluateVolumetricFormation as Bt, KineticMarqueeConfigSchema as C, computeLayoutSync as Ct, LightTypeSchema as D, deterministicWigglyNoise as Dt, LightNodeSchema as E, computeStaggerDelay as Et, SceneDefinitionSchema as F, evaluateSelectorCombination as Ft, SpringPhysicsSchema as G, initLayout as Gt, ShapeNodeSchema as H, generatePathSegments as Ht, SceneTransitionTypeSchema as I, evaluateSkewMatrix as It, TextAnimatorBuilder as J, sampleCurveGeometry as Jt, TextAnchorConfigSchema as K, parseSvgPathToCubicBeziers as Kt, SelectorBasedOnSchema as L, evaluateSpringProgress as Lt, Model3DNodeSchema as M, evaluateCubicBezierDerivative as Mt, ParticleDissolveConfigSchema as N, evaluateExpressionSelector as Nt, LineSpacingDynamicsSchema as O, distanceToCurveParameter as Ot, Scene as P, evaluateMarqueeOffset as Pt, TextNodeSchema as Q, SelectorModeSchema as R, evaluateTrackAtFrame as Rt, GlyphAnchorPointSchema as S, computeLayout as St, LayoutNodeSchema as T, computeRangeSelectorWeight as Tt, SkewPropertiesSchema as U, getScramblePool as Ut, Sequence as V, generateArcLengthLUT as Vt, Spatial3DPropertiesSchema as W, getShuffledOrder as Wt, TextCursorConfigSchema as X, waveToCubicBeziers as Xt, TextAnimatorSchema as Y, samplePathChainGeometry as Yt, TextCursorStyleSchema as Z, EnhancedTextNodeSchema as _, calculateSequenceTimeline as _t, AnchorPresetSchema as a, TextSignalSelectorSchema as at, FlexNodeSchema as b, computeAnchorPivotOffset as bt, BoxNodeSchema as c, TextWigglySelectorSchema as ct, CarrierHandoffConfigSchema as d, VariableFontAxesSchema as dt, TextPathOptionsSchema as et, ChromaticGlitchConfigSchema as f, Vec2Schema as ft, DynamicStrokePropertiesSchema as g, buildPathLUT as gt, CubicBezierSegmentSchema as h, applyStaggerToChildren as ht, AnchorGroupingSchema as i, TextSelectorSchema as it, MediaNodeSchema as j, evaluateCubicBezier as jt, LongShadowConfigSchema as k, ellipseToCubicBeziers as kt, CameraAnimation as l, TypewriterAnimatorSchema as lt, CompositorProgramSchema as m, VolumetricFormationModeSchema as mt, AdvancedTextAnimatorBuilder as n, TextRangeSelectorSchema as nt, AnimatableGlyphPropsSchema as o, TextSpanMarkSchema as ot, ColorStopSchema as p, VolumetricFormationConfigSchema as pt, TextAnimator as q, sampleAudioSpectrumScale as qt, AdvancedTextAnimatorSchema as r, TextScrambleConfigSchema as rt, AudioSpectrumTypographySchema as s, TextSpanSchema as st, AETextAnimatorSchema as t, TextPathSourceSchema as tt, CameraNodeSchema as u, TypingCadenceSchema as ut, ExpressionSelectorSchema as v, collectNodeOps as vt, LayerAnimation as w, computeLineLeadingDisplacement as wt, GlyphAnchorGroupingSchema as x, computeCarrierContinuity as xt, ExtendedGlyphPropertiesSchema as y, compositorToProgram as yt, SelectorShapeSchema as z, evaluateTypewriterState as zt };
-//# sourceMappingURL=program-C797QMRL.mjs.map
+export { TextAnimatorSchema as $, mergeAnimationTracks as $t, LightTypeSchema as A, computeRangeSelectorWeight as At, SceneTransitionTypeSchema as B, evaluateSelectorCombination as Bt, FlexNodeSchema as C, collectNodeOps as Ct, LayerAnimation as D, computeLayout as Dt, KineticMarqueeConfigSchema as E, computeCarrierContinuity as Et, MediaNodeSchema as F, evaluateAnimationAtFrame as Ft, Sequence as G, evaluateVolumetricFormation as Gt, SelectorModeSchema as H, evaluateSpringProgress as Ht, Model3DNodeSchema as I, evaluateCubicBezier as It, Spatial3DPropertiesSchema as J, getScramblePool as Jt, ShapeNodeSchema as K, generateArcLengthLUT as Kt, ParticleDissolveConfigSchema as L, evaluateCubicBezierDerivative as Lt, LongShadowConfigSchema as M, deterministicWigglyNoise as Mt, MaterialTypeSchema as N, distanceToCurveParameter as Nt, LayoutNodeSchema as O, computeLayoutSync as Ot, MatteModeSchema as P, ellipseToCubicBeziers as Pt, TextAnimatorBuilder as Q, lintComposition as Qt, Scene as R, evaluateExpressionSelector as Rt, ExtendedGlyphPropertiesSchema as S, calculateSequenceTimeline as St, GlyphAnchorPointSchema as T, computeAnchorPivotOffset as Tt, SelectorShapeSchema as U, evaluateTrackAtFrame as Ut, SelectorBasedOnSchema as V, evaluateSkewMatrix as Vt, SelectorUnitsSchema as W, evaluateTypewriterState as Wt, TextAnchorConfigSchema as X, hoistMattes as Xt, SpringPhysicsSchema as Y, getShuffledOrder as Yt, TextAnimator as Z, initLayout as Zt, DynamicStrokePropertiesSchema as _, Vec2Schema as _t, AnchorPresetSchema as a, TextPathSourceSchema as at, EnvironmentPresetSchema as b, applyStaggerToChildren as bt, BloomConfigSchema as c, TextSelectorSchema as ct, CameraNodeSchema as d, TextSpanSchema as dt, parseSvgPathToCubicBeziers as en, TextCursorConfigSchema as et, CarrierHandoffConfigSchema as f, TextWigglySelectorSchema as ft, CubicBezierSegmentSchema as g, VariableFontAxesSchema as gt, CompositorProgramSchema as h, TypingCadenceSchema as ht, AnchorGroupingSchema as i, waveToCubicBeziers as in, TextPathOptionsSchema as it, LineSpacingDynamicsSchema as j, computeStaggerDelay as jt, LightNodeSchema as k, computeLineLeadingDisplacement as kt, BoxNodeSchema as l, TextSignalSelectorSchema as lt, ColorStopSchema as m, TypewriterAnimatorSchema as mt, AdvancedTextAnimatorBuilder as n, sampleCurveGeometry as nn, TextNodeSchema as nt, AnimatableGlyphPropsSchema as o, TextRangeSelectorSchema as ot, ChromaticGlitchConfigSchema as p, ToneMappingSchema as pt, SkewPropertiesSchema as q, generatePathSegments as qt, AdvancedTextAnimatorSchema as r, samplePathChainGeometry as rn, TextPathBuilder as rt, AudioSpectrumTypographySchema as s, TextScrambleConfigSchema as st, AETextAnimatorSchema as t, sampleAudioSpectrumScale as tn, TextCursorStyleSchema as tt, CameraAnimation as u, TextSpanMarkSchema as ut, EnhancedTextNodeSchema as v, VolumetricFormationConfigSchema as vt, GlyphAnchorGroupingSchema as w, compositorToProgram as wt, ExpressionSelectorSchema as x, buildPathLUT as xt, EnvironmentFogSchema as y, VolumetricFormationModeSchema as yt, SceneDefinitionSchema as z, evaluateMarqueeOffset as zt };
+//# sourceMappingURL=program-BmNKgzja.mjs.map