vidply 1.2.1 → 1.2.3

package/dist/dev/vidply.esm.js

@@ -1,39 +1,39 @@
 /*!
- * VidPly v1.2.1 - Universal, Accessible Video Player
+ * VidPly v1.2.3 - Universal, Accessible Video Player
  * (c) 2026 Matthias Peltzer
  * Released under GPL-2.0-or-later License
  */
 import {
   TimeUtils
-} from "./vidply.chunk-YVCYQZJI.js";
+} from "./vidply.chunk-HZ7UOKOU.js";
 import {
   createIconElement,
   createPlayOverlay
-} from "./vidply.chunk-RQG3MA7W.js";
+} from "./vidply.chunk-UI3RYCVF.js";
 import {
   focusElement
-} from "./vidply.chunk-JAKZNGOR.js";
+} from "./vidply.chunk-P25MRJ6O.js";
 import {
   HTML5Renderer
-} from "./vidply.chunk-XAK3DPTO.js";
+} from "./vidply.chunk-CGYIED2I.js";
 import {
   CaptionManager
-} from "./vidply.chunk-LDVFAFGC.js";
+} from "./vidply.chunk-JKMQGLCJ.js";
 import {
   StorageManager
-} from "./vidply.chunk-UHMVDBDB.js";
+} from "./vidply.chunk-6LYZYI5G.js";
 import {
   debounce,
   isMobile,
   rafWithTimeout,
   reducedMotionScrollOptions,
   throttle
-} from "./vidply.chunk-5IK3IC5V.js";
+} from "./vidply.chunk-PRFNESYA.js";
 import {
   DOMUtils,
   i18n,
   isForbiddenKey
-} from "./vidply.chunk-NSMAZCMB.js";
+} from "./vidply.chunk-I6EDRYGJ.js";
 
 // src/utils/EventEmitter.ts
 var EventEmitter = class {
@@ -960,6 +960,12 @@ var ControlBar = class {
       }
       this.rightButtons.appendChild(btn);
     }
+    if (this.player.options.helpButton && this.player.options.keyboard) {
+      const btn = this.createHelpButton();
+      btn.dataset.overflowPriority = "3";
+      btn.dataset.overflowPriorityMobile = "3";
+      this.rightButtons.appendChild(btn);
+    }
     this.overflowMenuButton = this.createOverflowMenuButton();
     this.overflowMenuButton.style.display = "none";
     this.rightButtons.appendChild(this.overflowMenuButton);
@@ -2051,7 +2057,7 @@ var ControlBar = class {
     return button;
   }
   showCaptionStyleMenu(button) {
-    import("./vidply.CaptionStyleMenu-R2SCQ6VP.js").then(({ showCaptionStyleMenu }) => showCaptionStyleMenu(this, button)).catch((error) => this.player.log("Failed to load caption style menu:", error, "error"));
+    import("./vidply.CaptionStyleMenu-47RCKQF5.js").then(({ showCaptionStyleMenu }) => showCaptionStyleMenu(this, button)).catch((error) => this.player.log("Failed to load caption style menu:", error, "error"));
   }
   createSpeedButton() {
     const button = DOMUtils.createElement("button", {
@@ -2274,6 +2280,24 @@ var ControlBar = class {
     const isVisible = this.player.transcriptManager && this.player.transcriptManager.isVisible;
     this.controls.transcript.setAttribute("aria-expanded", isVisible ? "true" : "false");
   }
+  createHelpButton() {
+    const ariaLabel = i18n.t("help.button");
+    const button = DOMUtils.createElement("button", {
+      className: `${this.player.options.classPrefix}-button ${this.player.options.classPrefix}-help`,
+      attributes: {
+        "type": "button",
+        "aria-label": ariaLabel,
+        "aria-haspopup": "dialog"
+      }
+    });
+    button.appendChild(createIconElement("help"));
+    DOMUtils.attachTooltip(button, ariaLabel, this.player.options.classPrefix);
+    button.addEventListener("click", () => {
+      this.player.toggleKeyboardHelp();
+    });
+    this.controls.help = button;
+    return button;
+  }
   createAudioDescriptionButton() {
     const ariaLabel = i18n.t("player.audioDescription");
     const button = DOMUtils.createElement("button", {
@@ -3507,6 +3531,9 @@ var KeyboardManager = class {
           return true;
         }
         return false;
+      case "help":
+        this.player.toggleKeyboardHelp();
+        return true;
       default:
         return false;
     }
@@ -3594,6 +3621,252 @@ var KeyboardManager = class {
   }
 };
 
+// src/core/MediaSessionManager.ts
+var POSITION_THROTTLE_MS = 1e3;
+var activeManager = null;
+var MediaSessionManager = class {
+  player;
+  supported;
+  handlers = {};
+  boundActions = [];
+  lastPositionUpdate = 0;
+  constructor(player) {
+    this.player = player;
+    this.supported = typeof navigator !== "undefined" && "mediaSession" in navigator;
+    if (!this.supported) return;
+    this.attachEvents();
+    if (activeManager === null) {
+      this.claimSession();
+    }
+  }
+  /** Does this manager currently own the global media session? */
+  isActive() {
+    return activeManager === this;
+  }
+  /**
+   * Take ownership of the global session: (re)register the action handlers so
+   * the OS controls drive this player, and refresh metadata/state/position.
+   */
+  claimSession() {
+    if (!this.supported) return;
+    activeManager = this;
+    this.setupActionHandlers();
+    this.updateMetadata();
+    this.updatePlaybackState();
+    this.updatePositionState(true);
+  }
+  get session() {
+    return navigator.mediaSession;
+  }
+  setActionHandler(action, handler) {
+    try {
+      this.session.setActionHandler(action, handler);
+      if (handler && !this.boundActions.includes(action)) {
+        this.boundActions.push(action);
+      }
+    } catch {
+    }
+  }
+  setupActionHandlers() {
+    this.setActionHandler("play", () => this.player.play());
+    this.setActionHandler("pause", () => this.player.pause());
+    this.setActionHandler("stop", () => this.player.stop());
+    this.setActionHandler("seekbackward", (details) => {
+      this.player.seekBackward(this.offsetFrom(details));
+    });
+    this.setActionHandler("seekforward", (details) => {
+      this.player.seekForward(this.offsetFrom(details));
+    });
+    this.setActionHandler("seekto", (details) => {
+      if (details && typeof details.seekTime === "number") {
+        this.player.seek(details.seekTime);
+      }
+    });
+    this.updateTrackHandlers();
+  }
+  offsetFrom(details) {
+    const offset = details && typeof details.seekOffset === "number" ? details.seekOffset : void 0;
+    return typeof offset === "number" && offset > 0 ? offset : void 0;
+  }
+  /**
+   * previous/next track only make sense with a multi-item playlist; bind
+   * or clear them whenever the playlist state changes so the OS shows the
+   * correct affordances.
+   */
+  updateTrackHandlers() {
+    const pm = this.player.playlistManager;
+    const hasPlaylist = Boolean(pm && Array.isArray(pm.tracks) && pm.tracks.length > 1);
+    if (hasPlaylist && pm) {
+      this.setActionHandler("previoustrack", () => pm.previous());
+      this.setActionHandler("nexttrack", () => pm.next());
+    } else {
+      this.setActionHandler("previoustrack", null);
+      this.setActionHandler("nexttrack", null);
+    }
+  }
+  attachEvents() {
+    this.handlers = {
+      // Starting playback makes this player the session owner, taking over
+      // the OS controls from any other player on the page.
+      play: () => this.claimSession(),
+      pause: () => {
+        if (!this.isActive()) return;
+        this.updatePlaybackState();
+        this.updatePositionState(true);
+      },
+      ended: () => {
+        if (!this.isActive()) return;
+        this.updatePlaybackState();
+      },
+      timeupdate: () => {
+        if (!this.isActive()) return;
+        this.updatePositionState();
+      },
+      durationchange: () => {
+        if (!this.isActive()) return;
+        this.updatePositionState(true);
+      },
+      ratechange: () => {
+        if (!this.isActive()) return;
+        this.updatePositionState(true);
+      },
+      loadedmetadata: () => {
+        if (!this.isActive()) return;
+        this.updateMetadata();
+        this.updatePositionState(true);
+      },
+      playlisttrackchange: () => {
+        if (!this.isActive()) return;
+        this.updateMetadata();
+        this.updateTrackHandlers();
+        this.updatePositionState(true);
+      }
+    };
+    for (const [event, handler] of Object.entries(this.handlers)) {
+      if (handler) {
+        this.player.on(event, handler);
+      }
+    }
+  }
+  resolveMetadata() {
+    const opts = this.player.options;
+    let title = opts.title || "";
+    let artist = opts.artist || "";
+    const album = opts.album || "";
+    let poster = opts.poster || null;
+    const pm = this.player.playlistManager;
+    if (pm && Array.isArray(pm.tracks) && pm.currentIndex >= 0) {
+      const track = pm.tracks[pm.currentIndex];
+      if (track) {
+        if (track.title) title = track.title;
+        if (track.artist) artist = track.artist;
+        if (track.poster) poster = track.poster;
+      }
+    }
+    if (!title && typeof document !== "undefined") {
+      title = document.title || "VidPly";
+    }
+    return { title, artist, album, poster };
+  }
+  updateMetadata() {
+    if (!this.supported || typeof window === "undefined" || typeof window.MediaMetadata === "undefined") {
+      return;
+    }
+    const { title, artist, album, poster } = this.resolveMetadata();
+    const artwork = [];
+    if (poster) {
+      try {
+        const src = this.player.resolvePosterPath(poster);
+        if (src) {
+          artwork.push({ src });
+        }
+      } catch {
+      }
+    }
+    try {
+      this.session.metadata = new window.MediaMetadata({
+        title,
+        artist,
+        album,
+        artwork
+      });
+    } catch {
+    }
+  }
+  updatePlaybackState() {
+    if (!this.supported) return;
+    try {
+      this.session.playbackState = this.player.state.playing ? "playing" : "paused";
+    } catch {
+    }
+  }
+  /**
+   * Push the current position to the OS scrubber. `timeupdate` fires
+   * several times a second, so non-forced updates are throttled.
+   */
+  updatePositionState(force = false) {
+    if (!this.supported || typeof this.session.setPositionState !== "function") {
+      return;
+    }
+    const now = Date.now();
+    if (!force && now - this.lastPositionUpdate < POSITION_THROTTLE_MS) {
+      return;
+    }
+    this.lastPositionUpdate = now;
+    const duration = this.player.state.duration;
+    if (!Number.isFinite(duration) || duration <= 0) {
+      try {
+        this.session.setPositionState();
+      } catch {
+      }
+      return;
+    }
+    const playbackRate = this.player.state.playbackSpeed || 1;
+    const position = Math.min(Math.max(0, this.player.state.currentTime || 0), duration);
+    try {
+      this.session.setPositionState({
+        duration,
+        playbackRate: playbackRate > 0 ? playbackRate : 1,
+        position
+      });
+    } catch {
+    }
+  }
+  destroy() {
+    if (!this.supported) return;
+    for (const [event, handler] of Object.entries(this.handlers)) {
+      if (handler) {
+        this.player.off(event, handler);
+      }
+    }
+    this.handlers = {};
+    if (this.isActive()) {
+      for (const action of this.boundActions) {
+        try {
+          this.session.setActionHandler(action, null);
+        } catch {
+        }
+      }
+      try {
+        this.session.metadata = null;
+      } catch {
+      }
+      try {
+        if (typeof this.session.setPositionState === "function") {
+          this.session.setPositionState();
+        }
+      } catch {
+      }
+      try {
+        this.session.playbackState = "none";
+      } catch {
+      }
+      activeManager = null;
+    }
+    this.boundActions = [];
+  }
+};
+
 // src/utils/UrlSafe.ts
 function sanitizePosterUrl(input) {
   if (typeof input !== "string" || input.length === 0 || input.length > 4096) {
@@ -4694,27 +4967,280 @@ var MetadataAlertsManager = class {
   }
 };
 
+// src/controls/KeyboardHelp.ts
+var ACTION_ORDER = [
+  "play-pause",
+  "seek-backward",
+  "seek-forward",
+  "volume-up",
+  "volume-down",
+  "mute",
+  "captions",
+  "caption-style-menu",
+  "speed-down",
+  "speed-up",
+  "speed-menu",
+  "quality-menu",
+  "chapters-menu",
+  "transcript-toggle",
+  "fullscreen",
+  "help"
+];
+var ACTION_REQUIRES_CONTROL = {
+  captions: "captions",
+  "caption-style-menu": "captionStyle",
+  "speed-down": "speed",
+  "speed-up": "speed",
+  "speed-menu": "speed",
+  "quality-menu": "quality",
+  "chapters-menu": "chapters",
+  "transcript-toggle": "transcript",
+  fullscreen: "fullscreen"
+};
+var KeyboardHelp = class {
+  player;
+  isOpen = false;
+  overlay = null;
+  _triggerElement = null;
+  _keydownHandler = null;
+  _content = null;
+  constructor(player) {
+    this.player = player;
+  }
+  get prefix() {
+    return this.player.options.classPrefix;
+  }
+  /**
+   * Turn a raw KeyboardEvent.key value into a human-readable label. Arrow
+   * keys become universally understood glyphs; the space bar and single
+   * letters are normalised for legibility.
+   */
+  formatKey(key) {
+    switch (key) {
+      case " ":
+        return i18n.t("help.keys.space");
+      case "ArrowUp":
+        return "↑";
+      case "ArrowDown":
+        return "↓";
+      case "ArrowLeft":
+        return "←";
+      case "ArrowRight":
+        return "→";
+      case "Escape":
+        return "Esc";
+      default:
+        return key.length === 1 ? key.toUpperCase() : key;
+    }
+  }
+  createElement() {
+    const titleId = `${this.prefix}-help-title-${this.player.instanceId}`;
+    const overlay = DOMUtils.createElement("div", {
+      className: `${this.prefix}-settings-overlay ${this.prefix}-help-overlay`,
+      attributes: {
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-labelledby": titleId
+      }
+    });
+    overlay.style.display = "none";
+    const dialog = DOMUtils.createElement("div", {
+      className: `${this.prefix}-settings-dialog ${this.prefix}-help-dialog`
+    });
+    const header = DOMUtils.createElement("div", {
+      className: `${this.prefix}-settings-header`
+    });
+    const title = DOMUtils.createElement("h2", {
+      textContent: i18n.t("help.title"),
+      attributes: { id: titleId }
+    });
+    const closeButton = DOMUtils.createElement("button", {
+      className: `${this.prefix}-button ${this.prefix}-settings-close`,
+      attributes: {
+        type: "button",
+        "aria-label": i18n.t("help.close")
+      }
+    });
+    closeButton.appendChild(createIconElement("close"));
+    closeButton.addEventListener("click", () => this.hide());
+    header.appendChild(title);
+    header.appendChild(closeButton);
+    const content = DOMUtils.createElement("div", {
+      className: `${this.prefix}-settings-content`
+    });
+    this._content = content;
+    content.appendChild(this.buildShortcutList());
+    dialog.appendChild(header);
+    dialog.appendChild(content);
+    overlay.appendChild(dialog);
+    overlay.addEventListener("click", (e) => {
+      if (e.target === overlay) {
+        this.hide();
+      }
+    });
+    this._keydownHandler = (e) => {
+      if (!this.isOpen || !this.overlay) return;
+      if (e.key === "Escape") {
+        e.preventDefault();
+        this.hide();
+        return;
+      }
+      if (e.key === "Tab") {
+        const focusable = Array.from(
+          this.overlay.querySelectorAll(
+            'button, [href], select, input, textarea, [tabindex]:not([tabindex="-1"])'
+          )
+        ).filter((el) => !el.hasAttribute("disabled") && el.offsetParent !== null);
+        if (focusable.length === 0) return;
+        const first = focusable[0];
+        const last = focusable[focusable.length - 1];
+        if (!first || !last) return;
+        const active = document.activeElement;
+        if (e.shiftKey && (active === first || !this.overlay.contains(active))) {
+          e.preventDefault();
+          last.focus({ preventScroll: true });
+        } else if (!e.shiftKey && active === last) {
+          e.preventDefault();
+          first.focus({ preventScroll: true });
+        }
+      }
+    };
+    const lifecycleSignal = this.player.lifecycleSignal;
+    document.addEventListener(
+      "keydown",
+      this._keydownHandler,
+      lifecycleSignal ? { signal: lifecycleSignal } : void 0
+    );
+    return overlay;
+  }
+  /**
+   * Whether a shortcut row is worth showing for *this* player. Feature actions
+   * are hidden when their control isn't present (e.g. no captions track, an
+   * audio-only player with no fullscreen). Core actions are always relevant.
+   *
+   * When the player has no control bar we can't infer availability, so nothing
+   * is hidden — the shortcuts still work and we'd rather over-show than mislead.
+   */
+  isActionRelevant(action) {
+    const requiredControl = ACTION_REQUIRES_CONTROL[action];
+    if (!requiredControl) return true;
+    const controlBar = this.player.controlBar;
+    if (!controlBar || !controlBar.controls) return true;
+    return Boolean(controlBar.controls[requiredControl]);
+  }
+  buildShortcutList() {
+    const list = DOMUtils.createElement("dl", {
+      className: `${this.prefix}-help-list`
+    });
+    const shortcuts = this.player.options.keyboardShortcuts;
+    for (const action of ACTION_ORDER) {
+      const keys = shortcuts[action];
+      if (!Array.isArray(keys) || keys.length === 0) continue;
+      if (!this.isActionRelevant(action)) continue;
+      const term = DOMUtils.createElement("dt", {
+        className: `${this.prefix}-help-action`,
+        textContent: i18n.t(`help.actions.${action}`)
+      });
+      const desc = DOMUtils.createElement("dd", {
+        className: `${this.prefix}-help-keys`
+      });
+      keys.forEach((key, index) => {
+        if (index > 0) {
+          desc.appendChild(
+            DOMUtils.createElement("span", {
+              className: `${this.prefix}-help-key-sep`,
+              textContent: i18n.t("help.or")
+            })
+          );
+        }
+        desc.appendChild(
+          DOMUtils.createElement("kbd", {
+            className: `${this.prefix}-help-key`,
+            textContent: this.formatKey(key)
+          })
+        );
+      });
+      list.appendChild(term);
+      list.appendChild(desc);
+    }
+    return list;
+  }
+  show() {
+    if (this.isOpen) return;
+    if (!this.overlay) {
+      this.overlay = this.createElement();
+      this.player.container.appendChild(this.overlay);
+    } else if (this._content) {
+      this._content.replaceChildren(this.buildShortcutList());
+    }
+    const active = typeof document !== "undefined" ? document.activeElement : null;
+    this._triggerElement = active && typeof active.focus === "function" ? active : null;
+    this.overlay.style.display = "flex";
+    this.isOpen = true;
+    const closeButton = this.overlay.querySelector(`.${this.prefix}-settings-close`);
+    closeButton?.focus({ preventScroll: true });
+    this.player.emit("keyboardhelpopen");
+  }
+  hide() {
+    if (!this.overlay) return;
+    this.overlay.style.display = "none";
+    this.isOpen = false;
+    const trigger = this._triggerElement;
+    this._triggerElement = null;
+    if (trigger && document.contains(trigger)) {
+      try {
+        trigger.focus({ preventScroll: true });
+      } catch {
+        this.player.container?.focus();
+      }
+    } else {
+      this.player.container?.focus();
+    }
+    this.player.emit("keyboardhelpclose");
+  }
+  toggle() {
+    if (this.isOpen) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  }
+  destroy() {
+    if (this._keydownHandler) {
+      document.removeEventListener("keydown", this._keydownHandler);
+      this._keydownHandler = null;
+    }
+    if (this.overlay && this.overlay.parentNode) {
+      this.overlay.parentNode.removeChild(this.overlay);
+    }
+    this.overlay = null;
+    this._content = null;
+    this._triggerElement = null;
+    this.isOpen = false;
+  }
+};
+
 // src/core/Player.ts
 var AudioDescriptionManagerModule = null;
 var SignLanguageManagerModule = null;
 var FloatingPlayerManagerModule = null;
 async function loadAudioDescriptionManager() {
   if (!AudioDescriptionManagerModule) {
-    const module = await import("./vidply.AudioDescriptionManager-6RFVF27Z.js");
+    const module = await import("./vidply.AudioDescriptionManager-JYYLK5KB.js");
     AudioDescriptionManagerModule = module.AudioDescriptionManager;
   }
   return AudioDescriptionManagerModule;
 }
 async function loadSignLanguageManager() {
   if (!SignLanguageManagerModule) {
-    const module = await import("./vidply.SignLanguageManager-7IAJOVF6.js");
+    const module = await import("./vidply.SignLanguageManager-FLUCBW5H.js");
     SignLanguageManagerModule = module.SignLanguageManager;
   }
   return SignLanguageManagerModule;
 }
 async function loadFloatingPlayerManager() {
   if (!FloatingPlayerManagerModule) {
-    const module = await import("./vidply.FloatingPlayerManager-V5XQWS75.js");
+    const module = await import("./vidply.FloatingPlayerManager-C2UVRPZY.js");
     FloatingPlayerManagerModule = module.FloatingPlayerManager;
   }
   return FloatingPlayerManagerModule;
@@ -4777,9 +5303,11 @@ var Player = class _Player extends EventEmitter {
   controlBar = null;
   captionManager = null;
   keyboardManager = null;
+  mediaSessionManager = null;
   transcriptManager = null;
   playlistManager = null;
   settingsDialog = null;
+  keyboardHelp = null;
   audioDescriptionManager = null;
   signLanguageManager = null;
   floatingPlayerManager = null;
@@ -4895,6 +5423,11 @@ var Player = class _Player extends EventEmitter {
       poster: null,
       responsive: true,
       fillContainer: false,
+      // Media metadata + OS media controls (Media Session API)
+      title: null,
+      artist: null,
+      album: null,
+      mediaSession: true,
       // Playback
       autoplay: false,
       loop: false,
@@ -4942,6 +5475,7 @@ var Player = class _Player extends EventEmitter {
       captionsButton: true,
       transcriptButton: true,
       fullscreenButton: true,
+      helpButton: true,
       pipButton: false,
       floating: false,
       floatingPosition: "bottom-right",
@@ -5000,7 +5534,8 @@ var Player = class _Player extends EventEmitter {
         "speed-menu": ["s"],
         "quality-menu": ["q"],
         "chapters-menu": ["j"],
-        "transcript-toggle": ["t"]
+        "transcript-toggle": ["t"],
+        "help": ["?"]
       },
       // Accessibility
       ariaLabels: {},
@@ -5323,6 +5858,9 @@ var Player = class _Player extends EventEmitter {
       if (this.options.keyboard) {
         this.keyboardManager = new KeyboardManager(this);
       }
+      if (this.options.mediaSession) {
+        this.mediaSessionManager = new MediaSessionManager(this);
+      }
       this.setupResponsiveHandlers();
       if (this.options.startTime > 0) {
         this.seek(this.options.startTime);
@@ -5367,7 +5905,7 @@ var Player = class _Player extends EventEmitter {
     if (!this.options.transcript && !this.options.transcriptButton) {
       return null;
     }
-    const module = await import("./vidply.TranscriptManager-BPM3T23L.js");
+    const module = await import("./vidply.TranscriptManager-Y2RYXHJW.js");
     const fallbackDefault = module.default;
     const Manager = module.TranscriptManager || fallbackDefault;
     if (!Manager) {
@@ -5836,19 +6374,19 @@ var Player = class _Player extends EventEmitter {
   }
   async _detectRendererClass(src) {
     if (src.includes("youtube.com") || src.includes("youtu.be")) {
-      const module = await import("./vidply.YouTubeRenderer-HRTN4EJ5.js");
+      const module = await import("./vidply.YouTubeRenderer-EU2BARZF.js");
       return module.YouTubeRenderer ?? module.default;
     } else if (src.includes("vimeo.com")) {
-      const module = await import("./vidply.VimeoRenderer-BRHFYPNJ.js");
+      const module = await import("./vidply.VimeoRenderer-RQFQD7OE.js");
       return module.VimeoRenderer ?? module.default;
     } else if (src.includes(".m3u8")) {
-      const module = await import("./vidply.HLSRenderer-ZBEFVH5W.js");
+      const module = await import("./vidply.HLSRenderer-ZVBK2TNQ.js");
       return module.HLSRenderer ?? module.default;
     } else if (src.includes(".mpd")) {
-      const module = await import("./vidply.DASHRenderer-EOVEW73H.js");
+      const module = await import("./vidply.DASHRenderer-VEJ4HDHO.js");
       return module.DASHRenderer ?? module.default;
     } else if (src.includes("soundcloud.com") || src.includes("api.soundcloud.com")) {
-      const module = await import("./vidply.SoundCloudRenderer-OA7QQYGN.js");
+      const module = await import("./vidply.SoundCloudRenderer-MGMAJ7NK.js");
       return module.SoundCloudRenderer ?? module.default;
     }
     return HTML5Renderer;
@@ -6640,6 +7178,26 @@ var Player = class _Player extends EventEmitter {
   }
   hideSettings() {
   }
+  /**
+   * Lazily build (on first use) and toggle the keyboard-shortcuts help
+   * dialog. Reflects the live `keyboardShortcuts` bindings, including any
+   * consumer overrides.
+   */
+  toggleKeyboardHelp() {
+    if (!this.keyboardHelp) {
+      this.keyboardHelp = new KeyboardHelp(this);
+    }
+    this.keyboardHelp.toggle();
+  }
+  showKeyboardHelp() {
+    if (!this.keyboardHelp) {
+      this.keyboardHelp = new KeyboardHelp(this);
+    }
+    this.keyboardHelp.show();
+  }
+  hideKeyboardHelp() {
+    this.keyboardHelp?.hide();
+  }
   // Utility methods
   getCurrentTime() {
     return this.state.currentTime;
@@ -6779,6 +7337,22 @@ var Player = class _Player extends EventEmitter {
       }
       this.settingsDialog = null;
     }
+    if (this.keyboardHelp && typeof this.keyboardHelp.destroy === "function") {
+      try {
+        this.keyboardHelp.destroy();
+      } catch (err) {
+        this.log(`KeyboardHelp.destroy failed: ${err}`, "warn");
+      }
+      this.keyboardHelp = null;
+    }
+    if (this.mediaSessionManager && typeof this.mediaSessionManager.destroy === "function") {
+      try {
+        this.mediaSessionManager.destroy();
+      } catch (err) {
+        this.log(`MediaSessionManager.destroy failed: ${err}`, "warn");
+      }
+      this.mediaSessionManager = null;
+    }
     if (this.floatingPlayerManager) {
       try {
         this.floatingPlayerManager.destroy();