@editframe/elements 0.16.8-beta.0 → 0.18.3-beta.0

package/dist/gui/services/ElementConnectionManager.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Manages dynamic connection/disconnection of media elements to AudioContext
+ * Extracted from ContextMixin to improve separation of concerns and testability
+ */
+export declare class ElementConnectionManager {
+    private connectedMediaSources;
+    private lookaheadMs;
+    constructor(lookaheadMs?: number);
+    /**
+     * Update connected media elements based on current playhead position
+     * Connects upcoming elements and disconnects past elements
+     */
+    updateConnectedElements(audioContext: AudioContext, timegroup: any, // EFTimegroup type
+    currentMs: number): Promise<void>;
+    /**
+     * Find elements that should be connected based on timeline position
+     */
+    private getElementsToConnect;
+    /**
+     * Connect new elements that aren't already connected
+     */
+    private connectNewElements;
+    /**
+     * Update connection states for all managed elements
+     */
+    private updateElementStates;
+    /**
+     * Activate an element (connect to destination and start playback)
+     */
+    private activateElement;
+    /**
+     * Deactivate an element (disconnect but keep prepared)
+     */
+    private deactivateElement;
+    /**
+     * Clean up elements that are far in the past
+     */
+    private cleanupOldElements;
+    /**
+     * Clear all connected media sources (for cleanup)
+     */
+    clearAll(): void;
+    /**
+     * Get connection status for testing/debugging
+     */
+    getConnectionInfo(): {
+        total: number;
+        connected: number;
+        prepared: number;
+    };
+    /**
+     * Set lookahead time
+     */
+    setLookaheadMs(lookaheadMs: number): void;
+    /**
+     * Get current lookahead time
+     */
+    getLookaheadMs(): number;
+}

package/dist/gui/services/ElementConnectionManager.js

@@ -0,0 +1,128 @@
+/**
+* Manages dynamic connection/disconnection of media elements to AudioContext
+* Extracted from ContextMixin to improve separation of concerns and testability
+*/
+var ElementConnectionManager = class {
+	constructor(lookaheadMs = 3e3) {
+		this.connectedMediaSources = /* @__PURE__ */ new Map();
+		this.lookaheadMs = lookaheadMs;
+	}
+	/**
+	* Update connected media elements based on current playhead position
+	* Connects upcoming elements and disconnects past elements
+	*/
+	async updateConnectedElements(audioContext, timegroup, currentMs) {
+		if (!audioContext || audioContext.state === "closed") return;
+		const allMediaElements = Array.from(timegroup.querySelectorAll("ef-audio, ef-video"));
+		const lookaheadMs = currentMs + this.lookaheadMs;
+		const elementsToConnect = this.getElementsToConnect(allMediaElements, currentMs, lookaheadMs);
+		await this.connectNewElements(audioContext, elementsToConnect);
+		await this.updateElementStates(currentMs);
+		this.cleanupOldElements(currentMs);
+	}
+	/**
+	* Find elements that should be connected based on timeline position
+	*/
+	getElementsToConnect(allElements, currentMs, lookaheadMs) {
+		return allElements.filter((mediaElement) => {
+			const startTime = mediaElement.startTimeMs;
+			const endTime = mediaElement.endTimeMs;
+			const isCurrentlyActive = currentMs >= startTime && currentMs < endTime;
+			const isStartingSoon = startTime > currentMs && startTime <= lookaheadMs;
+			return isCurrentlyActive || isStartingSoon;
+		});
+	}
+	/**
+	* Connect new elements that aren't already connected
+	*/
+	async connectNewElements(audioContext, elementsToConnect) {
+		for (const mediaElement of elementsToConnect) if (!this.connectedMediaSources.has(mediaElement)) {
+			const mediaElementSource = await mediaElement.getMediaElementSource(audioContext);
+			this.connectedMediaSources.set(mediaElement, {
+				mediaElementSource,
+				connected: false
+			});
+		}
+	}
+	/**
+	* Update connection states for all managed elements
+	*/
+	async updateElementStates(currentMs) {
+		for (const [mediaElement, sourceInfo] of this.connectedMediaSources.entries()) {
+			const startTime = mediaElement.startTimeMs;
+			const endTime = mediaElement.endTimeMs;
+			const isCurrentlyActive = currentMs >= startTime && currentMs < endTime;
+			if (isCurrentlyActive && !sourceInfo.connected) await this.activateElement(mediaElement, sourceInfo);
+			else if (!isCurrentlyActive && sourceInfo.connected) await this.deactivateElement(mediaElement, sourceInfo);
+		}
+	}
+	/**
+	* Activate an element (connect to destination and start playback)
+	*/
+	async activateElement(mediaElement, sourceInfo) {
+		sourceInfo.mediaElementSource.connect(sourceInfo.mediaElementSource.context.destination);
+		sourceInfo.connected = true;
+		if (mediaElement.audioElement) {
+			const mediaTimeMs = mediaElement.currentSourceTimeMs;
+			mediaElement.audioElement.currentTime = mediaTimeMs / 1e3;
+			await mediaElement.audioElement.play();
+		}
+	}
+	/**
+	* Deactivate an element (disconnect but keep prepared)
+	*/
+	async deactivateElement(mediaElement, sourceInfo) {
+		sourceInfo.mediaElementSource.disconnect();
+		sourceInfo.connected = false;
+		if (mediaElement.audioElement) mediaElement.audioElement.pause();
+	}
+	/**
+	* Clean up elements that are far in the past
+	*/
+	cleanupOldElements(currentMs) {
+		const cleanupThresholdMs = currentMs - this.lookaheadMs;
+		for (const [mediaElement, sourceInfo] of this.connectedMediaSources.entries()) {
+			const endTime = mediaElement.endTimeMs;
+			if (endTime < cleanupThresholdMs) {
+				if (sourceInfo.connected) sourceInfo.mediaElementSource.disconnect();
+				this.connectedMediaSources.delete(mediaElement);
+			}
+		}
+	}
+	/**
+	* Clear all connected media sources (for cleanup)
+	*/
+	clearAll() {
+		for (const [, sourceInfo] of this.connectedMediaSources.entries()) try {
+			if (sourceInfo.connected) sourceInfo.mediaElementSource.disconnect();
+		} catch (_error) {}
+		this.connectedMediaSources.clear();
+	}
+	/**
+	* Get connection status for testing/debugging
+	*/
+	getConnectionInfo() {
+		let connected = 0;
+		let prepared = 0;
+		for (const [, sourceInfo] of this.connectedMediaSources.entries()) if (sourceInfo.connected) connected++;
+		else prepared++;
+		return {
+			total: this.connectedMediaSources.size,
+			connected,
+			prepared
+		};
+	}
+	/**
+	* Set lookahead time
+	*/
+	setLookaheadMs(lookaheadMs) {
+		this.lookaheadMs = lookaheadMs;
+	}
+	/**
+	* Get current lookahead time
+	*/
+	getLookaheadMs() {
+		return this.lookaheadMs;
+	}
+};
+export { ElementConnectionManager };

package/dist/gui/services/PlaybackController.browsertest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gui/services/PlaybackController.d.ts

@@ -0,0 +1,103 @@
+export interface PlaybackControllerOptions {
+    fps?: number;
+    onTimeUpdate?: (timeMs: number) => void;
+    onPlayStateChange?: (playing: boolean) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Manages playback timing, AudioContext lifecycle, and timeline synchronization
+ * Extracted from ContextMixin to improve separation of concerns and testability
+ */
+export declare class PlaybackController {
+    private playbackAudioContext;
+    private animationFrameRequest;
+    private options;
+    private playing;
+    private currentTimeMs;
+    private msPerFrame;
+    private audioStartTime;
+    private playbackStartTimeMs;
+    private activeChunks;
+    private chunkDurationMs;
+    private lookaheadChunks;
+    private currentChunkIndex;
+    private renderingChunks;
+    constructor(options?: PlaybackControllerOptions);
+    /**
+     * Start playback for the given timegroup
+     */
+    startPlayback(timegroup: any, fromMs?: number): Promise<void>;
+    /**
+     * Stop playback and clean up resources
+     */
+    stopPlayback(): Promise<void>;
+    /**
+     * Pause playback (can be resumed)
+     */
+    pausePlayback(): Promise<void>;
+    /**
+     * Resume paused playback
+     */
+    resumePlayback(): Promise<void>;
+    /**
+     * Seek to a specific time (restarts progressive playback from new position)
+     */
+    seekTo(timeMs: number, timegroup?: any): Promise<void>;
+    /**
+     * Internal method to sync playhead with unified audio buffer timing
+     */
+    private syncPlayheadToAudioBuffer;
+    /**
+     * Update playing state and notify observers
+     */
+    private setPlaying;
+    /**
+     * Get current playback state
+     */
+    isPlaying(): boolean;
+    /**
+     * Get current time
+     */
+    getCurrentTime(): number;
+    /**
+     * Get current AudioContext
+     */
+    getAudioContext(): AudioContext | null;
+    /**
+     * Check if AudioContext is ready
+     */
+    isAudioContextReady(): boolean;
+    /**
+     * Get playback statistics for debugging
+     */
+    getPlaybackInfo(): {
+        playing: boolean;
+        currentTimeMs: number;
+        audioContextState: string | null;
+        hasElementManager: boolean;
+    };
+    /**
+     * Update playback options
+     */
+    updateOptions(options: Partial<PlaybackControllerOptions>): void;
+    /**
+     * Start progressive chunk rendering and playback
+     */
+    private startProgressivePlayback;
+    /**
+     * Render and schedule a single audio chunk
+     */
+    private renderAndScheduleChunk;
+    /**
+     * Update chunk rendering as playhead advances - now handles all chunk management
+     */
+    private updateProgressiveChunks;
+    /**
+     * Systematically ensure chunks are ready ahead of current playback (synchronous)
+     */
+    private ensureChunksAhead;
+    /**
+     * Clean up chunks that are behind the current playhead
+     */
+    private cleanupOldChunks;
+}

package/dist/gui/services/PlaybackController.js

@@ -0,0 +1,290 @@
+/**
+* Manages playback timing, AudioContext lifecycle, and timeline synchronization
+* Extracted from ContextMixin to improve separation of concerns and testability
+*/
+var PlaybackController = class {
+	constructor(options = {}) {
+		this.playbackAudioContext = null;
+		this.animationFrameRequest = null;
+		this.playing = false;
+		this.currentTimeMs = 0;
+		this.audioStartTime = 0;
+		this.playbackStartTimeMs = 0;
+		this.activeChunks = /* @__PURE__ */ new Map();
+		this.chunkDurationMs = 4e3;
+		this.lookaheadChunks = 2;
+		this.currentChunkIndex = 0;
+		this.renderingChunks = /* @__PURE__ */ new Set();
+		this.options = {
+			fps: 30,
+			onTimeUpdate: () => {},
+			onPlayStateChange: () => {},
+			onError: () => {},
+			...options
+		};
+		this.msPerFrame = 1e3 / this.options.fps;
+	}
+	/**
+	* Start playback for the given timegroup
+	*/
+	async startPlayback(timegroup, fromMs) {
+		await this.stopPlayback();
+		if (!timegroup) {
+			this.setPlaying(false);
+			this.options.onPlayStateChange(false);
+			this.options.onError(/* @__PURE__ */ new Error("No timegroup provided"));
+			return;
+		}
+		await timegroup.waitForMediaDurations?.();
+		const currentMs = fromMs ?? timegroup.currentTimeMs ?? 0;
+		const toMs = timegroup.endTimeMs;
+		if (currentMs >= toMs) {
+			this.setPlaying(false);
+			this.options.onPlayStateChange(false);
+			return;
+		}
+		try {
+			this.playbackAudioContext = new AudioContext({ latencyHint: "playback" });
+			if (this.playbackAudioContext.state === "suspended") {
+				console.warn("AudioContext is suspended, attempting to resume...");
+				try {
+					await Promise.race([this.playbackAudioContext.resume(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("AudioContext resume timeout")), 2e3))]);
+				} catch (error) {
+					console.warn("AudioContext resume failed:", error);
+				}
+			} else await this.playbackAudioContext.resume();
+			this.audioStartTime = this.playbackAudioContext.currentTime;
+			this.playbackStartTimeMs = currentMs;
+			this.currentChunkIndex = Math.floor(currentMs / this.chunkDurationMs);
+			await this.startProgressivePlayback(timegroup, currentMs, toMs);
+			if (this.isAudioContextReady()) {
+				this.setPlaying(true);
+				this.currentTimeMs = currentMs;
+				this.options.onTimeUpdate(currentMs);
+				this.syncPlayheadToAudioBuffer(timegroup, currentMs);
+			} else {
+				this.setPlaying(false);
+				this.options.onPlayStateChange(false);
+				console.warn("AudioContext not ready for playback, state:", this.playbackAudioContext?.state);
+			}
+		} catch (error) {
+			console.error("🎵 [PLAYBACK_ERROR] Failed to setup progressive audio playback:", error);
+			this.setPlaying(false);
+			this.options.onPlayStateChange(false);
+			this.options.onError(error);
+		}
+	}
+	/**
+	* Stop playback and clean up resources
+	*/
+	async stopPlayback() {
+		for (const [_chunkIndex, bufferSource] of this.activeChunks.entries()) try {
+			bufferSource.stop();
+		} catch (_error) {}
+		this.activeChunks.clear();
+		this.renderingChunks.clear();
+		if (this.playbackAudioContext) {
+			if (this.playbackAudioContext.state !== "closed") await this.playbackAudioContext.close();
+		}
+		if (this.animationFrameRequest) {
+			cancelAnimationFrame(this.animationFrameRequest);
+			this.animationFrameRequest = null;
+		}
+		this.playbackAudioContext = null;
+		this.setPlaying(false);
+	}
+	/**
+	* Pause playback (can be resumed)
+	*/
+	async pausePlayback() {
+		if (this.playbackAudioContext && this.playbackAudioContext.state === "running") try {
+			await Promise.race([this.playbackAudioContext.suspend(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("AudioContext suspend timeout")), 2e3))]);
+		} catch (error) {
+			console.warn("AudioContext suspend failed:", error);
+		}
+		if (this.animationFrameRequest) {
+			cancelAnimationFrame(this.animationFrameRequest);
+			this.animationFrameRequest = null;
+		}
+		this.setPlaying(false);
+	}
+	/**
+	* Resume paused playback
+	*/
+	async resumePlayback() {
+		if (this.playbackAudioContext && this.playbackAudioContext.state === "suspended") {
+			try {
+				await Promise.race([this.playbackAudioContext.resume(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("AudioContext resume timeout")), 2e3))]);
+			} catch (error) {
+				console.warn("AudioContext resume failed:", error);
+			}
+			this.setPlaying(true);
+		}
+	}
+	/**
+	* Seek to a specific time (restarts progressive playback from new position)
+	*/
+	async seekTo(timeMs, timegroup) {
+		this.currentTimeMs = timeMs;
+		this.options.onTimeUpdate(timeMs);
+		if (this.playing && timegroup) {
+			for (const bufferSource of this.activeChunks.values()) try {
+				bufferSource.stop();
+			} catch (_error) {}
+			this.activeChunks.clear();
+			this.renderingChunks.clear();
+			this.audioStartTime = this.playbackAudioContext?.currentTime ?? 0;
+			this.playbackStartTimeMs = timeMs;
+			this.currentChunkIndex = Math.floor(timeMs / this.chunkDurationMs);
+			await this.startProgressivePlayback(timegroup, timeMs, timegroup.endTimeMs);
+		}
+	}
+	/**
+	* Internal method to sync playhead with unified audio buffer timing
+	*/
+	syncPlayheadToAudioBuffer(timegroup, startMs) {
+		if (!this.playbackAudioContext || !this.playing) return;
+		const elapsedAudioTime = this.playbackAudioContext.currentTime - this.audioStartTime;
+		const rawTimeMs = startMs + elapsedAudioTime * 1e3;
+		const nextTimeMs = Math.round(rawTimeMs / this.msPerFrame) * this.msPerFrame;
+		if (nextTimeMs !== this.currentTimeMs) {
+			this.currentTimeMs = nextTimeMs;
+			this.options.onTimeUpdate(nextTimeMs);
+			if (timegroup && timegroup.currentTimeMs !== nextTimeMs) timegroup.currentTimeMs = nextTimeMs;
+			this.updateProgressiveChunks(timegroup, nextTimeMs, timegroup.endTimeMs);
+		}
+		this.animationFrameRequest = requestAnimationFrame(() => {
+			this.syncPlayheadToAudioBuffer(timegroup, startMs);
+		});
+	}
+	/**
+	* Update playing state and notify observers
+	*/
+	setPlaying(playing) {
+		if (this.playing !== playing) {
+			this.playing = playing;
+			this.options.onPlayStateChange(playing);
+		}
+	}
+	/**
+	* Get current playback state
+	*/
+	isPlaying() {
+		return this.playing;
+	}
+	/**
+	* Get current time
+	*/
+	getCurrentTime() {
+		return this.currentTimeMs;
+	}
+	/**
+	* Get current AudioContext
+	*/
+	getAudioContext() {
+		return this.playbackAudioContext;
+	}
+	/**
+	* Check if AudioContext is ready
+	*/
+	isAudioContextReady() {
+		return this.playbackAudioContext != null && this.playbackAudioContext.state !== "closed";
+	}
+	/**
+	* Get playback statistics for debugging
+	*/
+	getPlaybackInfo() {
+		return {
+			playing: this.playing,
+			currentTimeMs: this.currentTimeMs,
+			audioContextState: this.playbackAudioContext?.state || null,
+			hasElementManager: false
+		};
+	}
+	/**
+	* Update playback options
+	*/
+	updateOptions(options) {
+		Object.assign(this.options, options);
+		if (options.fps) this.msPerFrame = 1e3 / options.fps;
+	}
+	/**
+	* Start progressive chunk rendering and playback
+	*/
+	async startProgressivePlayback(timegroup, fromMs, _toMs) {
+		const firstChunkIndex = Math.floor(fromMs / this.chunkDurationMs);
+		const firstChunkStart = firstChunkIndex * this.chunkDurationMs;
+		const offsetInChunk = fromMs - firstChunkStart;
+		await this.renderAndScheduleChunk(timegroup, firstChunkStart, firstChunkIndex, offsetInChunk);
+	}
+	/**
+	* Render and schedule a single audio chunk
+	*/
+	async renderAndScheduleChunk(timegroup, chunkStartMs, chunkIndex, offsetInChunk = 0) {
+		if (this.renderingChunks.has(chunkIndex) || this.activeChunks.has(chunkIndex)) return;
+		this.renderingChunks.add(chunkIndex);
+		try {
+			const chunkEndMs = chunkStartMs + this.chunkDurationMs;
+			const chunkBuffer = await timegroup.renderAudio(chunkStartMs, chunkEndMs);
+			const bufferSource = this.playbackAudioContext?.createBufferSource();
+			if (!bufferSource || !this.playbackAudioContext?.destination) throw new Error("Audio context or buffer source not available");
+			bufferSource.buffer = chunkBuffer;
+			bufferSource.connect(this.playbackAudioContext.destination);
+			const chunkTimelineStartMs = chunkIndex * this.chunkDurationMs;
+			const relativeDelayMs = Math.max(0, chunkTimelineStartMs - this.playbackStartTimeMs);
+			const chunkStartTime = this.audioStartTime + relativeDelayMs / 1e3;
+			const startOffset = offsetInChunk / 1e3;
+			const now = this.playbackAudioContext?.currentTime ?? 0;
+			if (chunkStartTime <= now) console.warn(`🎵 [CHUNK_TIMING_WARNING] Chunk ${chunkIndex} scheduled in the past! startTime=${chunkStartTime.toFixed(3)}s, currentTime=${now.toFixed(3)}s`);
+			bufferSource.start(chunkStartTime, startOffset);
+			this.activeChunks.set(chunkIndex, bufferSource);
+			bufferSource.onended = () => {
+				this.activeChunks.delete(chunkIndex);
+			};
+		} catch (error) {
+			console.error(`🎵 [CHUNK_ERROR] Failed to render chunk ${chunkIndex}:`, error);
+		} finally {
+			this.renderingChunks.delete(chunkIndex);
+		}
+	}
+	/**
+	* Update chunk rendering as playhead advances - now handles all chunk management
+	*/
+	updateProgressiveChunks(timegroup, currentTimeMs, maxTimeMs) {
+		const newChunkIndex = Math.floor(currentTimeMs / this.chunkDurationMs);
+		if (newChunkIndex !== this.currentChunkIndex) {
+			this.currentChunkIndex = newChunkIndex;
+			this.cleanupOldChunks();
+		}
+		this.ensureChunksAhead(timegroup, maxTimeMs);
+	}
+	/**
+	* Systematically ensure chunks are ready ahead of current playback (synchronous)
+	*/
+	ensureChunksAhead(timegroup, maxTimeMs) {
+		for (let i = 1; i <= this.lookaheadChunks; i++) {
+			const targetChunkIndex = this.currentChunkIndex + i;
+			const targetChunkStartMs = targetChunkIndex * this.chunkDurationMs;
+			if (targetChunkStartMs >= maxTimeMs) break;
+			if (!this.renderingChunks.has(targetChunkIndex) && !this.activeChunks.has(targetChunkIndex)) {
+				const offsetInChunk = 0;
+				this.renderAndScheduleChunk(timegroup, targetChunkStartMs, targetChunkIndex, offsetInChunk).catch((error) => {
+					console.error(`🎵 [ENSURE_CHUNKS_ERROR] Failed to render chunk ${targetChunkIndex}:`, error);
+				});
+			}
+		}
+	}
+	/**
+	* Clean up chunks that are behind the current playhead
+	*/
+	cleanupOldChunks() {
+		const cutoffChunkIndex = this.currentChunkIndex - 1;
+		for (const [chunkIndex, bufferSource] of this.activeChunks.entries()) if (chunkIndex < cutoffChunkIndex) {
+			try {
+				bufferSource.stop();
+			} catch (_error) {}
+			this.activeChunks.delete(chunkIndex);
+		}
+	}
+};
+export { PlaybackController };

package/dist/index.js

@@ -1,12 +1,12 @@
-/* empty css             */
+/* empty css         */
+import { EFConfiguration } from "./gui/EFConfiguration.js";
+import "./elements/EFMedia.js";
 import { EFTimegroup } from "./elements/EFTimegroup.js";
 import { EFImage } from "./elements/EFImage.js";
-import "./elements/EFMedia.js";
 import { EFAudio } from "./elements/EFAudio.js";
 import { EFVideo } from "./elements/EFVideo.js";
 import { EFCaptions, EFCaptionsActiveWord, EFCaptionsAfterActiveWord, EFCaptionsBeforeActiveWord, EFCaptionsSegment } from "./elements/EFCaptions.js";
 import { EFWaveform } from "./elements/EFWaveform.js";
-import { EFConfiguration } from "./gui/EFConfiguration.js";
 import { EFWorkbench } from "./gui/EFWorkbench.js";
 import { EFPreview } from "./gui/EFPreview.js";
 import { EFFilmstrip } from "./gui/EFFilmstrip.js";
@@ -18,30 +18,5 @@ import { EFFocusOverlay } from "./gui/EFFocusOverlay.js";
 import { EFFitScale } from "./gui/EFFitScale.js";
 import "./EF_FRAMEGEN.js";
 import { RenderInfo, getRenderInfo } from "./getRenderInfo.js";
-if (typeof window !== "undefined") {
-  window.EF_REGISTERED = true;
-}
-export {
-  EFAudio,
-  EFCaptions,
-  EFCaptionsActiveWord,
-  EFCaptionsAfterActiveWord,
-  EFCaptionsBeforeActiveWord,
-  EFCaptionsSegment,
-  EFConfiguration,
-  EFFilmstrip,
-  EFFitScale,
-  EFFocusOverlay,
-  EFImage,
-  EFPreview,
-  EFScrubber,
-  EFTimeDisplay,
-  EFTimegroup,
-  EFToggleLoop,
-  EFTogglePlay,
-  EFVideo,
-  EFWaveform,
-  EFWorkbench,
-  RenderInfo,
-  getRenderInfo
-};
+if (typeof window !== "undefined") window.EF_REGISTERED = true;
+export { EFAudio, EFCaptions, EFCaptionsActiveWord, EFCaptionsAfterActiveWord, EFCaptionsBeforeActiveWord, EFCaptionsSegment, EFConfiguration, EFFilmstrip, EFFitScale, EFFocusOverlay, EFImage, EFPreview, EFScrubber, EFTimeDisplay, EFTimegroup, EFToggleLoop, EFTogglePlay, EFVideo, EFWaveform, EFWorkbench, RenderInfo, getRenderInfo };

package/dist/msToTimeCode.js

@@ -1,15 +1,13 @@
 const msToTimeCode = (ms, subSecond = false) => {
-  const seconds = Math.floor(ms / 1e3);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  const pad = (num) => num.toString().padStart(2, "0");
-  let timecode = `${pad(hours)}:${pad(minutes % 60)}:${pad(seconds % 60)}`;
-  if (subSecond) {
-    const subSeconds = Math.floor(ms % 1e3 / 10);
-    timecode += `.${subSeconds.toString().padStart(2, "0")}`;
-  }
-  return timecode;
-};
-export {
-  msToTimeCode
+	const seconds = Math.floor(ms / 1e3);
+	const minutes = Math.floor(seconds / 60);
+	const hours = Math.floor(minutes / 60);
+	const pad = (num) => num.toString().padStart(2, "0");
+	let timecode = `${pad(hours)}:${pad(minutes % 60)}:${pad(seconds % 60)}`;
+	if (subSecond) {
+		const subSeconds = Math.floor(ms % 1e3 / 10);
+		timecode += `.${subSeconds.toString().padStart(2, "0")}`;
+	}
+	return timecode;
 };
+export { msToTimeCode };