@openplayerjs/core 3.0.2 → 3.1.1

package/dist/index.js

@@ -1,9 +1,110 @@
 const DVR_THRESHOLD = 120;
 const EVENT_OPTIONS = { passive: false };
 
+/**
+ * Wrap a native HTMLMediaElement inside the normalized MediaSurface contract.
+ */
+class HtmlMediaSurface {
+    constructor(media) {
+        Object.defineProperty(this, "media", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: media
+        });
+        Object.defineProperty(this, "element", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.element = media;
+    }
+    get currentSrc() {
+        return this.media.currentSrc || this.media.src || '';
+    }
+    get currentTime() {
+        return this.media.currentTime || 0;
+    }
+    set currentTime(value) {
+        this.media.currentTime = value;
+    }
+    get duration() {
+        return this.media.duration;
+    }
+    set duration(_value) {
+        // Native media duration is read-only.
+    }
+    get volume() {
+        return this.media.volume;
+    }
+    set volume(value) {
+        this.media.volume = value;
+    }
+    get muted() {
+        return this.media.muted;
+    }
+    set muted(value) {
+        this.media.muted = value;
+    }
+    get playbackRate() {
+        return this.media.playbackRate;
+    }
+    set playbackRate(value) {
+        this.media.playbackRate = value;
+    }
+    get paused() {
+        return this.media.paused;
+    }
+    get ended() {
+        return this.media.ended;
+    }
+    load(source) {
+        if (source?.src && this.media.src !== source.src) {
+            this.media.src = source.src;
+        }
+        this.media.load();
+    }
+    play() {
+        return this.media.play();
+    }
+    pause() {
+        this.media.pause();
+    }
+    on(event, handler, options) {
+        const wrapped = ((evt) => {
+            if (event === 'error') {
+                handler((this.media.error ?? evt));
+                return;
+            }
+            handler(undefined);
+        });
+        this.media.addEventListener(event, wrapped, options);
+        return () => this.media.removeEventListener(event, wrapped, options);
+    }
+}
+function bridgeSurfaceEvents(surface, events) {
+    return [
+        surface.on('loadstart', () => events.emit('loadstart'), EVENT_OPTIONS),
+        surface.on('loadedmetadata', () => events.emit('loadedmetadata'), EVENT_OPTIONS),
+        surface.on('durationchange', () => events.emit('durationchange'), EVENT_OPTIONS),
+        surface.on('timeupdate', () => events.emit('timeupdate'), EVENT_OPTIONS),
+        surface.on('waiting', () => events.emit('waiting'), EVENT_OPTIONS),
+        surface.on('seeking', () => events.emit('seeking'), EVENT_OPTIONS),
+        surface.on('seeked', () => events.emit('seeked'), EVENT_OPTIONS),
+        surface.on('ended', () => events.emit('ended'), EVENT_OPTIONS),
+        surface.on('error', (error) => events.emit('error', error), EVENT_OPTIONS),
+        surface.on('play', () => events.emit('play'), EVENT_OPTIONS),
+        surface.on('playing', () => events.emit('playing'), EVENT_OPTIONS),
+        surface.on('pause', () => events.emit('pause'), EVENT_OPTIONS),
+        surface.on('volumechange', () => events.emit('volumechange'), EVENT_OPTIONS),
+        surface.on('ratechange', () => events.emit('ratechange'), EVENT_OPTIONS),
+    ];
+}
+
 class BaseMediaEngine {
     constructor() {
-        Object.defineProperty(this, "media", {
+        Object.defineProperty(this, "surface", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -21,88 +122,94 @@ class BaseMediaEngine {
             writable: true,
             value: []
         });
-        Object.defineProperty(this, "mediaListeners", {
+        Object.defineProperty(this, "surfaceListeners", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: []
         });
     }
-    /**
-     * Bridge real HTMLMediaElement events into the player EventBus using
-     * HTML5 event names (no payload; consumers read from player/media).
-     */
-    bindMediaEvents(media, events) {
-        this.media = media;
+    bindSurfaceEvents(surface, events) {
+        this.surface = surface;
         this.events = events;
-        const onLoadedMetadata = () => events.emit('loadedmetadata');
-        const onDurationChange = () => events.emit('durationchange');
-        const onTimeUpdate = () => events.emit('timeupdate');
-        const onWaiting = () => events.emit('waiting');
-        const onSeeking = () => events.emit('seeking');
-        const onSeeked = () => events.emit('seeked');
-        const onEnded = () => events.emit('ended');
-        const onError = () => events.emit('error', media.error);
-        const onPlay = () => events.emit('play');
-        const onPlaying = () => events.emit('playing');
-        const onPause = () => events.emit('pause');
-        const onVolumeChange = () => events.emit('volumechange');
-        const onRateChange = () => events.emit('ratechange');
-        this.addMediaListener(media, 'loadedmetadata', onLoadedMetadata, EVENT_OPTIONS);
-        this.addMediaListener(media, 'durationchange', onDurationChange, EVENT_OPTIONS);
-        this.addMediaListener(media, 'timeupdate', onTimeUpdate, EVENT_OPTIONS);
-        this.addMediaListener(media, 'waiting', onWaiting, EVENT_OPTIONS);
-        this.addMediaListener(media, 'seeking', onSeeking, EVENT_OPTIONS);
-        this.addMediaListener(media, 'seeked', onSeeked, EVENT_OPTIONS);
-        this.addMediaListener(media, 'ended', onEnded, EVENT_OPTIONS);
-        this.addMediaListener(media, 'error', onError, EVENT_OPTIONS);
-        this.addMediaListener(media, 'playing', onPlaying, EVENT_OPTIONS);
-        this.addMediaListener(media, 'pause', onPause, EVENT_OPTIONS);
-        this.addMediaListener(media, 'play', onPlay, EVENT_OPTIONS);
-        this.addMediaListener(media, 'volumechange', onVolumeChange, EVENT_OPTIONS);
-        this.addMediaListener(media, 'ratechange', onRateChange, EVENT_OPTIONS);
+        this.surfaceListeners = bridgeSurfaceEvents(surface, events);
+    }
+    unbindSurfaceEvents() {
+        this.surfaceListeners.forEach((off) => off());
+        this.surfaceListeners = [];
+    }
+    bindMediaEvents(media, events) {
+        const shim = {
+            get currentTime() { return media.currentTime; },
+            set currentTime(v) { media.currentTime = v; },
+            get duration() { return media.duration; },
+            set duration(_v) { },
+            get volume() { return media.volume; },
+            set volume(v) { media.volume = v; },
+            get muted() { return media.muted; },
+            set muted(v) { media.muted = v; },
+            get playbackRate() { return media.playbackRate; },
+            set playbackRate(v) { media.playbackRate = v; },
+            get paused() { return media.paused; },
+            get ended() { return media.ended; },
+            play: () => media.play(),
+            pause: () => media.pause(),
+            on: (event, handler) => {
+                const wrapped = () => handler();
+                media.addEventListener(event, wrapped);
+                return () => media.removeEventListener(event, wrapped);
+            },
+        };
+        this.surfaceListeners = bridgeSurfaceEvents(shim, events);
     }
     unbindMediaEvents() {
-        if (!this.media)
-            return;
-        for (const l of this.mediaListeners) {
-            this.media.removeEventListener(l.type, l.handler, l.options);
-        }
-        this.mediaListeners = [];
+        this.unbindSurfaceEvents();
     }
-    addMediaListener(media, type, handler, options) {
-        media.addEventListener(type, handler, options);
-        this.mediaListeners.push({ type, handler, options });
+    addMediaListener(media, event, handler, options) {
+        media.addEventListener(event, handler, options);
+        this.surfaceListeners.push(() => media.removeEventListener(event, handler, options));
     }
     canHandlePlayback(ctx) {
         const owner = ctx.core.leases.owner('playback');
         return !owner || owner === this.name;
     }
-    /**
-     * Commands are explicit and separate from notifications.
-     */
     bindCommands(ctx) {
-        const { media, events } = ctx;
+        const { events } = ctx;
         this.commands.push(events.on('cmd:seek', (t) => {
             if (!this.canHandlePlayback(ctx))
                 return;
             try {
-                media.currentTime = t;
+                ctx.surface.currentTime = t;
             }
             catch {
                 // ignore
             }
         }));
         this.commands.push(events.on('cmd:setVolume', (v) => {
-            media.volume = v;
+            try {
+                ctx.surface.volume = v;
+            }
+            catch {
+                // ignore
+            }
         }));
         this.commands.push(events.on('cmd:setMuted', (m) => {
-            media.muted = m;
+            try {
+                ctx.surface.muted = m;
+            }
+            catch {
+                // ignore
+            }
         }));
         this.commands.push(events.on('cmd:setRate', (r) => {
             if (!this.canHandlePlayback(ctx))
                 return;
-            media.playbackRate = r;
+            try {
+                ctx.surface.playbackRate = r;
+            }
+            catch {
+                // ignore
+            }
         }));
         this.bindPlayPauseCommands(ctx);
     }
@@ -112,25 +219,28 @@ class BaseMediaEngine {
         this.commands = [];
     }
     bindPlayPauseCommands(ctx) {
-        const { media, events } = ctx;
+        const { events } = ctx;
         this.commands.push(events.on('cmd:play', () => {
             if (!this.canHandlePlayback(ctx))
                 return;
-            this.playImpl(media);
+            this.playImpl(ctx.surface);
         }));
         this.commands.push(events.on('cmd:pause', () => {
             if (!this.canHandlePlayback(ctx))
                 return;
-            this.pauseImpl(media);
+            this.pauseImpl(ctx.surface);
         }));
     }
-    playImpl(media) {
-        void media.play().catch(() => {
-            // ignore
-        });
+    playImpl(surface) {
+        const maybePromise = surface.play();
+        if (maybePromise && typeof maybePromise.catch === 'function') {
+            void maybePromise.catch(() => {
+                // ignore
+            });
+        }
     }
-    pauseImpl(media) {
-        media.pause();
+    pauseImpl(surface) {
+        surface.pause();
     }
 }
 
@@ -167,28 +277,27 @@ class DefaultMediaEngine extends BaseMediaEngine {
         return media.canPlayType(source.type || '') !== '';
     }
     attach(ctx) {
-        if (ctx.activeSource?.src && ctx.media.src !== ctx.activeSource.src) {
-            ctx.media.src = ctx.activeSource.src;
-        }
+        const surface = ctx.resetSurface();
         try {
-            ctx.media.load();
+            surface.load?.(ctx.activeSource);
         }
         catch {
             // ignore
         }
-        this.bindMediaEvents(ctx.media, ctx.events);
+        this.bindSurfaceEvents(surface, ctx.events);
         this.bindCommands(ctx);
-        // When preload="none" and play is requested, bump preload so the browser
-        // will actually fetch resource metadata and fire loadedmetadata.
         this.commands.push(ctx.events.on('cmd:startLoad', () => {
             const s = ctx.core.state.current;
             if (['ready', 'playing', 'paused', 'waiting', 'seeking', 'ended'].includes(s))
                 return;
+            // ctx.media.preload is intentionally read/written here: it is a DOM attribute
+            // with no surface equivalent. The surface abstraction covers playback operations
+            // only; loading hints are DOM-level concerns that must be set directly on the element.
             if (ctx.media.preload !== 'none')
                 return;
             ctx.media.preload = 'metadata';
             try {
-                ctx.media.load();
+                surface.load?.(ctx.activeSource);
             }
             catch {
                 // ignore
@@ -197,7 +306,7 @@ class DefaultMediaEngine extends BaseMediaEngine {
     }
     detach() {
         this.unbindCommands();
-        this.unbindMediaEvents();
+        this.unbindSurfaceEvents();
     }
 }
 
@@ -411,7 +520,15 @@ function isMobile() {
         /android/i.test(window.navigator.userAgent));
 }
 function predictMimeType(media, url) {
-    const fragments = new URL(url).pathname.split('.');
+    let pathname;
+    try {
+        pathname = new URL(url).pathname;
+    }
+    catch {
+        // Non-URL string (e.g. a bare video ID): no extension can be determined.
+        return isAudio(media) ? 'audio/mp3' : 'video/mp4';
+    }
+    const fragments = pathname.split('.');
     const extension = fragments.length > 1 ? fragments.pop().toLowerCase() : '';
     // If no extension found, check if media is a vendor iframe
     if (!extension)
@@ -505,6 +622,18 @@ class Core {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "nativeSurface", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "activeSurface", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "interactionUnsubs", {
             enumerable: true,
             configurable: true,
@@ -623,30 +752,35 @@ class Core {
         else {
             this.media = media;
         }
+        this.nativeSurface = new HtmlMediaSurface(this.media);
+        this.activeSurface = this.nativeSurface;
         this.registerPlugin(new DefaultMediaEngine());
         this.config = { ...defaultConfiguration, ...config };
         this.media.currentTime = this.config.startTime || this.media.currentTime;
-        this._currentTime = this.config.startTime || this.media.currentTime;
-        this._duration = this.config.duration || this.media.duration;
-        const initialVolume = clamp01(this.config.startVolume ?? this.media.volume);
-        this.media.volume = initialVolume;
+        this._currentTime = this.config.startTime || this.activeSurface.currentTime;
+        this._duration = this.config.duration || this.activeSurface.duration;
+        const initialVolume = clamp01(this.config.startVolume ?? this.activeSurface.volume);
+        this.activeSurface.volume = initialVolume;
         this._volume = initialVolume;
         if (this.config.startVolume !== undefined) {
-            this.media.muted = initialVolume <= 0;
+            this.activeSurface.muted = initialVolume <= 0;
             this._muted = initialVolume <= 0;
         }
         else {
-            this._muted = this.media.muted;
+            this._muted = this.activeSurface.muted;
         }
-        this.media.playbackRate = this.config.startPlaybackRate || this.media.playbackRate;
-        this._playbackRate = this.config.startPlaybackRate || this.media.playbackRate;
+        this.activeSurface.playbackRate = this.config.startPlaybackRate || this.activeSurface.playbackRate;
+        this._playbackRate = this.config.startPlaybackRate || this.activeSurface.playbackRate;
         (this.config.plugins || []).forEach((p) => this.registerPlugin(p));
         this.bindStateTransitions();
-        this.bindMediaSync();
+        this.bindSurfaceSync();
         this.bindLeaseSync();
         this.bindFirstInteraction();
         queueMicrotask(() => this.maybeAutoLoad());
     }
+    get surface() {
+        return this.activeSurface;
+    }
     on(event, cb) {
         // Keep the surface flexible (plugins may emit custom events).
         return this.events.on(event, cb);
@@ -739,13 +873,7 @@ class Core {
         const sources = this.detectedSources ?? this.readMediaSources(this.media);
         this.detectedSources = sources;
         const { engine, source: activeSource } = this.resolveMediaEngine(sources);
-        this.playerContext = {
-            media: this.media,
-            events: this.events,
-            config: this.config,
-            activeSource,
-            core: this,
-        };
+        this.playerContext = this.createPlayerContext(activeSource);
         this.activeEngine?.detach?.(this.playerContext);
         this.activeEngine = engine;
         this.emit('loadstart');
@@ -1008,35 +1136,32 @@ class Core {
             }
         });
     }
-    bindMediaSync() {
+    bindSurfaceSync() {
         const read = () => {
-            // time + duration
             try {
-                this._currentTime = this.media.currentTime || 0;
+                this._currentTime = this.activeSurface.currentTime || 0;
             }
             catch {
                 // ignore
             }
             try {
-                const d = this.media.duration;
+                const d = this.config.duration || this.activeSurface.duration;
                 this._duration = d;
             }
             catch {
                 // ignore
             }
-            // volume + mute
             try {
-                this._muted = Boolean(this.media.muted);
-                const v = this.media.volume;
+                this._muted = Boolean(this.activeSurface.muted);
+                const v = this.activeSurface.volume;
                 if (Number.isFinite(v))
                     this._volume = v;
             }
             catch {
                 // ignore
             }
-            // rate
             try {
-                const r = this.media.playbackRate;
+                const r = this.activeSurface.playbackRate;
                 if (Number.isFinite(r))
                     this._playbackRate = r;
             }
@@ -1050,6 +1175,33 @@ class Core {
         this.events.on('volumechange', () => read());
         this.events.on('ratechange', () => read());
     }
+    createPlayerContext(activeSource) {
+        const ctx = {
+            media: this.media,
+            container: (this.media.parentElement ?? this.media),
+            events: this.events,
+            config: this.config,
+            activeSource,
+            core: this,
+            surface: this.activeSurface, // overridden below with a live getter
+            setSurface: (surface) => {
+                this.activeSurface = surface;
+                return this.activeSurface;
+            },
+            resetSurface: () => {
+                this.activeSurface = this.nativeSurface;
+                return this.nativeSurface;
+            },
+        };
+        // Replace the snapshot with a live getter so ctx.surface always reflects the
+        // current active surface even after setSurface() is called (e.g. by an iframe engine).
+        Object.defineProperty(ctx, 'surface', {
+            get: () => this.activeSurface,
+            enumerable: true,
+            configurable: true,
+        });
+        return ctx;
+    }
     bindLeaseSync() {
         this.leases.onChange((cap) => {
             if (cap !== 'playback')
@@ -1237,5 +1389,306 @@ function getOverlayManager(player) {
     return mgr;
 }
 
-export { BaseMediaEngine, Core, DVR_THRESHOLD, DefaultMediaEngine, DisposableStore, EVENT_OPTIONS, EventBus, Lease, PluginRegistry, StateManager, formatTime, generateISODateTime, getOverlayManager, isAudio, isMobile, offset };
+// ─── IframeMediaSurface ───────────────────────────────────────────────────────
+/**
+ * A normalized MediaSurface backed by an IframeMediaAdapter.
+ *
+ * Usage inside an engine's attach():
+ *   const surface = new IframeMediaSurface(adapter, { pollIntervalMs: 250 });
+ *   ctx.setSurface(surface);
+ *   this.bindSurfaceEvents(surface, ctx.events);  // wires internal bus → EventBus
+ *   this.bindCommands(ctx);
+ *   surface.mount(ctx.container);
+ */
+class IframeMediaSurface {
+    constructor(adapter, options = {}) {
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'iframe'
+        });
+        Object.defineProperty(this, "element", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentSrc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "internalBus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new EventBus()
+        });
+        Object.defineProperty(this, "adapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pollIntervalMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pollTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Normalized state — updated by adapter events and polling
+        Object.defineProperty(this, "_paused", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "_ended", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: NaN
+        });
+        Object.defineProperty(this, "_currentTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "_volume", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "_muted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_playbackRate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        this.adapter = adapter;
+        this.pollIntervalMs = options.pollIntervalMs ?? 250;
+        this.onAdapterReady = this.onAdapterReady.bind(this);
+        this.onAdapterState = this.onAdapterState.bind(this);
+        this.onAdapterError = this.onAdapterError.bind(this);
+        this.adapter.on('ready', this.onAdapterReady);
+        this.adapter.on('state', this.onAdapterState);
+        this.adapter.on('error', this.onAdapterError);
+        // Wire optional push events
+        this.adapter.on('timeupdate', ((t) => this.applyTime(t)));
+        this.adapter.on('durationchange', ((d) => this.applyDuration(d)));
+        this.adapter.on('ratechange', ((r) => this.applyRate(r)));
+        this.adapter.on('volumechange', ((v, m) => this.applyVolume(v, m)));
+        this.adapter.on('ended', (() => this.applyEnded()));
+    }
+    // ─── MediaSurface properties (getter + setter adjacent) ──────────────────
+    get currentTime() {
+        return this._currentTime;
+    }
+    set currentTime(value) {
+        this._currentTime = value;
+        this.internalBus.emit('seeking');
+        void Promise.resolve(this.adapter.seekTo(value)).then(() => {
+            this.internalBus.emit('seeked');
+        });
+    }
+    get duration() {
+        return this._duration;
+    }
+    set duration(_value) {
+    }
+    get volume() {
+        return this._volume;
+    }
+    set volume(value) {
+        const clamped = Math.min(1, Math.max(0, value));
+        this.adapter.setVolume(clamped);
+        this.applyVolume(clamped, this._muted);
+    }
+    get muted() {
+        return this._muted;
+    }
+    set muted(value) {
+        if (value)
+            this.adapter.mute();
+        else
+            this.adapter.unmute();
+        this.applyVolume(this._volume, value);
+    }
+    get playbackRate() {
+        return this._playbackRate;
+    }
+    set playbackRate(value) {
+        this.adapter.setPlaybackRate(value);
+        this.applyRate(value);
+    }
+    get paused() {
+        return this._paused;
+    }
+    get ended() {
+        return this._ended;
+    }
+    // ─── MediaSurface methods ─────────────────────────────────────────────────
+    load(_source) {
+        // No-op: iframe surfaces are initialized with a fixed source at construction time.
+    }
+    play() {
+        return Promise.resolve(this.adapter.play()).then(() => undefined);
+    }
+    pause() {
+        void Promise.resolve(this.adapter.pause());
+    }
+    /**
+     * Subscribe to surface events — satisfies MediaSurface.on() and is used by
+     * bridgeSurfaceEvents / BaseMediaEngine.bindSurfaceEvents to forward events
+     * onto the shared EventBus.
+     */
+    on(event, handler, _options) {
+        return this.internalBus.on(event, handler);
+    }
+    // ─── Extra lifecycle (beyond MediaSurface contract) ───────────────────────
+    /** Mount the adapter iframe into a DOM container. Resolves once the adapter is ready. */
+    async mount(container) {
+        await this.adapter.mount(container);
+        // Polling starts in onAdapterReady() after the player signals it is initialized.
+    }
+    destroy() {
+        this.stopPolling();
+        this.adapter.off('ready', this.onAdapterReady);
+        this.adapter.off('state', this.onAdapterState);
+        this.adapter.off('error', this.onAdapterError);
+        this.adapter.destroy();
+        this.internalBus.clear();
+    }
+    // ─── Adapter → internal bus ───────────────────────────────────────────────
+    onAdapterReady() {
+        this.applyDuration(this.safeNum(this.adapter.getDuration()));
+        this.applyTime(this.safeNum(this.adapter.getCurrentTime()));
+        if (this.adapter.getVolume)
+            this.applyVolume(this.safeNum(this.adapter.getVolume()), this._muted);
+        if (this.adapter.isMuted)
+            this.applyVolume(this._volume, !!this.adapter.isMuted());
+        if (this.adapter.getPlaybackRate)
+            this.applyRate(this.safeNum(this.adapter.getPlaybackRate()));
+        if (this.adapter.getElement) {
+            this.element = this.adapter.getElement();
+        }
+        this.startPolling();
+        this.internalBus.emit('loadedmetadata');
+    }
+    onAdapterState(s) {
+        switch (s) {
+            case 'loading':
+            case 'buffering':
+                this.internalBus.emit('waiting');
+                break;
+            case 'playing':
+                this._paused = false;
+                this._ended = false;
+                this.internalBus.emit('play');
+                this.internalBus.emit('playing');
+                break;
+            case 'paused':
+                this._paused = true;
+                this.internalBus.emit('pause');
+                break;
+            case 'ended':
+                this._paused = true;
+                this._ended = true;
+                this.internalBus.emit('ended');
+                break;
+        }
+    }
+    onAdapterError(err) {
+        this.internalBus.emit('error', err);
+    }
+    applyTime(t) {
+        if (!Number.isFinite(t))
+            return;
+        this._currentTime = t;
+        this.internalBus.emit('timeupdate');
+    }
+    applyDuration(d) {
+        if (!Number.isFinite(d) || d <= 0)
+            return;
+        this._duration = d;
+        this.internalBus.emit('durationchange');
+    }
+    applyRate(r) {
+        if (!Number.isFinite(r) || r <= 0)
+            return;
+        this._playbackRate = r;
+        this.internalBus.emit('ratechange');
+    }
+    applyVolume(v, muted) {
+        if (!Number.isFinite(v))
+            return;
+        this._volume = Math.min(1, Math.max(0, v));
+        this._muted = !!muted;
+        this.internalBus.emit('volumechange');
+    }
+    applyEnded() {
+        this._ended = true;
+        this._paused = true;
+        this.internalBus.emit('ended');
+    }
+    // ─── Polling ──────────────────────────────────────────────────────────────
+    startPolling() {
+        if (this.pollTimer != null)
+            return;
+        const tick = () => {
+            this.applyTime(this.safeNum(this.adapter.getCurrentTime()));
+            this.applyDuration(this.safeNum(this.adapter.getDuration()));
+            if (this.adapter.getVolume)
+                this.applyVolume(this.safeNum(this.adapter.getVolume()), this._muted);
+            if (this.adapter.isMuted)
+                this.applyVolume(this._volume, !!this.adapter.isMuted());
+            if (this.adapter.getPlaybackRate)
+                this.applyRate(this.safeNum(this.adapter.getPlaybackRate()));
+            this.pollTimer = window.setTimeout(tick, this.pollIntervalMs);
+        };
+        this.pollTimer = window.setTimeout(tick, this.pollIntervalMs);
+    }
+    stopPolling() {
+        if (this.pollTimer != null) {
+            window.clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    safeNum(n) {
+        const v = Number(n);
+        return Number.isFinite(v) ? v : NaN;
+    }
+}
+
+const CAPTION_KEY = Symbol.for('openplayerjs.caption.provider');
+function getCaptionTrackProvider(core) {
+    return core[CAPTION_KEY] ?? null;
+}
+function setCaptionTrackProvider(core, provider) {
+    core[CAPTION_KEY] = provider;
+}
+
+export { BaseMediaEngine, Core, DVR_THRESHOLD, DefaultMediaEngine, DisposableStore, EVENT_OPTIONS, EventBus, HtmlMediaSurface, IframeMediaSurface, Lease, PluginRegistry, StateManager, formatTime, generateISODateTime, getCaptionTrackProvider, getOverlayManager, isAudio, isMobile, offset, setCaptionTrackProvider };
 //# sourceMappingURL=index.js.map