@edm-webplayer/webplayer-angular 0.1.30 → 0.1.32

package/fesm2022/edm-webplayer-webplayer-angular.mjs

@@ -78,10 +78,18 @@ class PlyrPlayerComponent {
     recommendationBlocker;
     recommendationBlockerActiveZone;
     topClickBlocker;
+    gestureOverlay;
     menuObserver;
     playbackEnded = false;
     overlayBlockAll = false;
-    onResize = () => this.updateRecommendationBlockerSafeZone();
+    endedPosterOverlay;
+    fullscreenCleanup;
+    interactionUnmuteCleanup;
+    pendingGesturePlay = false;
+    onResize = () => {
+        this.updateRecommendationBlockerSafeZone();
+        this.updateGestureOverlaySafeZone();
+    };
     onTopBlockerPointerDown = (event) => {
         try {
             event.preventDefault();
@@ -105,7 +113,8 @@ class PlyrPlayerComponent {
         }
         this.togglePlayback();
     };
-    controlsSafeZonePx = 96;
+    controlsSafeZonePxDesktop = 96;
+    controlsSafeZonePxTouch = 144;
     constructor(progressService, document) {
         this.progressService = progressService;
         this.document = document;
@@ -119,8 +128,9 @@ class PlyrPlayerComponent {
     getControlsSafeZone() {
         const controls = (this.plyr?.elements?.controls ?? null);
         const menuHeight = this.getOpenMenuHeight();
+        const baseSafeZone = this.isTouchDevice() ? this.controlsSafeZonePxTouch : this.controlsSafeZonePxDesktop;
         if (!controls) {
-            return Math.max(this.controlsSafeZonePx, menuHeight + 5);
+            return Math.max(baseSafeZone, menuHeight + 5);
         }
         let controlsHeight = 0;
         try {
@@ -133,7 +143,7 @@ class PlyrPlayerComponent {
         if (!controlsHeight) {
             controlsHeight = controls.offsetHeight || controls.clientHeight || 0;
         }
-        return Math.max(this.controlsSafeZonePx, Math.ceil(controlsHeight + menuHeight + 24));
+        return Math.max(baseSafeZone, Math.ceil(controlsHeight + menuHeight + 24));
     }
     getOverlaySafeZone() {
         const host = this.config?.video_host;
@@ -336,13 +346,12 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
         this.updateTopClickBlockerSafeZone();
     }
     updateRecommendationBlockerSafeZone() {
-        if (!this.recommendationBlockerActiveZone && !this.topClickBlocker)
-            return;
-        const safeZone = this.getOverlaySafeZone();
+        const overlaySafeZone = this.getOverlaySafeZone();
         if (this.recommendationBlockerActiveZone) {
-            this.recommendationBlockerActiveZone.style.bottom = `${safeZone}px`;
+            this.recommendationBlockerActiveZone.style.bottom = `${overlaySafeZone}px`;
         }
-        this.updateTopClickBlockerSafeZone(safeZone);
+        this.updateTopClickBlockerSafeZone(overlaySafeZone);
+        this.updateGestureOverlaySafeZone(this.getControlsSafeZone());
     }
     updateTopClickBlockerSafeZone(precomputed) {
         if (!this.topClickBlocker)
@@ -351,6 +360,13 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
         const safeZone = Math.max(0, safeZoneRaw);
         this.topClickBlocker.style.bottom = `${safeZone}px`;
     }
+    updateGestureOverlaySafeZone(precomputed) {
+        if (!this.gestureOverlay)
+            return;
+        const safeZoneRaw = typeof precomputed === 'number' ? precomputed : this.getControlsSafeZone();
+        const safeZone = Math.max(0, safeZoneRaw);
+        this.gestureOverlay.style.bottom = `${safeZone}px`;
+    }
     togglePlayback(force) {
         if (!this.plyr)
             return;
@@ -382,6 +398,7 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
             this.playbackEnded = false;
             this.overlayBlockAll = false;
             this.updateRecommendationBlockerSafeZone();
+            this.hideGestureOverlay();
             try {
                 const result = this.plyr.play?.();
                 if (result && typeof result.catch === 'function') {
@@ -443,6 +460,19 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
         });
         this.menuObserver = observer;
     }
+    isIOSDevice() {
+        if (typeof navigator === 'undefined')
+            return false;
+        const ua = navigator.userAgent || '';
+        const iOS = /iPad|iPhone|iPod/.test(ua);
+        const iPadOS = navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
+        return iOS || iPadOS;
+    }
+    isAndroidDevice() {
+        if (typeof navigator === 'undefined')
+            return false;
+        return /Android/i.test(navigator.userAgent || '');
+    }
     isTouchDevice() {
         if (typeof window === 'undefined') {
             return false;
@@ -460,6 +490,333 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
         }
         return 'ontouchstart' in window;
     }
+    isIframeProvider() {
+        return this.config?.video_host === 'youtube' || this.config?.video_host === 'vimeo';
+    }
+    shouldAutoplay() {
+        return !!(this.config?.autoplay || this.config?.is_live);
+    }
+    requiresMutedAutoplay() {
+        return this.isIOSDevice();
+    }
+    setPlayerMutedState(muted, volume = 1, target) {
+        if (this.plyr) {
+            try {
+                this.plyr.muted = muted;
+            }
+            catch { }
+            if (!muted) {
+                try {
+                    this.plyr.volume = volume;
+                }
+                catch { }
+            }
+        }
+        const media = target ?? this.videoRef?.nativeElement ?? null;
+        if (media) {
+            try {
+                media.muted = muted;
+            }
+            catch { }
+            if (!muted && typeof media.volume === 'number') {
+                try {
+                    media.volume = volume;
+                }
+                catch { }
+            }
+        }
+    }
+    clearAutoplayUnlockListener() {
+        if (this.interactionUnmuteCleanup) {
+            try {
+                this.interactionUnmuteCleanup();
+            }
+            catch { }
+            this.interactionUnmuteCleanup = undefined;
+        }
+    }
+    ensureAutoplayUnlockListener() {
+        if (typeof window === 'undefined' ||
+            this.interactionUnmuteCleanup ||
+            !this.shouldAutoplay()) {
+            return;
+        }
+        const capture = true;
+        const handler = () => {
+            this.setPlayerMutedState(false);
+            try {
+                this.plyr?.play();
+            }
+            catch { }
+            this.clearAutoplayUnlockListener();
+        };
+        window.addEventListener('touchend', handler, capture);
+        window.addEventListener('pointerup', handler, capture);
+        window.addEventListener('click', handler, capture);
+        this.interactionUnmuteCleanup = () => {
+            window.removeEventListener('touchend', handler, capture);
+            window.removeEventListener('pointerup', handler, capture);
+            window.removeEventListener('click', handler, capture);
+            this.interactionUnmuteCleanup = undefined;
+        };
+    }
+    scheduleUserInteractionUnmute(video) {
+        this.unmuteAfterDelay(video || undefined);
+        this.ensureAutoplayUnlockListener();
+    }
+    applyStartTimeToCurrentSource(start, opts = {}) {
+        if (!this.plyr || !(start > 0)) {
+            return;
+        }
+        const video = opts.video ?? this.videoRef?.nativeElement ?? null;
+        let attempts = Math.max(1, opts.attempts ?? 6);
+        const delayMs = opts.delayMs ?? 250;
+        const tolerance = 0.35;
+        const scheduleRetry = () => {
+            attempts -= 1;
+            if (attempts > 0) {
+                setTimeout(trySeek, delayMs);
+            }
+        };
+        const verifyAfterAttempt = () => {
+            const current = this.plyr?.currentTime || 0;
+            if (Math.abs(current - start) <= tolerance) {
+                attempts = 0;
+                return;
+            }
+            scheduleRetry();
+        };
+        const trySeek = () => {
+            if (!this.plyr)
+                return;
+            let maybePromise = null;
+            try {
+                const result = this.seekUsingHostAPI(start, video);
+                if (result && typeof result.then === 'function') {
+                    maybePromise = result;
+                }
+            }
+            catch {
+                scheduleRetry();
+                return;
+            }
+            if (maybePromise) {
+                maybePromise
+                    .then(() => verifyAfterAttempt())
+                    .catch(() => scheduleRetry());
+                return;
+            }
+            verifyAfterAttempt();
+        };
+        trySeek();
+    }
+    seekUsingHostAPI(target, video) {
+        if (!Number.isFinite(target) || target < 0) {
+            return null;
+        }
+        if (this.config.video_host === 'vimeo') {
+            const embed = this.plyr?.embed;
+            if (embed && typeof embed.setCurrentTime === 'function') {
+                try {
+                    return embed.setCurrentTime(target);
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        if (video) {
+            try {
+                video.currentTime = target;
+            }
+            catch { }
+        }
+        try {
+            this.plyr.currentTime = target;
+        }
+        catch { }
+        return null;
+    }
+    ensureGestureOverlay() {
+        if (this.gestureOverlay && this.gestureOverlay.isConnected) {
+            return this.gestureOverlay;
+        }
+        const wrapper = this.getVideoWrapper();
+        if (!wrapper) {
+            return null;
+        }
+        const overlay = this.document.createElement('button');
+        overlay.type = 'button';
+        overlay.className = 'plyr-gesture-overlay';
+        overlay.style.position = 'absolute';
+        overlay.style.top = '0';
+        overlay.style.left = '0';
+        overlay.style.right = '0';
+        overlay.style.bottom = '0';
+        overlay.style.width = '100%';
+        overlay.style.height = '100%';
+        overlay.style.display = 'none';
+        overlay.style.alignItems = 'center';
+        overlay.style.justifyContent = 'center';
+        overlay.style.padding = '0 16px';
+        overlay.style.background = 'rgba(0,0,0,0.35)';
+        overlay.style.backdropFilter = 'blur(1px)';
+        overlay.style.border = '0';
+        overlay.style.zIndex = '16';
+        overlay.style.color = 'var(--theme-text-color, #fff)';
+        overlay.style.fontSize = '14px';
+        overlay.style.fontWeight = '600';
+        overlay.style.textAlign = 'center';
+        overlay.style.cursor = 'pointer';
+        overlay.style.touchAction = 'manipulation';
+        overlay.style.pointerEvents = 'none';
+        overlay.textContent = 'Toque para reproduzir';
+        wrapper.appendChild(overlay);
+        this.gestureOverlay = overlay;
+        this.updateGestureOverlaySafeZone();
+        return overlay;
+    }
+    hideGestureOverlay() {
+        if (this.gestureOverlay) {
+            this.gestureOverlay.style.display = 'none';
+            this.gestureOverlay.style.pointerEvents = 'none';
+        }
+        this.pendingGesturePlay = false;
+    }
+    requestGestureToPlay(video) {
+        if (!this.isIframeProvider()) {
+            return;
+        }
+        if (this.pendingGesturePlay) {
+            return;
+        }
+        const overlay = this.ensureGestureOverlay();
+        if (!overlay) {
+            return;
+        }
+        this.pendingGesturePlay = true;
+        const media = video ?? this.videoRef?.nativeElement ?? null;
+        const onInteraction = (event) => {
+            try {
+                event.preventDefault();
+            }
+            catch { }
+            try {
+                event.stopPropagation();
+            }
+            catch { }
+            overlay.removeEventListener('click', onInteraction);
+            overlay.removeEventListener('touchend', onInteraction);
+            overlay.style.display = 'none';
+            this.pendingGesturePlay = false;
+            this.clearAutoplayUnlockListener();
+            this.setPlayerMutedState(this.requiresMutedAutoplay(), 1, media);
+            try {
+                const result = this.plyr?.play();
+                if (result && typeof result.catch === 'function') {
+                    result.catch(() => {
+                        this.requestGestureToPlay(media);
+                    });
+                }
+            }
+            catch {
+                this.requestGestureToPlay(media);
+            }
+        };
+        overlay.addEventListener('click', onInteraction, { once: true });
+        overlay.addEventListener('touchend', onInteraction, { once: true });
+        this.updateGestureOverlaySafeZone();
+        overlay.style.pointerEvents = 'auto';
+        overlay.style.display = 'flex';
+    }
+    shouldShowGestureOverlayForError(error) {
+        if (!this.isIframeProvider()) {
+            return false;
+        }
+        if (!error) {
+            return true;
+        }
+        const err = error;
+        const name = typeof err.name === 'string' ? err.name.toLowerCase() : '';
+        const message = typeof err.message === 'string' ? err.message.toLowerCase() : '';
+        if (!name && !message) {
+            return true;
+        }
+        return (name.includes('notallowed') ||
+            name.includes('notallowederror') ||
+            name.includes('gesture') ||
+            message.includes('gesture') ||
+            message.includes('user interaction') ||
+            message.includes('user activation') ||
+            message.includes('without user') ||
+            message.includes('play() failed'));
+    }
+    startAutoplayFlow(video) {
+        if (!this.shouldAutoplay() || !this.plyr)
+            return;
+        const media = video ?? this.videoRef?.nativeElement ?? null;
+        const tryPlay = (muted) => {
+            this.setPlayerMutedState(muted, 1, media);
+            let playResult;
+            try {
+                playResult = this.plyr.play();
+            }
+            catch (error) {
+                if (!muted) {
+                    tryPlay(true);
+                    return;
+                }
+                if (media) {
+                    try {
+                        const nativePlay = media.play();
+                        if (nativePlay && typeof nativePlay.catch === 'function') {
+                            nativePlay.catch(() => { });
+                        }
+                    }
+                    catch { }
+                }
+                this.scheduleUserInteractionUnmute(media);
+                if (this.shouldShowGestureOverlayForError(error)) {
+                    this.requestGestureToPlay(media);
+                }
+                return;
+            }
+            if (playResult && typeof playResult.catch === 'function') {
+                playResult.catch((error) => {
+                    if (!muted) {
+                        tryPlay(true);
+                        return;
+                    }
+                    if (media) {
+                        try {
+                            const nativePlay = media.play();
+                            if (nativePlay && typeof nativePlay.catch === 'function') {
+                                nativePlay.catch(() => { });
+                            }
+                        }
+                        catch { }
+                    }
+                    this.scheduleUserInteractionUnmute(media);
+                    if (this.shouldShowGestureOverlayForError(error)) {
+                        this.requestGestureToPlay(media);
+                    }
+                });
+                return;
+            }
+            if (muted) {
+                this.scheduleUserInteractionUnmute(media);
+            }
+            else {
+                this.clearAutoplayUnlockListener();
+            }
+        };
+        if (this.requiresMutedAutoplay()) {
+            tryPlay(true);
+        }
+        else {
+            tryPlay(false);
+        }
+    }
     setupControlsVisibility() {
         const container = this.plyr?.elements?.container;
         if (!container) {
@@ -570,19 +927,104 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
             container.classList.remove('plyr--auto-hide-controls');
         };
     }
+    bindFullscreenBehavior() {
+        this.fullscreenCleanup?.();
+        this.fullscreenCleanup = undefined;
+        if (!this.plyr)
+            return;
+        if (this.isIOSDevice() || !this.isAndroidDevice()) {
+            return;
+        }
+        if (typeof window === 'undefined' || typeof screen === 'undefined') {
+            return;
+        }
+        const orientation = screen.orientation;
+        const canLockOrientation = orientation && typeof orientation.lock === 'function' && typeof orientation.unlock === 'function';
+        if (!canLockOrientation) {
+            return;
+        }
+        const isPortrait = () => {
+            if (typeof window.matchMedia === 'function') {
+                try {
+                    return window.matchMedia('(orientation: portrait)').matches;
+                }
+                catch { }
+            }
+            return (window.innerHeight || 0) >= (window.innerWidth || 0);
+        };
+        let orientationLocked = false;
+        const lockLandscape = async () => {
+            if (!orientation)
+                return;
+            try {
+                await orientation.lock('landscape');
+                orientationLocked = true;
+            }
+            catch { }
+        };
+        const unlockOrientation = () => {
+            if (orientationLocked && orientation) {
+                try {
+                    orientation.unlock();
+                }
+                catch { }
+            }
+            orientationLocked = false;
+        };
+        const onEnterFullscreen = () => {
+            if (isPortrait()) {
+                lockLandscape();
+            }
+        };
+        const onExitFullscreen = () => {
+            unlockOrientation();
+        };
+        const onOrientationChange = () => {
+            if (!this.plyr?.fullscreen?.active) {
+                unlockOrientation();
+            }
+        };
+        this.plyr.on('enterfullscreen', onEnterFullscreen);
+        this.plyr.on('exitfullscreen', onExitFullscreen);
+        window.addEventListener('orientationchange', onOrientationChange);
+        this.fullscreenCleanup = () => {
+            unlockOrientation();
+            this.plyr?.off('enterfullscreen', onEnterFullscreen);
+            this.plyr?.off('exitfullscreen', onExitFullscreen);
+            window.removeEventListener('orientationchange', onOrientationChange);
+        };
+    }
     setupPlayer() {
         if (!this.videoRef)
             return;
         this.hls?.destroy();
         this.controlsVisibilityCleanup?.();
         this.controlsVisibilityCleanup = undefined;
+        this.fullscreenCleanup?.();
+        this.fullscreenCleanup = undefined;
         this.plyr?.destroy();
+        this.clearAutoplayUnlockListener();
+        this.hideGestureOverlay();
         this.recommendationBlocker = null;
         const speedOptions = [1, 1.25, 1.5, 2];
         const locale = this.resolveLocale();
         const captionsLanguage = this.resolveCaptionsLanguage(locale) ?? 'pt';
         const hideVimeoRecommendations = this.shouldHideVimeoRecommendations();
         const vimeoPremium = Boolean(this.config?.vimeo_premium);
+        const shouldAutoplay = this.shouldAutoplay();
+        const startMuted = this.requiresMutedAutoplay();
+        try {
+            this.videoRef.nativeElement.muted = startMuted;
+        }
+        catch { }
+        try {
+            this.videoRef.nativeElement.playsInline = true;
+        }
+        catch { }
+        try {
+            this.videoRef.nativeElement.autoplay = shouldAutoplay;
+        }
+        catch { }
         const vimeoOptions = {
             byline: false,
             portrait: false,
@@ -594,6 +1036,9 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
             quality: "auto",
             transparent: false,
         };
+        vimeoOptions.autoplay = shouldAutoplay;
+        vimeoOptions.muted = startMuted;
+        vimeoOptions.playsinline = true;
         if (hideVimeoRecommendations) {
             vimeoOptions.controls = false;
             vimeoOptions.sidedock = 0;
@@ -609,6 +1054,9 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
         youtubePlayerVars.playerVars = {
             hl: locale,
             cc_lang_pref: captionsLanguage || locale.split('-')[0]?.toLowerCase(),
+            autoplay: shouldAutoplay ? 1 : 0,
+            mute: startMuted ? 1 : 0,
+            playsinline: 1,
         };
         if (captionsLanguage) {
             youtubePlayerVars.playerVars.cc_load_policy = 1;
@@ -630,7 +1078,12 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
             ],
             youtube: youtubePlayerVars,
             vimeo: vimeoOptions,
-            fullscreen: { enabled: true, fallback: true, iosNative: true, container: null },
+            fullscreen: {
+                enabled: true,
+                fallback: true,
+                iosNative: true,
+                container: null,
+            },
             i18n: {
                 speed: 'Velocidade',
             },
@@ -641,13 +1094,15 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
             clickToPlay: true,
             hideControls: false,
             keyboard: { focused: true, global: false },
-            muted: false,
+            autoplay: shouldAutoplay,
+            muted: startMuted,
         };
         plyrOptions.hl = locale;
         if (captionsLanguage) {
             plyrOptions.captions = { language: captionsLanguage };
         }
         this.plyr = new Plyr.default(this.videoRef.nativeElement, plyrOptions);
+        this.bindFullscreenBehavior();
         this.setupControlsVisibility();
         this.ensureTopClickBlocker();
         this.observeMenuChanges();
@@ -668,8 +1123,7 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
         const apply = () => {
             const dur = this.plyr.duration || 0;
             const start = this.resolveStartTime(this.config.last_time, this.config.last_percent, dur);
-            if (start > 0)
-                this.plyr.currentTime = start;
+            this.applyStartTimeToCurrentSource(start);
             this.plyr.off("ready", apply);
         };
         this.plyr.on("ready", apply);
@@ -698,12 +1152,14 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
             });
         };
         this.plyr?.on?.("play", () => {
+            this.hideGestureOverlay();
             this.clearVimeoEndedState();
             this.playbackEnded = false;
             this.overlayBlockAll = false;
             this.updateRecommendationBlockerSafeZone();
             this.toggleRecommendationBlocker(false);
             parent.postMessage('playing_video', "*");
+            console.log('event: playing_video');
             this.postCastEvent({ event: 'play', currentTime: this.plyr.currentTime || 0 });
         });
         this.plyr?.on?.("timeupdate", onTimeUpdate);
@@ -721,6 +1177,7 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
             this.playbackEnded = true;
             this.overlayBlockAll = true;
             this.updateRecommendationBlockerSafeZone();
+            console.log('event: ended');
             parent.postMessage('event: ended', "*");
             this.postCastEvent({ event: 'ended', currentTime: this.plyr.currentTime || 0 });
             this.progressService.ended$.next();
@@ -729,7 +1186,7 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
         });
     }
     unmuteAfterDelay(video, delayMs = 2000, volume = 1) {
-        if (!this.config.autoplay)
+        if (!this.shouldAutoplay())
             return;
         setTimeout(() => {
             try {
@@ -784,13 +1241,8 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
                 const onReady = () => {
                     this.plyr.off("ready", onReady);
                     const start = this.resolveStartTime(this.config.last_time, this.config.last_percent, this.plyr.duration);
-                    if (start > 0)
-                        this.plyr.currentTime = start;
-                    if (this.config.autoplay || this.config.is_live) {
-                        setTimeout(() => {
-                            this.plyr.play();
-                        }, 1500);
-                    }
+                    this.applyStartTimeToCurrentSource(start);
+                    this.startAutoplayFlow();
                     parent.postMessage('playerIsReadyToPlay', "*");
                     parent.postMessage('duration:' + this.plyr.duration, "*");
                     console.log('event: current_time ' + this.plyr.currentTime);
@@ -852,35 +1304,8 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
                     const onLoadedMeta = () => {
                         const dur = this.plyr.duration || video.duration || 0;
                         const start = this.resolveStartTime(this.config.last_time, this.config.last_percent, dur);
-                        if (start > 0) {
-                            try {
-                                this.plyr.currentTime = start;
-                            }
-                            catch {
-                                try {
-                                    video.currentTime = start;
-                                }
-                                catch { }
-                            }
-                        }
-                        if (this.config.autoplay) {
-                            try {
-                                video.muted = true;
-                            }
-                            catch { }
-                            setTimeout(() => {
-                                try {
-                                    this.plyr.play();
-                                }
-                                catch {
-                                    try {
-                                        video.play();
-                                    }
-                                    catch { }
-                                }
-                                this.unmuteAfterDelay(video);
-                            }, 250);
-                        }
+                        this.applyStartTimeToCurrentSource(start, { video });
+                        this.startAutoplayFlow(video);
                         video.removeEventListener("loadedmetadata", onLoadedMeta);
                     };
                     video.addEventListener("loadedmetadata", onLoadedMeta);
@@ -894,17 +1319,8 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
                     this.hls.on(Hls.Events.MANIFEST_PARSED, () => {
                         const dur = video.duration || 0;
                         const start = this.resolveStartTime(this.config.last_time, this.config.last_percent, dur);
-                        if (start > 0) {
-                            try {
-                                video.currentTime = start;
-                            }
-                            catch { }
-                        }
-                        if (this.config.autoplay) {
-                            video.muted = true;
-                            video.play().catch(() => { });
-                            this.unmuteAfterDelay(video);
-                        }
+                        this.applyStartTimeToCurrentSource(start, { video });
+                        this.startAutoplayFlow(video);
                     });
                     this.hls.on(Hls.Events.ERROR, (_evt, data) => {
                         if (data?.fatal) {
@@ -993,6 +1409,7 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
         this.hls?.destroy();
         this.controlsVisibilityCleanup?.();
         this.controlsVisibilityCleanup = undefined;
+        this.clearAutoplayUnlockListener();
         const container = this.plyr?.elements?.container;
         container?.classList.remove("plyr--vimeo-ended");
         if (this.recommendationBlocker?.parentElement) {
@@ -1019,9 +1436,19 @@ ${allPairs.map(([n, v]) => `  ${n}: ${v};`).join('\n')}
             catch { }
         }
         this.topClickBlocker = null;
+        if (this.gestureOverlay?.parentElement) {
+            try {
+                this.gestureOverlay.parentElement.removeChild(this.gestureOverlay);
+            }
+            catch { }
+        }
+        this.gestureOverlay = null;
+        this.pendingGesturePlay = false;
         this.menuObserver?.disconnect();
         this.menuObserver = undefined;
         window.removeEventListener('resize', this.onResize);
+        this.fullscreenCleanup?.();
+        this.fullscreenCleanup = undefined;
         this.plyr?.destroy();
         window.removeEventListener('message', this.onCastMessage);
     }