@openplayerjs/core 3.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1241 @@
+const DVR_THRESHOLD = 120;
+const EVENT_OPTIONS = { passive: false };
+
+class BaseMediaEngine {
+    constructor() {
+        Object.defineProperty(this, "media", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "events", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "commands", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "mediaListeners", {
+            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;
+        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);
+    }
+    unbindMediaEvents() {
+        if (!this.media)
+            return;
+        for (const l of this.mediaListeners) {
+            this.media.removeEventListener(l.type, l.handler, l.options);
+        }
+        this.mediaListeners = [];
+    }
+    addMediaListener(media, type, handler, options) {
+        media.addEventListener(type, handler, options);
+        this.mediaListeners.push({ type, 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;
+        this.commands.push(events.on('cmd:seek', (t) => {
+            if (!this.canHandlePlayback(ctx))
+                return;
+            try {
+                media.currentTime = t;
+            }
+            catch {
+                // ignore
+            }
+        }));
+        this.commands.push(events.on('cmd:setVolume', (v) => {
+            media.volume = v;
+        }));
+        this.commands.push(events.on('cmd:setMuted', (m) => {
+            media.muted = m;
+        }));
+        this.commands.push(events.on('cmd:setRate', (r) => {
+            if (!this.canHandlePlayback(ctx))
+                return;
+            media.playbackRate = r;
+        }));
+        this.bindPlayPauseCommands(ctx);
+    }
+    unbindCommands() {
+        for (const off of this.commands)
+            off();
+        this.commands = [];
+    }
+    bindPlayPauseCommands(ctx) {
+        const { media, events } = ctx;
+        this.commands.push(events.on('cmd:play', () => {
+            if (!this.canHandlePlayback(ctx))
+                return;
+            this.playImpl(media);
+        }));
+        this.commands.push(events.on('cmd:pause', () => {
+            if (!this.canHandlePlayback(ctx))
+                return;
+            this.pauseImpl(media);
+        }));
+    }
+    playImpl(media) {
+        void media.play().catch(() => {
+            // ignore
+        });
+    }
+    pauseImpl(media) {
+        media.pause();
+    }
+}
+
+class DefaultMediaEngine extends BaseMediaEngine {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'default-engine'
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: '1.0.0'
+        });
+        Object.defineProperty(this, "capabilities", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['media-engine']
+        });
+        Object.defineProperty(this, "priority", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    canPlay(source) {
+        const media = document.createElement('video');
+        return media.canPlayType(source.type || '') !== '';
+    }
+    attach(ctx) {
+        if (ctx.activeSource?.src && ctx.media.src !== ctx.activeSource.src) {
+            ctx.media.src = ctx.activeSource.src;
+        }
+        try {
+            ctx.media.load();
+        }
+        catch {
+            // ignore
+        }
+        this.bindMediaEvents(ctx.media, 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;
+            if (ctx.media.preload !== 'none')
+                return;
+            ctx.media.preload = 'metadata';
+            try {
+                ctx.media.load();
+            }
+            catch {
+                // ignore
+            }
+        }));
+    }
+    detach() {
+        this.unbindCommands();
+        this.unbindMediaEvents();
+    }
+}
+
+const defaultConfiguration = {
+    startTime: 0,
+    duration: 0,
+};
+
+class DisposableStore {
+    constructor() {
+        Object.defineProperty(this, "disposers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "disposed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    get isDisposed() {
+        return this.disposed;
+    }
+    add(disposer) {
+        const d = (disposer ?? (() => { }));
+        if (this.disposed) {
+            try {
+                d();
+            }
+            catch {
+                // best-effort cleanup
+            }
+            return () => { };
+        }
+        this.disposers.push(d);
+        return d;
+    }
+    addEventListener(target, type, handler, options) {
+        target.addEventListener(type, handler, options);
+        return this.add(() => target.removeEventListener(type, handler, options));
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (let i = this.disposers.length - 1; i >= 0; i--) {
+            try {
+                this.disposers[i]();
+            }
+            catch {
+                // best-effort cleanup
+            }
+        }
+        this.disposers = [];
+    }
+}
+
+class EventBus {
+    constructor() {
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    on(event, cb) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(cb);
+        return () => this.listeners.get(event).delete(cb);
+    }
+    emit(event, payload) {
+        this.listeners.get(event)?.forEach((cb) => cb(payload));
+    }
+    listenerCount(event) {
+        return this.listeners.get(event)?.size ?? 0;
+    }
+    clear() {
+        this.listeners.clear();
+    }
+}
+
+class Lease {
+    constructor() {
+        Object.defineProperty(this, "owners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    onChange(cb) {
+        this.listeners.push(cb);
+        return () => {
+            this.listeners = this.listeners.filter((x) => x !== cb);
+        };
+    }
+    notify(capability) {
+        const owner = this.owners.get(capability);
+        for (const cb of this.listeners) {
+            try {
+                cb(capability, owner);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    acquire(capability, owner) {
+        if (this.owners.has(capability))
+            return false;
+        this.owners.set(capability, owner);
+        this.notify(capability);
+        return true;
+    }
+    release(capability, owner) {
+        if (this.owners.get(capability) === owner) {
+            this.owners.delete(capability);
+            this.notify(capability);
+        }
+    }
+    owner(capability) {
+        return this.owners.get(capability);
+    }
+}
+
+class PluginRegistry {
+    constructor() {
+        Object.defineProperty(this, "plugins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    register(plugin) {
+        this.plugins.push(plugin);
+    }
+    all() {
+        return this.plugins;
+    }
+}
+
+class StateManager {
+    constructor(state) {
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+    }
+    get current() {
+        return this.state;
+    }
+    transition(next) {
+        this.state = next;
+    }
+}
+
+function formatTime(seconds, frameRate) {
+    const f = Math.floor((seconds % 1) * (frameRate || 0));
+    let s = Math.floor(seconds);
+    let m = Math.floor(s / 60);
+    const h = Math.floor(m / 60);
+    const wrap = (value) => {
+        const formattedVal = value.toString();
+        if (value < 10) {
+            if (value <= 0) {
+                return '00';
+            }
+            return `0${formattedVal}`;
+        }
+        return formattedVal;
+    };
+    m %= 60;
+    s %= 60;
+    return `${h > 0 ? `${wrap(h)}:` : ''}${wrap(m)}:${wrap(s)}${f ? `:${wrap(f)}` : ''}`;
+}
+const generateISODateTime = (d) => {
+    const duration = Number.isFinite(d) ? Math.max(0, d) : 0;
+    const totalSeconds = Math.floor(duration);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    return `PT${hours ? `${hours}H` : ''}${minutes ? `${minutes}M` : ''}${seconds}S`;
+};
+function offset(el) {
+    const rect = el.getBoundingClientRect();
+    return {
+        left: rect.left + (window.pageXOffset || document.documentElement.scrollLeft),
+        top: rect.top + (window.pageYOffset || document.documentElement.scrollTop),
+    };
+}
+function isAudio(element) {
+    return element instanceof HTMLAudioElement;
+}
+function isMobile() {
+    return ((/ipad|iphone|ipod/i.test(window.navigator.userAgent) && !window.MSStream) ||
+        /android/i.test(window.navigator.userAgent));
+}
+function predictMimeType(media, url) {
+    const fragments = new URL(url).pathname.split('.');
+    const extension = fragments.length > 1 ? fragments.pop().toLowerCase() : '';
+    // If no extension found, check if media is a vendor iframe
+    if (!extension)
+        return isAudio(media) ? 'audio/mp3' : 'video/mp4';
+    // Check native media types
+    switch (extension) {
+        case 'm3u8':
+        case 'm3u':
+            return 'application/x-mpegURL';
+        case 'mpd':
+            return 'application/dash+xml';
+        case 'mp4':
+            return isAudio(media) ? 'audio/mp4' : 'video/mp4';
+        case 'mp3':
+            return 'audio/mp3';
+        case 'webm':
+            return isAudio(media) ? 'audio/webm' : 'video/webm';
+        case 'ogg':
+            return isAudio(media) ? 'audio/ogg' : 'video/ogg';
+        case 'ogv':
+            return 'video/ogg';
+        case 'oga':
+            return 'audio/ogg';
+        case '3gp':
+            return 'audio/3gpp';
+        case 'wav':
+            return 'audio/wav';
+        case 'aac':
+            return 'audio/aac';
+        case 'flac':
+            return 'audio/flac';
+        default:
+            return isAudio(media) ? 'audio/mp3' : 'video/mp4';
+    }
+}
+
+const clamp01 = (n) => Math.min(1, Math.max(0, n));
+class Core {
+    constructor(media, config = {}) {
+        Object.defineProperty(this, "media", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isLive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "events", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new EventBus()
+        });
+        Object.defineProperty(this, "leases", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Lease()
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new StateManager('idle')
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "userInteracted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "canAutoplay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "canAutoplayMuted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "interactionUnsubs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "plugins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new PluginRegistry()
+        });
+        Object.defineProperty(this, "pluginDisposables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakMap()
+        });
+        Object.defineProperty(this, "_src", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_volume", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "_playbackRate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "_currentTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "_muted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "detectedSources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "activeEngine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "playerContext", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "autoplaySupport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autoplaySupportPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "readyPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "readyResolve", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "readyReject", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "playRequestPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (typeof media === 'string') {
+            const el = document.querySelector(media);
+            if (!el || !(el instanceof HTMLMediaElement)) {
+                throw new Error(`OpenPlayer: could not find media element for selector: ${media}`);
+            }
+            this.media = el;
+        }
+        else {
+            this.media = media;
+        }
+        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._volume = initialVolume;
+        if (this.config.startVolume !== undefined) {
+            this.media.muted = initialVolume <= 0;
+            this._muted = initialVolume <= 0;
+        }
+        else {
+            this._muted = this.media.muted;
+        }
+        this.media.playbackRate = this.config.startPlaybackRate || this.media.playbackRate;
+        this._playbackRate = this.config.startPlaybackRate || this.media.playbackRate;
+        (this.config.plugins || []).forEach((p) => this.registerPlugin(p));
+        this.bindStateTransitions();
+        this.bindMediaSync();
+        this.bindLeaseSync();
+        this.bindFirstInteraction();
+        queueMicrotask(() => this.maybeAutoLoad());
+    }
+    on(event, cb) {
+        // Keep the surface flexible (plugins may emit custom events).
+        return this.events.on(event, cb);
+    }
+    emit(event, payload) {
+        this.events.emit(event, payload);
+        this.plugins
+            .all()
+            .filter((p) => !p.capabilities?.includes('media-engine'))
+            .forEach((p) => {
+            p.onEvent?.(event, payload);
+        });
+    }
+    registerPlugin(plugin) {
+        this.plugins.register(plugin);
+        const dispose = new DisposableStore();
+        this.pluginDisposables.set(plugin, dispose);
+        plugin.setup?.({
+            core: this,
+            media: this.media,
+            events: this.events,
+            state: this.state,
+            leases: this.leases,
+            dispose,
+            add: (d) => dispose.add(d ?? undefined),
+            on: (event, cb) => dispose.add(this.events.on(event, cb)),
+            listen: (target, type, handler, options) => dispose.addEventListener(target, type, handler, options),
+        });
+    }
+    set src(value) {
+        this._src = value;
+        if (value) {
+            this.detectedSources = [{ src: value, type: predictMimeType(this.media, value) }];
+            this.emit('source:set', value);
+            // Tear down any active engine so that load() can re-initialise cleanly
+            // with the new source, even when the player is already in a non-idle state.
+            if (this.playerContext) {
+                this.activeEngine?.detach?.(this.playerContext);
+                this.activeEngine = undefined;
+                this.playerContext = null;
+            }
+            this.state.transition('idle');
+            this.readyPromise = undefined;
+            this.readyResolve = undefined;
+            this.readyReject = undefined;
+            this.playRequestPromise = undefined;
+            queueMicrotask(() => this.load());
+        }
+    }
+    get src() {
+        return this._src;
+    }
+    get volume() {
+        return this._volume;
+    }
+    set volume(v) {
+        const next = clamp01(v);
+        this._volume = next;
+        this.emit('cmd:setVolume', next);
+    }
+    get muted() {
+        return this._muted;
+    }
+    set muted(muted) {
+        this._muted = muted;
+        this.emit('cmd:setMuted', muted);
+    }
+    set playbackRate(rate) {
+        this._playbackRate = rate;
+        this.emit('cmd:setRate', rate);
+    }
+    get playbackRate() {
+        return this._playbackRate;
+    }
+    set currentTime(time) {
+        this._currentTime = time;
+        this.emit('cmd:seek', time);
+    }
+    get currentTime() {
+        return this._currentTime;
+    }
+    get duration() {
+        return this._duration;
+    }
+    load() {
+        if (this.state.current !== 'idle')
+            return;
+        this.emit('cmd:startLoad');
+        this.createReadyPromise();
+        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.activeEngine?.detach?.(this.playerContext);
+        this.activeEngine = engine;
+        this.emit('loadstart');
+        this.emit('cmd:load');
+        this.activeEngine.attach(this.playerContext);
+        this.emit('cmd:setVolume', this._volume);
+        this.emit('cmd:setMuted', this._muted);
+        this.emit('cmd:setRate', this._playbackRate);
+        if (this._currentTime)
+            this.emit('cmd:seek', this._currentTime);
+    }
+    async whenReady() {
+        if (this.state.current === 'ready' ||
+            this.state.current === 'playing' ||
+            this.state.current === 'paused' ||
+            this.state.current === 'waiting' ||
+            this.state.current === 'seeking' ||
+            this.state.current === 'ended') {
+            return;
+        }
+        if (!this.activeEngine)
+            this.load();
+        this.createReadyPromise();
+        return this.readyPromise ?? Promise.resolve();
+    }
+    async play() {
+        if (this.playRequestPromise)
+            return this.playRequestPromise;
+        if (!this.activeEngine)
+            this.load();
+        // Emit cmd:play synchronously while the user-gesture task is still active.
+        // Browsers (especially Safari) require media.play() to be called in the same
+        // microtask/task as the user interaction; any await before this would cause
+        // the autoplay policy to reject the play() call on unmuted media.
+        this.emit('cmd:play');
+        // Await readiness for state-machine consistency (does not re-emit cmd:play).
+        this.playRequestPromise = this.whenReady().finally(() => {
+            this.playRequestPromise = undefined;
+        });
+        return this.playRequestPromise;
+    }
+    async determineAutoplaySupport() {
+        if (this.autoplaySupport)
+            return this.autoplaySupport;
+        if (this.autoplaySupportPromise)
+            return this.autoplaySupportPromise;
+        // Gate on readiness, but don't fail detection if readiness never arrives.
+        await this.whenReady().catch(() => { });
+        const media = this.media;
+        const defaultVol = media.volume;
+        const defaultMuted = media.muted;
+        const restore = () => {
+            try {
+                media.volume = defaultVol;
+            }
+            catch {
+                // ignore
+            }
+            try {
+                media.muted = defaultMuted;
+            }
+            catch {
+                // ignore
+            }
+            // Keep Player state consistent with the underlying element.
+            this._volume = defaultVol;
+            this._muted = defaultMuted;
+        };
+        this.autoplaySupportPromise = (async () => {
+            try {
+                // Attempt unmuted autoplay first.
+                try {
+                    const playPromise = media.play();
+                    if (playPromise !== undefined)
+                        await playPromise;
+                    try {
+                        media.pause();
+                    }
+                    catch {
+                        // ignore
+                    }
+                    this.canAutoplay = true;
+                    this.canAutoplayMuted = false;
+                    return { autoplay: true, muted: false };
+                }
+                catch {
+                    // Unmuted autoplay failed; retry muted autoplay.
+                    try {
+                        media.volume = 0;
+                        media.muted = true;
+                        this._volume = 0;
+                        this._muted = true;
+                    }
+                    catch {
+                        // ignore
+                    }
+                    try {
+                        const playPromiseMuted = media.play();
+                        if (playPromiseMuted !== undefined)
+                            await playPromiseMuted;
+                        try {
+                            media.pause();
+                        }
+                        catch {
+                            // ignore
+                        }
+                        this.canAutoplay = true;
+                        this.canAutoplayMuted = true;
+                        return { autoplay: true, muted: true };
+                    }
+                    catch {
+                        // Autoplay is blocked even when muted.
+                        this.canAutoplay = false;
+                        this.canAutoplayMuted = false;
+                        return { autoplay: false, muted: false };
+                    }
+                }
+            }
+            finally {
+                restore();
+            }
+        })();
+        this.autoplaySupport = await this.autoplaySupportPromise;
+        return this.autoplaySupportPromise;
+    }
+    pause() {
+        if (this.state.current === 'idle' || this.state.current === 'loading') {
+            return;
+        }
+        this.emit('cmd:pause');
+    }
+    destroy() {
+        this.events.emit('player:destroy');
+        if (this.playerContext)
+            this.activeEngine?.detach?.(this.playerContext);
+        this.playerContext = null;
+        this.plugins.all().forEach((p) => {
+            // Always dispose tracked resources first.
+            try {
+                this.pluginDisposables.get(p)?.dispose();
+            }
+            catch {
+                // ignore
+            }
+            try {
+                p.destroy?.();
+            }
+            catch {
+                // ignore
+            }
+        });
+        this.interactionUnsubs.forEach((u) => u());
+        this.interactionUnsubs = [];
+        this.events.clear();
+    }
+    addCaptions(args) {
+        const track = document.createElement('track');
+        track.kind = args.kind || 'captions';
+        track.src = args.src;
+        if (args.srclang)
+            track.srclang = args.srclang;
+        if (args.label)
+            track.label = args.label;
+        if (args.default)
+            track.default = true;
+        this.media.appendChild(track);
+        this.emit('texttrack:add', track);
+        this.emit('texttrack:listchange');
+        return track;
+    }
+    getPlugin(name) {
+        return this.plugins.all().find((p) => p?.name === name);
+    }
+    extend(extension) {
+        if (!extension || typeof extension !== 'object')
+            return this;
+        for (const key of Object.keys(extension)) {
+            if (this[key] === undefined) {
+                this[key] = extension[key];
+            }
+            else if (this[key] &&
+                typeof this[key] === 'object' &&
+                extension[key] &&
+                typeof extension[key] === 'object') {
+                const target = this[key];
+                const source = extension[key];
+                for (const k of Object.keys(source)) {
+                    if (target[k] === undefined)
+                        target[k] = source[k];
+                }
+            }
+        }
+        return this;
+    }
+    bindFirstInteraction() {
+        const doc = typeof document !== 'undefined' ? document : null;
+        if (!doc)
+            return;
+        const mark = () => {
+            if (this.userInteracted)
+                return;
+            this.userInteracted = true;
+            this.emit('player:interacted');
+            this.interactionUnsubs.forEach((u) => u());
+            this.interactionUnsubs = [];
+        };
+        const opts = { capture: true, passive: true };
+        const removeOpts = { capture: true };
+        const on = (type) => {
+            doc.addEventListener(type, mark, opts);
+            this.interactionUnsubs.push(() => doc.removeEventListener(type, mark, removeOpts));
+        };
+        on('pointerdown');
+        on('mousedown');
+        on('touchstart');
+        on('keydown');
+    }
+    resolveMediaEngine(sources) {
+        if (sources.length === 0)
+            throw new Error('Player cannot resolve media with an empty source');
+        const engines = this.plugins
+            .all()
+            .filter((p) => !!(!!p && p.capabilities?.includes('media-engine') && typeof p.canPlay === 'function'));
+        // Don't mutate registry order.
+        const sortedEngines = [...engines].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0) || a.name.localeCompare(b.name));
+        for (const source of sources) {
+            for (const engine of sortedEngines) {
+                if (engine.canPlay?.(source)) {
+                    return { engine, source };
+                }
+            }
+        }
+        throw new Error('No compatible media engine found');
+    }
+    bindStateTransitions() {
+        // Load lifecycle
+        this.events.on('loadstart', () => this.state.transition('loading'));
+        // Resolve "ready" when metadata is available (closest HTML5 analogue to previous playback:ready).
+        this.events.on('loadedmetadata', () => {
+            this.state.transition('ready');
+            if (this.readyResolve) {
+                this.readyResolve();
+                this.readyResolve = undefined;
+                this.readyReject = undefined;
+            }
+        });
+        // IMPORTANT: state transitions only on observed playback events (not on commands).
+        this.events.on('playing', () => this.state.transition('playing'));
+        this.events.on('pause', () => this.state.transition('paused'));
+        this.events.on('waiting', () => this.state.transition('waiting'));
+        this.events.on('seeking', () => this.state.transition('seeking'));
+        this.events.on('seeked', () => this.state.transition('ready'));
+        this.events.on('ended', () => this.state.transition('ended'));
+        this.events.on('error', (e) => {
+            this.state.transition('error');
+            if (this.readyReject) {
+                this.readyReject(e);
+                this.readyResolve = undefined;
+                this.readyReject = undefined;
+            }
+        });
+    }
+    bindMediaSync() {
+        const read = () => {
+            // time + duration
+            try {
+                this._currentTime = this.media.currentTime || 0;
+            }
+            catch {
+                // ignore
+            }
+            try {
+                const d = this.media.duration;
+                this._duration = d;
+            }
+            catch {
+                // ignore
+            }
+            // volume + mute
+            try {
+                this._muted = Boolean(this.media.muted);
+                const v = this.media.volume;
+                if (Number.isFinite(v))
+                    this._volume = v;
+            }
+            catch {
+                // ignore
+            }
+            // rate
+            try {
+                const r = this.media.playbackRate;
+                if (Number.isFinite(r))
+                    this._playbackRate = r;
+            }
+            catch {
+                // ignore
+            }
+        };
+        this.events.on('loadedmetadata', () => read());
+        this.events.on('durationchange', () => read());
+        this.events.on('timeupdate', () => read());
+        this.events.on('volumechange', () => read());
+        this.events.on('ratechange', () => read());
+    }
+    bindLeaseSync() {
+        this.leases.onChange((cap) => {
+            if (cap !== 'playback')
+                return;
+            queueMicrotask(() => {
+                this.emit('cmd:setVolume', this._volume);
+                this.emit('cmd:setMuted', this._muted);
+                this.emit('cmd:setRate', this._playbackRate);
+                if (this._currentTime)
+                    this.emit('cmd:seek', this._currentTime);
+            });
+        });
+    }
+    createReadyPromise() {
+        if (this.readyPromise)
+            return;
+        this.readyPromise = new Promise((resolve, reject) => {
+            this.readyResolve = resolve;
+            this.readyReject = reject;
+        });
+    }
+    readMediaSources(media) {
+        const sources = [];
+        if (media.src) {
+            sources.push({ src: media.src, type: predictMimeType(media, media.src) });
+        }
+        try {
+            media.querySelectorAll('source').forEach((el) => {
+                sources.push({ src: el.src, type: el.type || predictMimeType(media, el.src) });
+            });
+        }
+        catch {
+            // ignore
+        }
+        return sources;
+    }
+    maybeAutoLoad() {
+        if (this.state.current !== 'idle')
+            return;
+        const hasEngines = this.plugins.all().some((p) => p.capabilities?.includes('media-engine'));
+        if (!hasEngines)
+            return;
+        const sources = this.readMediaSources(this.media);
+        if (sources.length === 0)
+            return;
+        this.detectedSources = sources;
+        // Capture autoplay intent before we clear the src attribute.
+        const wantsAutoplay = this.media.autoplay;
+        try {
+            const sources = this.media.querySelectorAll('source');
+            sources.forEach((s) => s.remove());
+            if (this.media.getAttribute('src'))
+                this.media.removeAttribute('src');
+            if (this.media.src)
+                this.media.src = '';
+            this.load();
+            if (wantsAutoplay) {
+                // Programmatic media.load() above resets the element and causes some browsers
+                // (notably Chromium) not to re-trigger native autoplay after the src is restored.
+                // Disable the autoplay attribute to prevent a native-vs-plugin race, then
+                // propagate the play intent through Core's event system so plugins (e.g. AdsPlugin)
+                // can intercept the preroll before content begins.
+                this.media.autoplay = false;
+                queueMicrotask(() => this.emit('cmd:play'));
+            }
+        }
+        catch {
+            // best effort; don't block attach
+        }
+    }
+}
+
+class OverlayBus {
+    constructor(bus) {
+        Object.defineProperty(this, "bus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: bus
+        });
+    }
+    on(event, cb) {
+        return this.bus.on(event, cb);
+    }
+    emit(event, ...data) {
+        this.bus.emit(event, ...data);
+    }
+    clear() {
+        this.bus.clear();
+    }
+}
+const OVERLAY_MANAGER_KEY = '__op::overlay::manager';
+class OverlayManager {
+    constructor() {
+        Object.defineProperty(this, "bus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "active", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "overlays", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.bus = new OverlayBus(new EventBus());
+    }
+    dispose() {
+        this.overlays.clear();
+        this.active = null;
+        this.bus.clear();
+    }
+    activate(state) {
+        this.overlays.set(state.id, state);
+        this.recomputeAndEmit();
+    }
+    update(id, patch) {
+        const cur = this.overlays.get(id);
+        if (!cur)
+            return;
+        const next = { ...cur, ...patch, id: cur.id };
+        this.overlays.set(id, next);
+        this.recomputeAndEmit();
+    }
+    deactivate(id) {
+        const existed = this.overlays.delete(id);
+        if (!existed)
+            return;
+        this.recomputeAndEmit();
+    }
+    recomputeAndEmit() {
+        const next = this.pickActive();
+        this.active = next;
+        this.bus.emit('overlay:changed', this.active);
+    }
+    pickActive() {
+        let best = null;
+        for (const s of this.overlays.values()) {
+            if (!best || s.priority > best.priority)
+                best = s;
+        }
+        return best;
+    }
+}
+function getOverlayManager(player) {
+    if (player[OVERLAY_MANAGER_KEY])
+        return player[OVERLAY_MANAGER_KEY];
+    const mgr = new OverlayManager();
+    player[OVERLAY_MANAGER_KEY] = mgr;
+    try {
+        if (player?.events?.on && player?.events?.emit) {
+            const off = mgr.bus.on('overlay:changed', (active) => player.events.emit('overlay:changed', active));
+            player.events.on('player:destroy', () => {
+                try {
+                    off();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    mgr.dispose();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    delete player[OVERLAY_MANAGER_KEY];
+                }
+                catch {
+                    // ignore
+                }
+            });
+        }
+    }
+    catch {
+        // ignore
+    }
+    return mgr;
+}
+
+export { BaseMediaEngine, Core, DVR_THRESHOLD, DefaultMediaEngine, DisposableStore, EVENT_OPTIONS, EventBus, Lease, PluginRegistry, StateManager, formatTime, generateISODateTime, getOverlayManager, isAudio, isMobile, offset };
+//# sourceMappingURL=index.js.map