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

package/dist/elements/EFImage.d.ts

@@ -9,6 +9,7 @@ export declare class EFImage extends EFImage_base {
     set assetId(value: string | null);
     get assetId(): string | null;
     render(): import('lit-html').TemplateResult<1>;
+    private isDirectUrl;
     assetPath(): string;
     get hasOwnDuration(): boolean;
     fetchImage: Task<readonly [string, typeof fetch], void>;

package/dist/elements/EFImage.js

@@ -1,104 +1,86 @@
-import { Task } from "@lit/task";
-import { LitElement, html, css } from "lit";
-import { property, customElement } from "lit/decorators.js";
-import { createRef, ref } from "lit/directives/ref.js";
 import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
 import { EFSourceMixin } from "./EFSourceMixin.js";
 import { EFTemporal } from "./EFTemporal.js";
 import { FetchMixin } from "./FetchMixin.js";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
-var _assetId;
-let EFImage = class extends EFTemporal(
-  EFSourceMixin(FetchMixin(LitElement), {
-    assetType: "image_files"
-  })
-) {
-  constructor() {
-    super(...arguments);
-    this.imageRef = createRef();
-    this.canvasRef = createRef();
-    __privateAdd(this, _assetId, null);
-    this.fetchImage = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.assetPath(), this.fetch],
-      task: async ([assetPath, fetch], { signal }) => {
-        const response = await fetch(assetPath, { signal });
-        const image = new Image();
-        image.src = URL.createObjectURL(await response.blob());
-        await new Promise((resolve) => {
-          image.onload = resolve;
-        });
-        if (!this.canvasRef.value) throw new Error("Canvas not ready");
-        const ctx = this.canvasRef.value.getContext("2d");
-        if (!ctx) throw new Error("Canvas 2d context not ready");
-        this.canvasRef.value.width = image.width;
-        this.canvasRef.value.height = image.height;
-        ctx.drawImage(image, 0, 0);
-      }
-    });
-    this.frameTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.fetchImage.status],
-      task: async () => {
-        await this.fetchImage.taskComplete;
-      }
-    });
-  }
-  set assetId(value) {
-    __privateSet(this, _assetId, value);
-  }
-  get assetId() {
-    return __privateGet(this, _assetId) ?? this.getAttribute("asset-id");
-  }
-  render() {
-    return html`<canvas ${ref(this.canvasRef)}></canvas>`;
-  }
-  assetPath() {
-    if (this.assetId) {
-      return `${this.apiHost}/api/v1/image_files/${this.assetId}`;
-    }
-    return `/@ef-image/${this.src}`;
-  }
-  get hasOwnDuration() {
-    return this.hasExplicitDuration;
-  }
-};
-_assetId = /* @__PURE__ */ new WeakMap();
-EFImage.styles = [
-  css`
+import { Task } from "@lit/task";
+import { LitElement, css, html } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
+import { createRef, ref } from "lit/directives/ref.js";
+let EFImage = class EFImage$1 extends EFTemporal(EFSourceMixin(FetchMixin(LitElement), { assetType: "image_files" })) {
+	constructor(..._args) {
+		super(..._args);
+		this.imageRef = createRef();
+		this.canvasRef = createRef();
+		this.fetchImage = new Task(this, {
+			autoRun: EF_INTERACTIVE,
+			args: () => [this.assetPath(), this.fetch],
+			task: async ([assetPath, fetch], { signal }) => {
+				if (this.isDirectUrl(assetPath)) return;
+				const response = await fetch(assetPath, { signal });
+				const image = new Image();
+				image.src = URL.createObjectURL(await response.blob());
+				await new Promise((resolve, reject) => {
+					image.onload = resolve;
+					image.onerror = reject;
+				});
+				if (!this.canvasRef.value) throw new Error("Canvas not ready");
+				const ctx = this.canvasRef.value.getContext("2d");
+				if (!ctx) throw new Error("Canvas 2d context not ready");
+				this.canvasRef.value.width = image.width;
+				this.canvasRef.value.height = image.height;
+				ctx.drawImage(image, 0, 0);
+			}
+		});
+		this.frameTask = new Task(this, {
+			autoRun: EF_INTERACTIVE,
+			args: () => [this.fetchImage.status],
+			task: async () => {
+				await this.fetchImage.taskComplete;
+			}
+		});
+	}
+	static {
+		this.styles = [css`
       :host {
         display: block;
         display: flex;
         align-items: center;
         justify-content: center;
       }
-      canvas {
+      canvas, img {
         all: inherit;
       }
-    `
-];
-__decorateClass([
-  property({ type: String, attribute: "asset-id", reflect: true })
-], EFImage.prototype, "assetId", 1);
-EFImage = __decorateClass([
-  customElement("ef-image")
-], EFImage);
-export {
-  EFImage
+    `];
+	}
+	#assetId = null;
+	set assetId(value) {
+		this.#assetId = value;
+	}
+	get assetId() {
+		return this.#assetId ?? this.getAttribute("asset-id");
+	}
+	render() {
+		const assetPath = this.assetPath();
+		const isDirectUrl = this.isDirectUrl(assetPath);
+		return isDirectUrl ? html`<img ${ref(this.imageRef)} src=${assetPath} />` : html`<canvas ${ref(this.canvasRef)}></canvas>`;
+	}
+	isDirectUrl(src) {
+		return src.startsWith("http://") || src.startsWith("https://");
+	}
+	assetPath() {
+		if (this.assetId) return `${this.apiHost}/api/v1/image_files/${this.assetId}`;
+		if (this.isDirectUrl(this.src)) return this.src;
+		return `/@ef-image/${this.src}`;
+	}
+	get hasOwnDuration() {
+		return this.hasExplicitDuration;
+	}
 };
+_decorate([property({
+	type: String,
+	attribute: "asset-id",
+	reflect: true
+})], EFImage.prototype, "assetId", null);
+EFImage = _decorate([customElement("ef-image")], EFImage);
+export { EFImage };

package/dist/elements/EFMedia/AssetIdMediaEngine.d.ts

@@ -0,0 +1,18 @@
+import { TrackFragmentIndex } from '../../../../assets/src/index.ts';
+import { InitSegmentPaths, MediaEngine } from '../../transcoding/types';
+import { UrlGenerator } from '../../transcoding/utils/UrlGenerator';
+import { EFMedia } from '../EFMedia';
+import { AssetMediaEngine } from './AssetMediaEngine';
+export declare class AssetIdMediaEngine extends AssetMediaEngine implements MediaEngine {
+    assetId: string;
+    private apiHost;
+    static fetchByAssetId(host: EFMedia, _urlGenerator: UrlGenerator, assetId: string, apiHost: string): Promise<AssetIdMediaEngine>;
+    constructor(host: EFMedia, assetId: string, data: Record<number, TrackFragmentIndex>, apiHost: string);
+    get initSegmentPaths(): InitSegmentPaths;
+    get templates(): {
+        initSegment: string;
+        mediaSegment: string;
+    };
+    buildInitSegmentUrl(trackId: number): string;
+    buildMediaSegmentUrl(trackId: number, _segmentId: number): string;
+}

package/dist/elements/EFMedia/AssetIdMediaEngine.js

@@ -0,0 +1,41 @@
+import { AssetMediaEngine } from "./AssetMediaEngine.js";
+var AssetIdMediaEngine = class AssetIdMediaEngine extends AssetMediaEngine {
+	static async fetchByAssetId(host, _urlGenerator, assetId, apiHost) {
+		const url = `${apiHost}/api/v1/isobmff_files/${assetId}/index`;
+		const response = await host.fetch(url);
+		const data = await response.json();
+		return new AssetIdMediaEngine(host, assetId, data, apiHost);
+	}
+	constructor(host, assetId, data, apiHost) {
+		super(host, assetId, data);
+		this.assetId = assetId;
+		this.apiHost = apiHost;
+	}
+	get initSegmentPaths() {
+		const paths = {};
+		if (this.audioTrackIndex !== void 0) paths.audio = {
+			path: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${this.audioTrackIndex.track}`,
+			pos: this.audioTrackIndex.initSegment.offset,
+			size: this.audioTrackIndex.initSegment.size
+		};
+		if (this.videoTrackIndex !== void 0) paths.video = {
+			path: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${this.videoTrackIndex.track}`,
+			pos: this.videoTrackIndex.initSegment.offset,
+			size: this.videoTrackIndex.initSegment.size
+		};
+		return paths;
+	}
+	get templates() {
+		return {
+			initSegment: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/{trackId}`,
+			mediaSegment: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/{trackId}`
+		};
+	}
+	buildInitSegmentUrl(trackId) {
+		return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;
+	}
+	buildMediaSegmentUrl(trackId, _segmentId) {
+		return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;
+	}
+};
+export { AssetIdMediaEngine };

package/dist/elements/EFMedia/AssetIdMediaEngine.test.d.ts

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

package/dist/elements/EFMedia/AssetMediaEngine.d.ts

@@ -0,0 +1,47 @@
+import { TrackFragmentIndex } from '../../../../assets/src/index.ts';
+import { AudioRendition, InitSegmentPaths, MediaEngine, SegmentTimeRange } from '../../transcoding/types';
+import { UrlGenerator } from '../../transcoding/utils/UrlGenerator';
+import { EFMedia } from '../EFMedia';
+import { BaseMediaEngine } from './BaseMediaEngine';
+export declare class AssetMediaEngine extends BaseMediaEngine implements MediaEngine {
+    host: EFMedia;
+    src: string;
+    protected data: Record<number, TrackFragmentIndex>;
+    static fetch(host: EFMedia, urlGenerator: UrlGenerator, src: string): Promise<AssetMediaEngine>;
+    durationMs: number;
+    constructor(host: EFMedia, src: string, data: Record<number, TrackFragmentIndex>);
+    get audioTrackIndex(): import('../../../../assets/src/index.ts').AudioTrackFragmentIndex | undefined;
+    get videoTrackIndex(): import('../../../../assets/src/index.ts').VideoTrackFragmentIndex | undefined;
+    get videoRendition(): {
+        trackId: number | undefined;
+        src: string;
+        startTimeOffsetMs: number | undefined;
+    };
+    get audioRendition(): {
+        trackId: number | undefined;
+        src: string;
+    };
+    get initSegmentPaths(): InitSegmentPaths;
+    get templates(): {
+        initSegment: string;
+        mediaSegment: string;
+    };
+    buildInitSegmentUrl(trackId: number): string;
+    buildMediaSegmentUrl(trackId: number, segmentId: number): string;
+    fetchInitSegment(rendition: {
+        trackId: number | undefined;
+        src: string;
+    }, signal: AbortSignal): Promise<ArrayBuffer>;
+    fetchMediaSegmentImpl(segmentId: number, rendition: {
+        trackId: number | undefined;
+        src: string;
+    }, signal?: AbortSignal): Promise<ArrayBuffer>;
+    /**
+     * Calculate audio segments for variable-duration segments using track fragment index
+     */
+    calculateAudioSegmentRange(fromMs: number, toMs: number, rendition: AudioRendition, _durationMs: number): SegmentTimeRange[];
+    computeSegmentId(desiredSeekTimeMs: number, rendition: {
+        trackId: number | undefined;
+        src: string;
+    }): number;
+}

package/dist/elements/EFMedia/AssetMediaEngine.js

@@ -0,0 +1,116 @@
+import { BaseMediaEngine } from "./BaseMediaEngine.js";
+var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
+	static async fetch(host, urlGenerator, src) {
+		const url = urlGenerator.generateTrackFragmentIndexUrl(src);
+		const response = await host.fetch(url);
+		const data = await response.json();
+		if (src.startsWith("/")) src = src.slice(1);
+		return new AssetMediaEngine(host, src, data);
+	}
+	constructor(host, src, data) {
+		super();
+		this.host = host;
+		this.src = src;
+		this.data = data;
+		const longestFragment = Object.values(data).reduce((max, fragment) => Math.max(max, fragment.duration / fragment.timescale), 0);
+		this.durationMs = longestFragment * 1e3;
+	}
+	get audioTrackIndex() {
+		return Object.values(this.data).find((track) => track.type === "audio");
+	}
+	get videoTrackIndex() {
+		return Object.values(this.data).find((track) => track.type === "video");
+	}
+	get videoRendition() {
+		return {
+			trackId: this.videoTrackIndex?.track,
+			src: this.src,
+			startTimeOffsetMs: this.videoTrackIndex?.startTimeOffsetMs
+		};
+	}
+	get audioRendition() {
+		return {
+			trackId: this.audioTrackIndex?.track,
+			src: this.src
+		};
+	}
+	get initSegmentPaths() {
+		const paths = {};
+		if (this.audioTrackIndex !== void 0) paths.audio = {
+			path: `@ef-track/${this.audioTrackIndex.track}.m4s`,
+			pos: this.audioTrackIndex.initSegment.offset,
+			size: this.audioTrackIndex.initSegment.size
+		};
+		if (this.videoTrackIndex !== void 0) paths.video = {
+			path: `/@ef-track/${this.videoTrackIndex.track}.m4s`,
+			pos: this.videoTrackIndex.initSegment.offset,
+			size: this.videoTrackIndex.initSegment.size
+		};
+		return paths;
+	}
+	get templates() {
+		return {
+			initSegment: "/@ef-track/{src}?trackId={trackId}",
+			mediaSegment: "/@ef-track/{src}?trackId={trackId}"
+		};
+	}
+	buildInitSegmentUrl(trackId) {
+		return `/@ef-track/${this.src}?trackId=${trackId}`;
+	}
+	buildMediaSegmentUrl(trackId, segmentId) {
+		return `/@ef-track/${this.src}?trackId=${trackId}&segmentId=${segmentId}`;
+	}
+	async fetchInitSegment(rendition, signal) {
+		if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
+		const url = this.buildInitSegmentUrl(rendition.trackId);
+		const initSegment = this.data[rendition.trackId]?.initSegment;
+		if (!initSegment) throw new Error("Init segment not found");
+		const headers = { Range: `bytes=${initSegment.offset}-${initSegment.offset + initSegment.size - 1}` };
+		return this.fetchMediaCacheWithHeaders(url, headers, signal);
+	}
+	async fetchMediaSegmentImpl(segmentId, rendition, signal) {
+		if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
+		if (segmentId === void 0) throw new Error("Segment ID is not available");
+		const url = this.buildMediaSegmentUrl(rendition.trackId, segmentId);
+		const mediaSegment = this.data[rendition.trackId]?.segments[segmentId];
+		if (!mediaSegment) throw new Error("Media segment not found");
+		const headers = { Range: `bytes=${mediaSegment.offset}-${mediaSegment.offset + mediaSegment.size - 1}` };
+		return this.fetchMediaCacheWithHeaders(url, headers, signal);
+	}
+	/**
+	* Calculate audio segments for variable-duration segments using track fragment index
+	*/
+	calculateAudioSegmentRange(fromMs, toMs, rendition, _durationMs) {
+		if (fromMs >= toMs || !rendition.trackId) return [];
+		const track = this.data[rendition.trackId];
+		if (!track) return [];
+		const { timescale, segments } = track;
+		const segmentRanges = [];
+		for (let i = 0; i < segments.length; i++) {
+			const segment = segments[i];
+			const segmentStartTime = segment.cts;
+			const segmentEndTime = segment.cts + segment.duration;
+			const segmentStartMs = segmentStartTime / timescale * 1e3;
+			const segmentEndMs = segmentEndTime / timescale * 1e3;
+			if (segmentStartMs < toMs && segmentEndMs > fromMs) segmentRanges.push({
+				segmentId: i,
+				startMs: segmentStartMs,
+				endMs: segmentEndMs
+			});
+		}
+		return segmentRanges;
+	}
+	computeSegmentId(desiredSeekTimeMs, rendition) {
+		if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
+		const track = this.data[rendition.trackId];
+		if (!track) throw new Error("Track not found");
+		const { timescale, segments } = track;
+		const desiredSeekTime = desiredSeekTimeMs / 1e3 * timescale;
+		for (let i = segments.length - 1; i >= 0; i--) {
+			const segment = segments[i];
+			if (segment.cts <= desiredSeekTime) return i;
+		}
+		return 0;
+	}
+};
+export { AssetMediaEngine };

package/dist/elements/EFMedia/BaseMediaEngine.d.ts

@@ -0,0 +1,55 @@
+import { AudioRendition, SegmentTimeRange, VideoRendition } from '../../transcoding/types';
+import { EFMedia } from '../EFMedia.js';
+export declare abstract class BaseMediaEngine {
+    private requestDeduplicator;
+    abstract get videoRendition(): VideoRendition | undefined;
+    abstract get audioRendition(): AudioRendition | undefined;
+    abstract get host(): EFMedia;
+    getVideoRendition(): VideoRendition;
+    getAudioRendition(): AudioRendition;
+    /**
+     * Generate cache key for segment requests
+     */
+    private getSegmentCacheKey;
+    /**
+     * Abstract method for actual segment fetching - implemented by subclasses
+     */
+    abstract fetchMediaSegmentImpl(segmentId: number, rendition: {
+        trackId: number | undefined;
+        src: string;
+    }): Promise<ArrayBuffer>;
+    /**
+     * Fetch media segment with built-in deduplication
+     * Eliminates the need for separate coordinators - cleaner architecture
+     */
+    fetchMediaSegment(segmentId: number, rendition: {
+        trackId: number | undefined;
+        src: string;
+    }, _signal?: AbortSignal): Promise<ArrayBuffer>;
+    /**
+     * Check if a segment is currently being fetched
+     */
+    isSegmentBeingFetched(segmentId: number, rendition: {
+        src: string;
+        trackId: number | undefined;
+    }): boolean;
+    /**
+     * Get count of active segment requests (for debugging/monitoring)
+     */
+    getActiveSegmentRequestCount(): number;
+    /**
+     * Cancel all active segment requests (for cleanup)
+     */
+    cancelAllSegmentRequests(): void;
+    fetchMediaCache(mediaUrl: string): Promise<ArrayBuffer>;
+    /**
+     * Enhanced caching method that supports custom headers (e.g., Range requests)
+     * Cache key includes both URL and headers for proper cache isolation
+     */
+    fetchMediaCacheWithHeaders(mediaUrl: string, headers?: Record<string, string>, signal?: AbortSignal): Promise<ArrayBuffer>;
+    /**
+     * Calculate audio segments needed for a time range
+     * Each media engine implements this based on their segment structure
+     */
+    calculateAudioSegmentRange(fromMs: number, toMs: number, rendition: AudioRendition, durationMs: number): SegmentTimeRange[];
+}

package/dist/elements/EFMedia/BaseMediaEngine.js

@@ -0,0 +1,96 @@
+import { RequestDeduplicator } from "../../transcoding/cache/RequestDeduplicator.js";
+import { SizeAwareLRUCache } from "../../utils/LRUCache.js";
+const mediaCache = new SizeAwareLRUCache(100 * 1024 * 1024);
+var BaseMediaEngine = class {
+	constructor() {
+		this.requestDeduplicator = new RequestDeduplicator();
+	}
+	getVideoRendition() {
+		if (!this.videoRendition) throw new Error("No video rendition available");
+		return this.videoRendition;
+	}
+	getAudioRendition() {
+		if (!this.audioRendition) throw new Error("No audio rendition available");
+		return this.audioRendition;
+	}
+	/**
+	* Generate cache key for segment requests
+	*/
+	getSegmentCacheKey(segmentId, rendition) {
+		return `${rendition.src}-${rendition.id}-${segmentId}-${rendition.trackId}`;
+	}
+	/**
+	* Fetch media segment with built-in deduplication
+	* Eliminates the need for separate coordinators - cleaner architecture
+	*/
+	async fetchMediaSegment(segmentId, rendition, _signal) {
+		const cacheKey = this.getSegmentCacheKey(segmentId, rendition);
+		return this.requestDeduplicator.executeRequest(cacheKey, async () => {
+			return this.fetchMediaSegmentImpl(segmentId, rendition);
+		});
+	}
+	/**
+	* Check if a segment is currently being fetched
+	*/
+	isSegmentBeingFetched(segmentId, rendition) {
+		const cacheKey = this.getSegmentCacheKey(segmentId, rendition);
+		return this.requestDeduplicator.isPending(cacheKey);
+	}
+	/**
+	* Get count of active segment requests (for debugging/monitoring)
+	*/
+	getActiveSegmentRequestCount() {
+		return this.requestDeduplicator.getPendingCount();
+	}
+	/**
+	* Cancel all active segment requests (for cleanup)
+	*/
+	cancelAllSegmentRequests() {
+		this.requestDeduplicator.clear();
+	}
+	async fetchMediaCache(mediaUrl) {
+		const cached = mediaCache.get(mediaUrl);
+		if (cached) return cached;
+		const promise = this.host.fetch(mediaUrl).then((response) => response.arrayBuffer());
+		mediaCache.set(mediaUrl, promise);
+		return promise;
+	}
+	/**
+	* Enhanced caching method that supports custom headers (e.g., Range requests)
+	* Cache key includes both URL and headers for proper cache isolation
+	*/
+	async fetchMediaCacheWithHeaders(mediaUrl, headers, signal) {
+		const cacheKey = headers ? `${mediaUrl}:${JSON.stringify(headers)}` : mediaUrl;
+		const cached = mediaCache.get(cacheKey);
+		if (cached) return cached;
+		const promise = this.host.fetch(mediaUrl, {
+			headers,
+			signal
+		}).then((response) => response.arrayBuffer());
+		mediaCache.set(cacheKey, promise);
+		return promise;
+	}
+	/**
+	* Calculate audio segments needed for a time range
+	* Each media engine implements this based on their segment structure
+	*/
+	calculateAudioSegmentRange(fromMs, toMs, rendition, durationMs) {
+		if (fromMs >= toMs) return [];
+		const segmentDurationMs = rendition.segmentDurationMs || 1e3;
+		const segments = [];
+		const startSegmentIndex = Math.floor(fromMs / segmentDurationMs);
+		const endSegmentIndex = Math.floor(toMs / segmentDurationMs);
+		for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {
+			const segmentId = i + 1;
+			const segmentStartMs = i * segmentDurationMs;
+			const segmentEndMs = Math.min((i + 1) * segmentDurationMs, durationMs);
+			if (segmentStartMs < toMs && segmentEndMs > fromMs) segments.push({
+				segmentId,
+				startMs: segmentStartMs,
+				endMs: segmentEndMs
+			});
+		}
+		return segments;
+	}
+};
+export { BaseMediaEngine };

package/dist/elements/EFMedia/BaseMediaEngine.test.d.ts

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

package/dist/elements/EFMedia/BufferedSeekingInput.browsertest.d.ts

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

package/dist/elements/EFMedia/BufferedSeekingInput.d.ts

@@ -0,0 +1,43 @@
+import { MediaSample } from '../SampleBuffer';
+interface BufferedSeekingInputOptions {
+    videoBufferSize?: number;
+    audioBufferSize?: number;
+    /**
+     * FFmpeg start_time offset in milliseconds from the processed video.
+     * Applied during seeking to correct for timing shifts introduced by FFmpeg processing.
+     */
+    startTimeOffsetMs?: number;
+}
+export declare class NoSample extends RangeError {
+}
+export declare class BufferedSeekingInput {
+    private input;
+    private trackIterators;
+    private trackBuffers;
+    private options;
+    private trackIteratorCreationPromises;
+    private trackSeekPromises;
+    /**
+     * FFmpeg start_time offset in milliseconds from the processed video.
+     * Applied during seeking to correct for timing shifts introduced by FFmpeg processing.
+     */
+    private readonly startTimeOffsetMs;
+    constructor(arrayBuffer: ArrayBuffer, options?: BufferedSeekingInputOptions);
+    getBufferSize(trackId: number): number;
+    getBufferContents(trackId: number): readonly MediaSample[];
+    getBufferTimestamps(trackId: number): number[];
+    clearBuffer(trackId: number): void;
+    computeDuration(): Promise<number>;
+    getTrack(trackId: number): Promise<import('mediabunny').InputTrack>;
+    getAudioTrack(trackId: number): Promise<import('mediabunny').InputAudioTrack>;
+    getVideoTrack(trackId: number): Promise<import('mediabunny').InputVideoTrack>;
+    getFirstVideoTrack(): Promise<import('mediabunny').InputVideoTrack | undefined>;
+    getFirstAudioTrack(): Promise<import('mediabunny').InputAudioTrack | undefined>;
+    getTrackIterator(trackId: number): Promise<AsyncIterator<MediaSample, any, undefined>>;
+    private createIteratorSafe;
+    createTrackBuffer(trackId: number): Promise<void>;
+    seek(trackId: number, timeMs: number): Promise<MediaSample>;
+    private resetIterator;
+    private seekSafe;
+}
+export {};