framefields 2.4.0 → 2.4.2

package/dist/{dist-Cl0mvShy.mjs → dist-CxGfrigI.mjs}

@@ -1,6 +1,6 @@
-import { Ot as getMediaType, Pt as isSignal, on as updateClockSignals, p as DEFAULT_DURATION_MS, qt as resolveMediaMimeType, wt as getActiveMediaMetadata } from "./dist-fjKpBYkc.mjs";
+import { Jt as resolveMediaMimeType, Ot as getMediaType, Pt as isSignal, p as DEFAULT_DURATION_MS, sn as updateClockSignals, wt as getActiveMediaMetadata } from "./dist-ClyC_d66.mjs";
 import { t as audioRegistry, u as webgpuRegistry } from "./renderer-BSitV56h.mjs";
-import { C as drawGifNode, D as drawSignalNode, E as drawParagraphNode, L as inputStore, N as getHeadlessFontPath, Nn as signalRegistry, O as drawSvgNode, Q as registerHeadlessFont, S as drawCaptionNode, T as drawLottieNode, at as resolveMediaSourceUrl, et as shaderStore, it as GetFontAssetUrl, k as drawVideoNode, m as SlugGeometry, p as SlugFontCache, w as drawImageNode } from "./dist-DRB6Vg5u.mjs";
+import { C as drawGifNode, D as drawSignalNode, E as drawParagraphNode, L as inputStore, N as getHeadlessFontPath, Nn as signalRegistry, O as drawSvgNode, Q as registerHeadlessFont, S as drawCaptionNode, T as drawLottieNode, at as resolveMediaSourceUrl, et as shaderStore, it as GetFontAssetUrl, k as drawVideoNode, m as SlugGeometry, p as SlugFontCache, w as drawImageNode } from "./dist-CspOG4V1.mjs";
 import { AudioSampleSink } from "mediabunny";
 
 //#region ../renderers/dist/index.mjs
@@ -1038,6 +1038,23 @@ const waitForDelayRender = async (timeoutMs = 3e4) => {
 * Decodes all audio samples from a given source URL into raw Float32 mono/stereo channel buffers.
 */
 async function decodeAudioSource(url) {
+	const decoded = await decodeAudioRange(url);
+	return decoded ? {
+		channels: decoded.channels,
+		sampleRate: decoded.sampleRate
+	} : null;
+}
+/**
+* Seconds decoded ahead of a requested range: a compressed stream (MP3, AAC)
+* decoded from mid-file only matches a whole-file decode once the decoder has
+* warmed up on the packets before it.
+*/
+const DECODE_PREROLL_SEC = .5;
+/**
+* Decodes [range.startSec, range.endSec) of a source (the whole file without
+* a range), so a short clip from a long file decodes only what it plays.
+*/
+async function decodeAudioRange(url, range) {
 	mediaLogger.debug(`[AudioExtractor] decodeAudioSource started for url: ${url}`);
 	try {
 		if (typeof window !== "undefined" && typeof window.document !== "undefined" && !(typeof process !== "undefined" && process.versions && process.versions.node)) {
@@ -1057,7 +1074,10 @@ async function decodeAudioSource(url) {
 				for (let c = 0; c < audioBuffer.numberOfChannels; c++) channels.push(new Float32Array(audioBuffer.getChannelData(c)));
 				return {
 					channels,
-					sampleRate: audioBuffer.sampleRate
+					sampleRate: audioBuffer.sampleRate,
+					startIndex: 0,
+					validFromSec: 0,
+					validToSec: Number.POSITIVE_INFINITY
 				};
 			} finally {
 				audioCtx.close();
@@ -1075,13 +1095,17 @@ async function decodeAudioSource(url) {
 				mediaLogger.warn(`[AudioExtractor] No primary audio track found in input for ${url}`);
 				return null;
 			}
-			const generator = new AudioSampleSink(track).samples(0);
+			const sink = new AudioSampleSink(track);
+			const decodeFromSec = range ? Math.max(0, range.startSec - DECODE_PREROLL_SEC) : 0;
+			const generator = sink.samples(decodeFromSec, range?.endSec);
 			const decodedPlanes = [];
 			let totalFrames = 0;
 			let sampleRate = 48e3;
 			let numChannels = 1;
+			let firstTimestamp = null;
 			mediaLogger.debug(`[AudioExtractor] Starting mediabunny generator loop for ${url}...`);
 			for await (const sample of generator) {
+				if (firstTimestamp === null) firstTimestamp = sample.timestamp;
 				sampleRate = sample.sampleRate;
 				numChannels = sample.numberOfChannels;
 				const sampleFrames = sample.numberOfFrames;
@@ -1127,23 +1151,51 @@ async function decodeAudioSource(url) {
 			}
 			mediaLogger.debug(`[AudioExtractor] Generator loop finished. Decoded total frames: ${totalFrames}`);
 			if (totalFrames === 0 || decodedPlanes.length === 0) return null;
+			const channels = decodedPlanes.map((planes) => {
+				const merged = new Float32Array(totalFrames);
+				let offset = 0;
+				for (const plane of planes) {
+					merged.set(plane, offset);
+					offset += plane.length;
+				}
+				return merged;
+			});
+			let startIndex = 0;
+			if (decodeFromSec > 0 && firstTimestamp !== null) {
+				const origin = await sink.getSample(0);
+				const originTimestamp = origin?.timestamp ?? await track.getFirstTimestamp();
+				origin?.close();
+				startIndex = Math.round((firstTimestamp - originTimestamp) * sampleRate);
+			}
+			const endedEarly = !range || (startIndex + totalFrames) / sampleRate < range.endSec;
 			return {
-				channels: decodedPlanes.map((planes) => {
-					const merged = new Float32Array(totalFrames);
-					let offset = 0;
-					for (const plane of planes) {
-						merged.set(plane, offset);
-						offset += plane.length;
-					}
-					return merged;
-				}),
-				sampleRate
+				channels,
+				sampleRate,
+				startIndex,
+				validFromSec: decodeFromSec > 0 && range ? range.startSec : 0,
+				validToSec: endedEarly || !range ? Number.POSITIVE_INFINITY : range.endSec
 			};
 		} catch (err) {
 			if (err instanceof Error && err.message.includes("Cannot open local media file")) throw err;
 			if (typeof process !== "undefined" && process.versions?.node) try {
-				const { execSync } = await import("node:child_process");
-				const stdout = execSync(`ffmpeg -v error -i "${url}" -f f32le -ar 48000 -ac 2 pipe:1`, { maxBuffer: 100 * 1024 * 1024 });
+				const { execFileSync } = await import("node:child_process");
+				const ffStartIndex = range ? Math.round(Math.max(0, range.startSec) * 48e3) : 0;
+				const ffStartSec = ffStartIndex / 48e3;
+				const stdout = execFileSync("ffmpeg", [
+					"-v",
+					"error",
+					...ffStartSec > 0 ? ["-ss", String(ffStartSec)] : [],
+					"-i",
+					url,
+					...range ? ["-t", String(range.endSec - ffStartSec)] : [],
+					"-f",
+					"f32le",
+					"-ar",
+					"48000",
+					"-ac",
+					"2",
+					"pipe:1"
+				], { maxBuffer: Number.POSITIVE_INFINITY });
 				const totalSamples = stdout.byteLength / 4;
 				const numFrames = totalSamples / 2;
 				const interleaved = new Float32Array(stdout.buffer, stdout.byteOffset, totalSamples);
@@ -1153,9 +1205,13 @@ async function decodeAudioSource(url) {
 					left[i] = interleaved[i * 2];
 					right[i] = interleaved[i * 2 + 1];
 				}
+				const ffEndedEarly = !range || ffStartSec + numFrames / 48e3 < range.endSec;
 				return {
 					channels: [left, right],
-					sampleRate: 48e3
+					sampleRate: 48e3,
+					startIndex: ffStartIndex,
+					validFromSec: ffStartSec,
+					validToSec: ffEndedEarly || !range ? Number.POSITIVE_INFINITY : range.endSec
 				};
 			} catch (ffmpegErr) {
 				mediaLogger.warn({ ffmpegErr }, `[AudioExtractor] ffmpeg fallback decode failed for ${url}`);
@@ -1173,14 +1229,16 @@ async function decodeAudioSource(url) {
 }
 /**
 * Resamples a PCM buffer using linear interpolation to target sample rate & speed.
+* `trimOffsetSamples` is a whole-file index; `inputStartIndex` is the
+* whole-file index of `inputChannel[0]` when it holds only a range.
 */
-async function resampleAndStretchPCM(inputChannel, sourceSampleRate, targetSampleRate, speed, outputLength, trimOffsetSamples) {
+async function resampleAndStretchPCM(inputChannel, sourceSampleRate, targetSampleRate, speed, outputLength, trimOffsetSamples, inputStartIndex = 0) {
 	const output = new Float32Array(outputLength);
 	const factor = sourceSampleRate / targetSampleRate * speed;
 	const YIELD_INTERVAL = 1e5;
 	for (let i = 0; i < outputLength; i++) {
 		if (i > 0 && i % YIELD_INTERVAL === 0) await yieldToMain();
-		const srcIndex = trimOffsetSamples + i * factor;
+		const srcIndex = trimOffsetSamples + i * factor - inputStartIndex;
 		const indexFloor = Math.floor(srcIndex);
 		const indexCeil = Math.ceil(srcIndex);
 		if (indexFloor < 0) {
@@ -1195,11 +1253,64 @@ async function resampleAndStretchPCM(inputChannel, sourceSampleRate, targetSampl
 	}
 	return output;
 }
+/** Seconds decoded past a clip's last source sample, for interpolation. */
+const RANGE_MARGIN_SEC = .05;
+/** Processors that only scale what is already there, so silence stays silence. */
+const GAIN_ONLY_PROCESSORS = new Set(["Compositor", "CompositorLayer"]);
+/** Adds `src` into `dest` starting at `destStart` (which may be negative). */
+function addInto(dest, src, destStart) {
+	const from = Math.max(0, -destStart);
+	const to = Math.min(src.length, dest.length - destStart);
+	for (let i = from; i < to; i++) dest[destStart + i] += src[i];
+}
+/**
+* A node's stereo mix, allocated on first write. A child that covers the
+* whole bus while it is still silent is taken over instead of copied (adding
+* into silence changes nothing), so a chain of single-child nodes passes one
+* buffer up instead of allocating and summing a full-length copy per level.
+*/
+var MixBus = class {
+	channels = null;
+	constructor(length) {
+		this.length = length;
+	}
+	/** The bus channels, allocated (silent) if nothing was written yet. */
+	get() {
+		this.channels ??= [new Float32Array(this.length), new Float32Array(this.length)];
+		return this.channels;
+	}
+	/** Whether `src` written at `start` could replace the bus outright. */
+	canAdopt(src, start) {
+		return this.channels === null && start === 0 && src.every((ch) => ch.length === this.length);
+	}
+	/** Mixes `src` into the bus starting at sample `start`. */
+	add(src, start) {
+		if (this.canAdopt(src, start) && src[0] !== src[1]) {
+			this.channels = src;
+			return;
+		}
+		const dest = this.get();
+		for (let c = 0; c < 2; c++) addInto(dest[c], src[c], start);
+	}
+};
+/** A clip's file name for progress, without paths or signed-URL queries. */
+function sourceLabel(url) {
+	if (url.startsWith("data:")) return "inline audio";
+	const name = url.split(/[?#]/)[0].split(/[\\/]/).pop();
+	return name ? decodeURIComponentSafe(name) : "audio";
+}
+function decodeURIComponentSafe(s) {
+	try {
+		return decodeURIComponent(s);
+	} catch {
+		return s;
+	}
+}
 /**
 * Recursively parses the VirtualMediaData tree and mixes all active audio tracks
 * into a single unified stereo PCM stream (Float32Array channels).
 */
-async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device, renderId) {
+async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device, renderId, options = {}) {
 	mediaLogger.debug(`[AudioExtractor] mixAudioTracks started. FPS: ${fps}, targetSampleRate: ${targetSampleRate}`);
 	await waitForDelayRender();
 	shaderStore.registerSignalsFromComposition(renderId, virtualMedia);
@@ -1207,12 +1318,44 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 	const totalDurationSec = durationMs / 1e3;
 	const totalTargetSamples = Math.ceil(totalDurationSec * targetSampleRate);
 	mediaLogger.debug(`[AudioExtractor] Composition total duration: ${durationMs}ms (${totalDurationSec}s). Total mixed samples to allocate: ${totalTargetSamples}`);
-	const outputLeft = new Float32Array(totalTargetSamples);
-	const outputRight = new Float32Array(totalTargetSamples);
-	const mixedChannels = [outputLeft, outputRight];
 	const decodedCache = /* @__PURE__ */ new Map();
+	const undecodable = /* @__PURE__ */ new Set();
+	async function getDecodedRange(url, startSec, endSec) {
+		if (undecodable.has(url)) return null;
+		let ranges = decodedCache.get(url);
+		const hit = ranges?.find((r) => r.validFromSec <= startSec && r.validToSec >= endSec);
+		if (hit) return hit;
+		const decoded = await decodeAudioRange(url, {
+			startSec,
+			endSec
+		});
+		if (!decoded) {
+			undecodable.add(url);
+			return null;
+		}
+		if (!ranges) {
+			ranges = [];
+			decodedCache.set(url, ranges);
+		}
+		ranges.push(decoded);
+		return decoded;
+	}
+	const audibleCache = /* @__PURE__ */ new WeakMap();
+	function isAudible(node) {
+		const cached = audibleCache.get(node);
+		if (cached !== void 0) return cached;
+		const op = node.operation;
+		let audible = false;
+		if (op?.op === "source") {
+			const mediaType = getMediaType(node);
+			audible = mediaType === "Audio" || mediaType === "Video";
+		} else if (op?.op && !GAIN_ONLY_PROCESSORS.has(op.op) && audioRegistry.get(op.op)) audible = true;
+		if (!audible && node.children) audible = node.children.some((child) => child && isAudible(child));
+		audibleCache.set(node, audible);
+		return audible;
+	}
 	async function traverse(node, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, inheritedDurationFrames) {
-		if (!node) return null;
+		if (!node || !isAudible(node)) return null;
 		const op = node.operation;
 		if (!op) {
 			const durationMs$1 = getActiveMediaMetadata(node)?.durationMs ?? 0;
@@ -1220,22 +1363,17 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 			const actualDurationFrames = inheritedDurationFrames !== null ? durationFrames > 0 ? Math.min(inheritedDurationFrames, durationFrames) : inheritedDurationFrames : durationFrames;
 			const localSamplesCount$1 = Math.ceil(actualDurationFrames / fps * targetSampleRate);
 			if (localSamplesCount$1 <= 0) return null;
-			const localChannels$1 = [new Float32Array(localSamplesCount$1), new Float32Array(localSamplesCount$1)];
+			const bus$1 = new MixBus(localSamplesCount$1);
 			for (const child of node.children) {
 				const childChannels = await traverse(child, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, actualDurationFrames);
 				if (childChannels) {
 					const childOp = child.operation;
 					const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
 					const childStartSample = Math.round(childStartFrame / fps * targetSampleRate);
-					for (let c = 0; c < 2; c++) {
-						const dest = localChannels$1[c];
-						const src = childChannels[c];
-						const len = Math.min(src.length, dest.length - childStartSample);
-						for (let i = 0; i < len; i++) if (childStartSample + i >= 0) dest[childStartSample + i] += src[i];
-					}
+					bus$1.add(childChannels, childStartSample);
 				}
 			}
-			return localChannels$1;
+			return bus$1.channels;
 		}
 		const volume = inheritedVolume * (op.volume ?? 1) * (op.opacity === 0 ? 0 : 1) * (op.muted ? 0 : 1);
 		const speedMultiplier = inheritedSpeed;
@@ -1248,9 +1386,7 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 		const nodeActualDurationFrames = inheritedDurationFrames !== null ? nodeDurationFrames > 0 ? Math.min(inheritedDurationFrames, nodeDurationFrames) : inheritedDurationFrames : nodeDurationFrames;
 		const localSamplesCount = Math.ceil(nodeActualDurationFrames / fps * targetSampleRate);
 		if (localSamplesCount <= 0) return null;
-		const localLeft = new Float32Array(localSamplesCount);
-		const localRight = new Float32Array(localSamplesCount);
-		const localChannels = [localLeft, localRight];
+		const bus = new MixBus(localSamplesCount);
 		const processSegment = async (seg, windowStartFrameOffset) => {
 			const segSeekSec = seg ? seg.startSec : 0;
 			const totalSeekSec = inheritedSeekSec + layerTrimSec + segSeekSec;
@@ -1266,20 +1402,22 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 				if (params.sourceUrl && (mediaType === "Audio" || mediaType === "Video") && volume > 0) {
 					const finalSpeed = Math.max(.5, speedMultiplier * (Number(params.speed) || 1));
 					const effectiveTrimSec = Math.max(0, (Number(params.trimStartSec) || 0) + totalSeekSec);
-					let decoded = decodedCache.get(params.sourceUrl);
-					if (decoded === void 0) {
-						decoded = await decodeAudioSource(params.sourceUrl);
-						decodedCache.set(params.sourceUrl, decoded);
-					}
+					const clipDurationSec = actualDurationFrames / fps;
+					const clipSamplesCount = Math.min(localSamplesCount - segmentStartSample, Math.ceil(clipDurationSec * targetSampleRate));
+					const decoded = clipSamplesCount > 0 && segmentStartSample < localSamplesCount ? await getDecodedRange(params.sourceUrl, effectiveTrimSec, effectiveTrimSec + clipSamplesCount / targetSampleRate * finalSpeed + RANGE_MARGIN_SEC) : null;
 					if (decoded) {
-						const clipDurationSec = actualDurationFrames / fps;
-						const clipSamplesCount = Math.min(localSamplesCount - segmentStartSample, Math.ceil(clipDurationSec * targetSampleRate));
-						if (clipSamplesCount > 0 && segmentStartSample < localSamplesCount) {
-							const trimOffsetSamples = Math.round(effectiveTrimSec * decoded.sampleRate);
-							const srcLeft = decoded.channels[0];
-							const srcRight = decoded.channels.length > 1 ? decoded.channels[1] : decoded.channels[0];
-							const stretchedLeft = await resampleAndStretchPCM(srcLeft, decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples);
-							const stretchedRight = await resampleAndStretchPCM(srcRight, decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples);
+						const trimOffsetSamples = Math.round(effectiveTrimSec * decoded.sampleRate);
+						const stretchedLeft = await resampleAndStretchPCM(decoded.channels[0], decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples, decoded.startIndex);
+						const stretchedRight = decoded.channels.length > 1 ? await resampleAndStretchPCM(decoded.channels[1], decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples, decoded.startIndex) : stretchedLeft;
+						const stretched = [stretchedLeft, stretchedRight];
+						if (bus.canAdopt(stretched, segmentStartSample)) {
+							if (volume !== 1) {
+								for (let i = 0; i < clipSamplesCount; i++) stretchedLeft[i] *= volume;
+								if (stretchedRight !== stretchedLeft) for (let i = 0; i < clipSamplesCount; i++) stretchedRight[i] *= volume;
+							}
+							bus.channels = [stretchedLeft, stretchedRight === stretchedLeft ? stretchedLeft.slice() : stretchedRight];
+						} else {
+							const [localLeft, localRight] = bus.get();
 							for (let i = 0; i < clipSamplesCount; i++) {
 								const outIndex = segmentStartSample + i;
 								localLeft[outIndex] += stretchedLeft[i] * volume;
@@ -1289,26 +1427,29 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 					}
 					await yieldToMain();
 				}
+				if (mediaType === "Audio" || mediaType === "Video") {
+					clipsDone++;
+					options.onProgress?.({
+						done: clipsDone,
+						total: clipsTotal,
+						...params.sourceUrl && { source: sourceLabel(params.sourceUrl) }
+					});
+				}
 			}
 			if (node.children) for (const child of node.children) {
 				const childChannels = await traverse(child, totalSeekSec, totalClockFrames, volume, speedMultiplier, actualDurationFrames);
 				if (childChannels) {
 					const childOp = child.operation;
 					const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
-					const destStartSample = segmentStartSample + Math.round(childStartFrame / fps * targetSampleRate);
-					for (let c = 0; c < 2; c++) {
-						const dest = localChannels[c];
-						const src = childChannels[c];
-						const len = Math.min(src.length, dest.length - destStartSample);
-						for (let i = 0; i < len; i++) if (destStartSample + i >= 0) dest[destStartSample + i] += src[i];
-					}
+					const childStartSample = Math.round(childStartFrame / fps * targetSampleRate);
+					bus.add(childChannels, segmentStartSample + childStartSample);
 				}
 			}
 			const pluginProcessor = audioRegistry.get(op.op);
 			if (pluginProcessor) try {
 				const clipDurationSec = actualDurationFrames / fps;
 				const clipSamplesCount = Math.min(localSamplesCount - segmentStartSample, Math.ceil(clipDurationSec * targetSampleRate));
-				if (clipSamplesCount > 0 && segmentStartSample < localSamplesCount && segmentStartSample >= 0) await pluginProcessor(localChannels.map((ch) => ch.subarray(segmentStartSample, segmentStartSample + clipSamplesCount)), targetSampleRate, node, {
+				if (clipSamplesCount > 0 && segmentStartSample < localSamplesCount && segmentStartSample >= 0) await pluginProcessor(bus.get().map((ch) => ch.subarray(segmentStartSample, segmentStartSample + clipSamplesCount)), targetSampleRate, node, {
 					device,
 					frame: totalClockFrames,
 					fps,
@@ -1329,10 +1470,31 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 				currentStart += durFrames;
 			}
 		} else await processSegment(null, 0);
-		return localChannels;
+		return bus.channels;
+	}
+	const normalized = normalizeTimeline(virtualMedia, fps);
+	let clipsTotal = 0;
+	let clipsDone = 0;
+	if (options.onProgress) {
+		const count = (node) => {
+			if (!node) return;
+			const op = node.operation;
+			if (op?.op === "source") {
+				const mediaType = getMediaType(node);
+				if (mediaType === "Audio" || mediaType === "Video") clipsTotal += Math.max(1, op.timeline?.segments?.length ?? 0);
+			}
+			for (const child of node.children ?? []) count(child);
+		};
+		count(normalized);
+		options.onProgress({
+			done: 0,
+			total: clipsTotal
+		});
 	}
-	const rootChannels = await traverse(normalizeTimeline(virtualMedia, fps), 0, 0, 1, 1, null);
-	if (rootChannels) for (let c = 0; c < 2; c++) {
+	const rootChannels = await traverse(normalized, 0, 0, 1, 1, null);
+	const mixedChannels = rootChannels?.every((ch) => ch.length === totalTargetSamples) && rootChannels[0] !== rootChannels[1] ? rootChannels : [new Float32Array(totalTargetSamples), new Float32Array(totalTargetSamples)];
+	const [outputLeft, outputRight] = mixedChannels;
+	if (rootChannels && mixedChannels !== rootChannels) for (let c = 0; c < 2; c++) {
 		const dest = mixedChannels[c];
 		const src = rootChannels[c];
 		const len = Math.min(src.length, dest.length);
@@ -1361,4 +1523,4 @@ async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device
 
 //#endregion
 export { spring as _, resolveLayerDuration as a, computeStrokeRect as c, measureSpring as d, measureText as f, requiresIsolation as g, preloadFont as h, mixAudioTracks as i, interpolate as l, preloadCompositionFonts as m, decodeAudioSource as n, Easing as o, measureTextAsync as p, drawCompositionTree as r, bezier as s, compositionStateStore as t, mapBlendModeToSkia as u, springCalculation as v };
-//# sourceMappingURL=dist-Cl0mvShy.mjs.map
+//# sourceMappingURL=dist-CxGfrigI.mjs.map