vidply 1.2.0 → 1.2.3

package/dist/legacy/vidply.js

@@ -1,5 +1,5 @@
 /*!
- * VidPly v1.2.0 - Universal, Accessible Video Player
+ * VidPly v1.2.3 - Universal, Accessible Video Player
  * (c) 2026 Matthias Peltzer
  * Released under GPL-2.0-or-later License
  */
@@ -8,8 +8,13 @@
   var __defProp = Object.defineProperty;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  var __esm = (fn, res, err) => function __init() {
+    if (err) throw err[0];
+    try {
+      return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    } catch (e) {
+      throw err = [e], e;
+    }
   };
   var __export = (target, all) => {
     for (var name in all)
@@ -423,6 +428,33 @@
           reset: "Reset to defaults",
           close: "Close"
         },
+        help: {
+          title: "Keyboard shortcuts",
+          button: "Keyboard shortcuts",
+          close: "Close",
+          or: "or",
+          keys: {
+            space: "Space"
+          },
+          actions: {
+            "play-pause": "Play / Pause",
+            "seek-backward": "Seek backward",
+            "seek-forward": "Seek forward",
+            "volume-up": "Volume up",
+            "volume-down": "Volume down",
+            "mute": "Mute / Unmute",
+            "captions": "Toggle captions",
+            "caption-style-menu": "Caption styling",
+            "speed-down": "Decrease speed",
+            "speed-up": "Increase speed",
+            "speed-menu": "Playback speed",
+            "quality-menu": "Quality",
+            "chapters-menu": "Chapters",
+            "transcript-toggle": "Toggle transcript",
+            "fullscreen": "Toggle fullscreen",
+            "help": "Keyboard shortcuts"
+          }
+        },
         speeds: {
           normal: "Normal"
         },
@@ -647,6 +679,33 @@
           reset: "Zurücksetzen",
           close: "Schließen"
         },
+        help: {
+          title: "Tastaturkürzel",
+          button: "Tastaturkürzel",
+          close: "Schließen",
+          or: "oder",
+          keys: {
+            space: "Leertaste"
+          },
+          actions: {
+            "play-pause": "Wiedergabe / Pause",
+            "seek-backward": "Zurückspulen",
+            "seek-forward": "Vorspulen",
+            "volume-up": "Lauter",
+            "volume-down": "Leiser",
+            "mute": "Stumm / Ton an",
+            "captions": "Untertitel umschalten",
+            "caption-style-menu": "Untertitel-Stil",
+            "speed-down": "Langsamer",
+            "speed-up": "Schneller",
+            "speed-menu": "Wiedergabegeschwindigkeit",
+            "quality-menu": "Qualität",
+            "chapters-menu": "Kapitel",
+            "transcript-toggle": "Transkript umschalten",
+            "fullscreen": "Vollbild umschalten",
+            "help": "Tastaturkürzel"
+          }
+        },
         speeds: {
           normal: "Normal"
         },
@@ -868,6 +927,33 @@
           reset: "Restablecer",
           close: "Cerrar"
         },
+        help: {
+          title: "Atajos de teclado",
+          button: "Atajos de teclado",
+          close: "Cerrar",
+          or: "o",
+          keys: {
+            space: "Espacio"
+          },
+          actions: {
+            "play-pause": "Reproducir / Pausar",
+            "seek-backward": "Retroceder",
+            "seek-forward": "Avanzar",
+            "volume-up": "Subir volumen",
+            "volume-down": "Bajar volumen",
+            "mute": "Silenciar / Activar sonido",
+            "captions": "Alternar subtítulos",
+            "caption-style-menu": "Estilo de subtítulos",
+            "speed-down": "Reducir velocidad",
+            "speed-up": "Aumentar velocidad",
+            "speed-menu": "Velocidad de reproducción",
+            "quality-menu": "Calidad",
+            "chapters-menu": "Capítulos",
+            "transcript-toggle": "Alternar transcripción",
+            "fullscreen": "Alternar pantalla completa",
+            "help": "Atajos de teclado"
+          }
+        },
         speeds: {
           normal: "Normal"
         },
@@ -1089,6 +1175,33 @@
           reset: "Réinitialiser",
           close: "Fermer"
         },
+        help: {
+          title: "Raccourcis clavier",
+          button: "Raccourcis clavier",
+          close: "Fermer",
+          or: "ou",
+          keys: {
+            space: "Espace"
+          },
+          actions: {
+            "play-pause": "Lecture / Pause",
+            "seek-backward": "Reculer",
+            "seek-forward": "Avancer",
+            "volume-up": "Augmenter le volume",
+            "volume-down": "Baisser le volume",
+            "mute": "Couper / Activer le son",
+            "captions": "Activer/désactiver les sous-titres",
+            "caption-style-menu": "Style des sous-titres",
+            "speed-down": "Ralentir",
+            "speed-up": "Accélérer",
+            "speed-menu": "Vitesse de lecture",
+            "quality-menu": "Qualité",
+            "chapters-menu": "Chapitres",
+            "transcript-toggle": "Activer/désactiver la transcription",
+            "fullscreen": "Activer/désactiver le plein écran",
+            "help": "Raccourcis clavier"
+          }
+        },
         speeds: {
           normal: "Normal"
         },
@@ -1310,6 +1423,33 @@
           reset: "リセット",
           close: "閉じる"
         },
+        help: {
+          title: "キーボードショートカット",
+          button: "キーボードショートカット",
+          close: "閉じる",
+          or: "または",
+          keys: {
+            space: "スペース"
+          },
+          actions: {
+            "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": "キーボードショートカット"
+          }
+        },
         speeds: {
           normal: "通常"
         },
@@ -1762,7 +1902,8 @@
         move: `<path d="M10 9h4V6h3l-5-5-5 5h3v3zm-1 1H6V7l-5 5 5 5v-3h3v-4zm14 2l-5-5v3h-3v4h3v3l5-5zm-9 3h-4v3H7l5 5 5-5h-3v-3z"/>`,
         resize: `<path d="M21.71 11.29l-9-9c-.39-.39-1.02-.39-1.41 0l-9 9c-.39.39-.39 1.02 0 1.41l9 9c.39.39 1.02.39 1.41 0l9-9c.39-.38.39-1.01 0-1.41zM14 14.5V12h-4v2.5L7 11l3-3.5V10h4V7.5l3 3.5-3 3.5z"/>`,
         clock: `<path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"/><path d="M12.5 7H11v6l5.25 3.15.75-1.23-4.5-2.67z"/>`,
-        download: `<path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"/>`
+        download: `<path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"/>`,
+        help: `<path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"/>`
       };
       svgWrapper = (paths) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">${paths}</svg>`;
       Icons = Object.fromEntries(
@@ -3153,6 +3294,194 @@
     }
   });
 
+  // src/core/DescriptionSpeechManager.ts
+  var DescriptionSpeechManager;
+  var init_DescriptionSpeechManager = __esm({
+    "src/core/DescriptionSpeechManager.ts"() {
+      "use strict";
+      DescriptionSpeechManager = class {
+        constructor(player) {
+          __publicField(this, "player");
+          __publicField(this, "enabled", false);
+          __publicField(this, "descriptionTrack", null);
+          __publicField(this, "cueChangeHandler", null);
+          __publicField(this, "seekedHandler", null);
+          __publicField(this, "wasPlayingBeforeCue", false);
+          __publicField(this, "speaking", false);
+          __publicField(this, "lastSpokenCueKey", null);
+          __publicField(this, "_pendingUtterance", null);
+          this.player = player;
+        }
+        /**
+         * Whether speech synthesis is available and enabled in player options.
+         */
+        canUseSpeech() {
+          if (this.player.options.audioDescriptionSpeech === false) {
+            return false;
+          }
+          return typeof window !== "undefined" && "speechSynthesis" in window;
+        }
+        /**
+         * Resolve the descriptions track, preferring the active caption language.
+         */
+        findDescriptionTrack() {
+          var _a, _b, _c;
+          const textTracks = this.player.element ? Array.from(this.player.element.textTracks || []) : [];
+          const descriptionsTracks = textTracks.filter(
+            (track) => track.kind === "descriptions" && !track._vidplyStale
+          );
+          if (descriptionsTracks.length === 0) {
+            return null;
+          }
+          const captionLang = (_c = (_b = (_a = this.player.captionManager) == null ? void 0 : _a.currentTrack) == null ? void 0 : _b.track) == null ? void 0 : _c.language;
+          if (captionLang) {
+            const match = descriptionsTracks.find((track) => track.language === captionLang);
+            if (match) {
+              return match;
+            }
+          }
+          return descriptionsTracks[0] ?? null;
+        }
+        /**
+         * Enable VTT speech mode: wire cuechange/seeked listeners.
+         */
+        enable() {
+          const track = this.findDescriptionTrack();
+          if (!track) {
+            return false;
+          }
+          if (!this.canUseSpeech()) {
+            track.mode = "showing";
+            return true;
+          }
+          this.descriptionTrack = track;
+          track.mode = "hidden";
+          this.cueChangeHandler = () => {
+            this.handleCueChange();
+          };
+          track.addEventListener("cuechange", this.cueChangeHandler);
+          this.seekedHandler = () => {
+            this.cancelSpeech();
+            this.lastSpokenCueKey = null;
+            this.handleCueChange();
+          };
+          this.player.on("seeked", this.seekedHandler);
+          this.enabled = true;
+          this.handleCueChange();
+          return true;
+        }
+        /**
+         * Disable VTT speech mode and restore track state.
+         */
+        disable() {
+          this.cancelSpeech();
+          this.lastSpokenCueKey = null;
+          this.enabled = false;
+          if (this.descriptionTrack && this.cueChangeHandler) {
+            this.descriptionTrack.removeEventListener("cuechange", this.cueChangeHandler);
+          }
+          if (this.seekedHandler) {
+            this.player.off("seeked", this.seekedHandler);
+          }
+          if (this.descriptionTrack) {
+            this.descriptionTrack.mode = "hidden";
+          }
+          this.cueChangeHandler = null;
+          this.seekedHandler = null;
+          this.descriptionTrack = null;
+          this.wasPlayingBeforeCue = false;
+        }
+        /**
+         * Handle active description cues on the wired track.
+         */
+        handleCueChange() {
+          var _a;
+          if (!this.enabled || !this.descriptionTrack || !this.canUseSpeech()) {
+            return;
+          }
+          const activeCues = this.descriptionTrack.activeCues;
+          if (!activeCues || activeCues.length === 0) {
+            return;
+          }
+          const cue = activeCues[0];
+          const text = (_a = cue.text) == null ? void 0 : _a.trim();
+          if (!text) {
+            return;
+          }
+          const cueKey = `${cue.startTime}:${cue.endTime}:${text}`;
+          if (this.speaking && this.lastSpokenCueKey === cueKey) {
+            return;
+          }
+          if (this.lastSpokenCueKey === cueKey && !this.player.state.playing) {
+            return;
+          }
+          this.speakCue(cue, cueKey);
+        }
+        /**
+         * Pause playback and speak a description cue.
+         */
+        speakCue(cue, cueKey) {
+          var _a;
+          if (!this.canUseSpeech()) {
+            return;
+          }
+          if (this.player.state.paused && !this.speaking && !this.wasPlayingBeforeCue) {
+            return;
+          }
+          this.cancelSpeech();
+          this.wasPlayingBeforeCue = this.player.state.playing;
+          if (this.wasPlayingBeforeCue) {
+            this.player.pause();
+          }
+          this.speaking = true;
+          this.lastSpokenCueKey = cueKey;
+          const detail = {
+            time: cue.startTime,
+            endTime: cue.endTime,
+            text: cue.text.trim(),
+            cue
+          };
+          this.player.emit("audiodescriptioncuestart", detail);
+          const utterance = new SpeechSynthesisUtterance(detail.text);
+          const lang = ((_a = this.descriptionTrack) == null ? void 0 : _a.language) || this.player.options.language || "en";
+          utterance.lang = lang;
+          const finish = () => {
+            if (this._pendingUtterance !== utterance) {
+              return;
+            }
+            this._pendingUtterance = null;
+            this.speaking = false;
+            this.player.emit("audiodescriptioncueend", detail);
+            const extended = this.player.options.audioDescriptionExtended !== false;
+            const shouldResume = extended ? this.wasPlayingBeforeCue : this.wasPlayingBeforeCue && this.player.state.currentTime < cue.endTime;
+            if (shouldResume && this.enabled) {
+              void this.player.play();
+            }
+            this.wasPlayingBeforeCue = false;
+          };
+          utterance.onend = finish;
+          utterance.onerror = finish;
+          this._pendingUtterance = utterance;
+          window.speechSynthesis.speak(utterance);
+        }
+        /**
+         * Cancel any in-progress speech synthesis.
+         */
+        cancelSpeech() {
+          if (typeof window !== "undefined" && window.speechSynthesis) {
+            window.speechSynthesis.cancel();
+          }
+          this._pendingUtterance = null;
+          this.speaking = false;
+          this.wasPlayingBeforeCue = false;
+        }
+        destroy() {
+          this.disable();
+        }
+      };
+    }
+  });
+
   // src/core/AudioDescriptionManager.ts
   var AudioDescriptionManager_exports = {};
   __export(AudioDescriptionManager_exports, {
@@ -3163,6 +3492,7 @@
     "src/core/AudioDescriptionManager.ts"() {
       "use strict";
       init_CaptionManager();
+      init_DescriptionSpeechManager();
       AudioDescriptionManager = class {
         constructor(player) {
           __publicField(this, "player");
@@ -3172,6 +3502,7 @@
           __publicField(this, "originalSource");
           __publicField(this, "sourceElement");
           __publicField(this, "src");
+          __publicField(this, "speechManager");
           this.player = player;
           this.enabled = false;
           this.desiredState = false;
@@ -3179,6 +3510,49 @@
           this.sourceElement = null;
           this.originalSource = null;
           this.captionTracks = [];
+          this.speechManager = null;
+        }
+        /**
+         * Whether a described video source swap is configured.
+         */
+        _hasSwapSource() {
+          const hasSourceElementsWithDesc = this.player.sourceElements.some(
+            (el) => el.getAttribute("data-desc-src")
+          );
+          return Boolean(this.src || hasSourceElementsWithDesc);
+        }
+        /**
+         * Whether a descriptions VTT track is present on the media element.
+         */
+        _hasDescriptionsTrack() {
+          return Boolean(this.player.findTextTrack("descriptions"));
+        }
+        /**
+         * Resolve which audio-description delivery mode applies for the current media.
+         */
+        resolveDeliveryMode() {
+          const configured = this.player.options.audioDescriptionMode ?? "auto";
+          const hasSwap = this._hasSwapSource();
+          const hasDescriptions = this._hasDescriptionsTrack();
+          if (configured === "swap") {
+            return hasSwap ? "swap" : "none";
+          }
+          if (configured === "vtt_speech") {
+            return hasDescriptions ? "vtt_speech" : "none";
+          }
+          if (hasSwap) {
+            return "swap";
+          }
+          if (hasDescriptions) {
+            return "vtt_speech";
+          }
+          return "none";
+        }
+        _ensureSpeechManager() {
+          if (!this.speechManager) {
+            this.speechManager = new DescriptionSpeechManager(this.player);
+          }
+          return this.speechManager;
         }
         /**
          * Initialize audio description from source elements
@@ -3232,24 +3606,35 @@
          * Check if audio description is available
          */
         isAvailable() {
-          const hasSourceElementsWithDesc = this.player.sourceElements.some(
-            (el) => el.getAttribute("data-desc-src")
-          );
-          return Boolean(this.src || hasSourceElementsWithDesc || this.captionTracks.length > 0);
+          const mode = this.resolveDeliveryMode();
+          if (mode === "swap" || mode === "vtt_speech") {
+            return true;
+          }
+          return this.captionTracks.length > 0;
         }
         /**
          * Enable audio description
          */
         async enable() {
-          const hasSourceElementsWithDesc = this.player.sourceElements.some(
-            (el) => el.getAttribute("data-desc-src")
-          );
+          const deliveryMode = this.resolveDeliveryMode();
           const hasTracksWithDesc = this.captionTracks.length > 0;
-          if (!this.src && !hasSourceElementsWithDesc && !hasTracksWithDesc) {
-            console.warn("VidPly: No audio description source, source elements, or tracks provided");
+          if (deliveryMode === "none" && !hasTracksWithDesc) {
+            console.warn("VidPly: No audio description source, descriptions track, or tracks provided");
             return;
           }
           this.desiredState = true;
+          if (deliveryMode === "vtt_speech") {
+            const speechManager = this._ensureSpeechManager();
+            const started = speechManager.enable();
+            if (!started) {
+              console.warn("VidPly: No descriptions track available for VTT speech mode");
+              return;
+            }
+            this.enabled = true;
+            this.player.state.audioDescriptionEnabled = true;
+            this.player.emit("audiodescriptionenabled");
+            return;
+          }
           const currentTime = this.player.state.currentTime;
           const wasPlaying = this.player.state.playing;
           const posterValue = this.player.element.poster || this.player.element.getAttribute("poster") || this.player.options.poster;
@@ -3269,7 +3654,15 @@
          * Disable audio description
          */
         async disable() {
+          var _a;
           this.desiredState = false;
+          if ((_a = this.speechManager) == null ? void 0 : _a.enabled) {
+            this.speechManager.disable();
+            this.enabled = false;
+            this.player.state.audioDescriptionEnabled = false;
+            this.player.emit("audiodescriptiondisabled");
+            return;
+          }
           const hasTracksWithDesc = this.captionTracks.length > 0;
           if (!this.sourceElement && !this.src && hasTracksWithDesc) {
             await this._swapCaptionTracks(false);
@@ -3295,19 +3688,30 @@
          * Toggle audio description
          */
         async toggle() {
+          const deliveryMode = this.resolveDeliveryMode();
           const descriptionTrack = this.player.findTextTrack("descriptions");
-          const hasAudioDescriptionSrc = this.isAvailable();
-          if (descriptionTrack && !hasAudioDescriptionSrc) {
+          const hasSwapOrTracks = this._hasSwapSource() || this.captionTracks.length > 0;
+          if (deliveryMode === "vtt_speech") {
+            if (this.enabled) {
+              await this.disable();
+            } else {
+              await this.enable();
+            }
+            return;
+          }
+          if (descriptionTrack && !hasSwapOrTracks) {
             if (descriptionTrack.mode === "showing") {
               descriptionTrack.mode = "hidden";
               this.enabled = false;
+              this.player.state.audioDescriptionEnabled = false;
               this.player.emit("audiodescriptiondisabled");
             } else {
               descriptionTrack.mode = "showing";
               this.enabled = true;
+              this.player.state.audioDescriptionEnabled = true;
               this.player.emit("audiodescriptionenabled");
             }
-          } else if (descriptionTrack && hasAudioDescriptionSrc) {
+          } else if (descriptionTrack && hasSwapOrTracks) {
             if (this.enabled) {
               this.desiredState = false;
               await this.disable();
@@ -3316,7 +3720,7 @@
               this.desiredState = true;
               await this.enable();
             }
-          } else if (hasAudioDescriptionSrc) {
+          } else if (hasSwapOrTracks) {
             if (this.enabled) {
               this.desiredState = false;
               await this.disable();
@@ -3715,6 +4119,9 @@
          * Update sources (called when playlist changes)
          */
         updateSources(audioDescriptionSrc) {
+          var _a;
+          (_a = this.speechManager) == null ? void 0 : _a.destroy();
+          this.speechManager = null;
           this.src = audioDescriptionSrc || null;
           this.enabled = false;
           this.desiredState = false;
@@ -3733,6 +4140,9 @@
          * Cleanup
          */
         destroy() {
+          var _a;
+          (_a = this.speechManager) == null ? void 0 : _a.destroy();
+          this.speechManager = null;
           this.enabled = false;
           this.desiredState = false;
           this.captionTracks = [];
@@ -12102,6 +12512,12 @@
         }
         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);
@@ -13423,6 +13839,24 @@
       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", {
@@ -14670,6 +15104,9 @@
             return true;
           }
           return false;
+        case "help":
+          this.player.toggleKeyboardHelp();
+          return true;
         default:
           return false;
       }
@@ -14757,6 +15194,252 @@
     }
   };
 
+  // src/core/MediaSessionManager.ts
+  var POSITION_THROTTLE_MS = 1e3;
+  var activeManager = null;
+  var MediaSessionManager = class {
+    constructor(player) {
+      __publicField(this, "player");
+      __publicField(this, "supported");
+      __publicField(this, "handlers", {});
+      __publicField(this, "boundActions", []);
+      __publicField(this, "lastPositionUpdate", 0);
+      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/core/Player.ts
   init_HTML5Renderer();
   init_Icons();
@@ -15873,6 +16556,263 @@
     }
   };
 
+  // src/controls/KeyboardHelp.ts
+  init_DOMUtils();
+  init_Icons();
+  init_i18n();
+  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 {
+    constructor(player) {
+      __publicField(this, "player");
+      __publicField(this, "isOpen", false);
+      __publicField(this, "overlay", null);
+      __publicField(this, "_triggerElement", null);
+      __publicField(this, "_keydownHandler", null);
+      __publicField(this, "_content", null);
+      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 == null ? void 0 : closeButton.focus({ preventScroll: true });
+      this.player.emit("keyboardhelpopen");
+    }
+    hide() {
+      var _a, _b;
+      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 {
+          (_a = this.player.container) == null ? void 0 : _a.focus();
+        }
+      } else {
+        (_b = this.player.container) == null ? void 0 : _b.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;
@@ -15916,9 +16856,11 @@
       __publicField(this, "controlBar", null);
       __publicField(this, "captionManager", null);
       __publicField(this, "keyboardManager", null);
+      __publicField(this, "mediaSessionManager", null);
       __publicField(this, "transcriptManager", null);
       __publicField(this, "playlistManager", null);
       __publicField(this, "settingsDialog", null);
+      __publicField(this, "keyboardHelp", null);
       __publicField(this, "audioDescriptionManager", null);
       __publicField(this, "signLanguageManager", null);
       __publicField(this, "floatingPlayerManager", null);
@@ -16032,6 +16974,11 @@
         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,
@@ -16079,6 +17026,7 @@
         captionsButton: true,
         transcriptButton: true,
         fullscreenButton: true,
+        helpButton: true,
         pipButton: false,
         floating: false,
         floatingPosition: "bottom-right",
@@ -16104,6 +17052,9 @@
         audioDescriptionSrc: null,
         // URL to audio-described version
         audioDescriptionButton: true,
+        audioDescriptionMode: "auto",
+        audioDescriptionSpeech: true,
+        audioDescriptionExtended: true,
         // Sign Language
         signLanguage: true,
         signLanguageSrc: null,
@@ -16134,7 +17085,8 @@
           "speed-menu": ["s"],
           "quality-menu": ["q"],
           "chapters-menu": ["j"],
-          "transcript-toggle": ["t"]
+          "transcript-toggle": ["t"],
+          "help": ["?"]
         },
         // Accessibility
         ariaLabels: {},
@@ -16517,6 +17469,9 @@
         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);
@@ -16589,15 +17544,33 @@
       if (this.audioDescriptionManager) {
         return this.audioDescriptionManager;
       }
-      const hasAudioDescSrc = this.options.audioDescriptionSrc || this.audioDescriptionSrc;
-      const hasAudioDescButton = this.options.audioDescriptionButton;
-      if (!hasAudioDescSrc && !hasAudioDescButton) {
+      if (!this.hasAudioDescriptionContent()) {
         return null;
       }
       const AudioDescManager = await loadAudioDescriptionManager();
       this.audioDescriptionManager = new AudioDescManager(this);
       return this.audioDescriptionManager;
     }
+    /**
+     * True when the current media actually exposes audio-description content:
+     * an explicit described-audio source, `<source>` elements carrying
+     * `data-desc-src` / `data-orig-src`, or a `descriptions` text track.
+     * Mirrors `ControlBar.hasAudioDescription()` so the chunk load and the
+     * button visibility stay in lock-step.
+     */
+    hasAudioDescriptionContent() {
+      if (this.options.audioDescriptionSrc || this.audioDescriptionSrc) {
+        return true;
+      }
+      const hasSourceElementsWithDesc = this.sourceElements.some(
+        (el) => el.getAttribute("data-desc-src") || el.getAttribute("data-orig-src")
+      );
+      if (hasSourceElementsWithDesc) {
+        return true;
+      }
+      const textTracks = this.element ? Array.from(this.element.textTracks || []) : [];
+      return textTracks.some((track) => track.kind === "descriptions");
+    }
     // ============================================
     // Resume Playback Methods
     // ============================================
@@ -16609,16 +17582,24 @@
       if (this.signLanguageManager) {
         return this.signLanguageManager;
       }
-      const hasSignLangSrc = this.options.signLanguageSrc || this.signLanguageSrc;
-      const hasSignLangSources = this.options.signLanguageSources && Object.keys(this.options.signLanguageSources).length > 0;
-      const hasSignLangButton = this.options.signLanguageButton;
-      if (!hasSignLangSrc && !hasSignLangSources && !hasSignLangButton) {
+      if (!this.hasSignLanguageContent()) {
         return null;
       }
       const SignLangManager = await loadSignLanguageManager();
       this.signLanguageManager = new SignLangManager(this);
       return this.signLanguageManager;
     }
+    /**
+     * True when a sign-language video source (single `signLanguageSrc` or a
+     * `signLanguageSources` map) is configured. Mirrors
+     * `ControlBar.hasSignLanguage()`.
+     */
+    hasSignLanguageContent() {
+      if (this.options.signLanguageSrc || this.signLanguageSrc) {
+        return true;
+      }
+      return !!(this.options.signLanguageSources && Object.keys(this.options.signLanguageSources).length > 0);
+    }
     /**
      * Lazy-load and instantiate the floating (in-page PiP) manager. Only
      * created when `options.floating === true` and the media element is a
@@ -16643,13 +17624,10 @@
      */
     async initFeatureManagers() {
       const promises = [];
-      const hasSourceElementsWithDesc = this.sourceElements.some(
-        (el) => el.getAttribute("data-desc-src") || el.getAttribute("data-orig-src")
-      );
-      if (this.options.audioDescriptionButton || this.options.audioDescriptionSrc || this.audioDescriptionSrc || hasSourceElementsWithDesc) {
+      if (this.hasAudioDescriptionContent()) {
         promises.push(this.ensureAudioDescriptionManager());
       }
-      if (this.options.signLanguageButton || this.options.signLanguageSrc || this.signLanguageSrc || this.options.signLanguageSources && Object.keys(this.options.signLanguageSources).length > 0) {
+      if (this.hasSignLanguageContent()) {
         promises.push(this.ensureSignLanguageManager());
       }
       if (this.options.floating && this.element && this.element.tagName === "VIDEO") {
@@ -16991,6 +17969,9 @@
       }
       this.currentSource = src;
       this._pendingSource = null;
+      if (this.hasAudioDescriptionContent()) {
+        await this.ensureAudioDescriptionManager();
+      }
       (_b = this.audioDescriptionManager) == null ? void 0 : _b.initFromSourceElements(this.sourceElements, this.trackElements);
       if (!this.originalSrc) {
         this.originalSrc = src;
@@ -17832,6 +18813,27 @@
     }
     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() {
+      var _a;
+      (_a = this.keyboardHelp) == null ? void 0 : _a.hide();
+    }
     // Utility methods
     getCurrentTime() {
       return this.state.currentTime;
@@ -17972,6 +18974,22 @@
         }
         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();
@@ -18466,7 +19484,7 @@
      * @param {number} index - Track index
      */
     selectTrack(index) {
-      var _a, _b, _c, _d;
+      var _a, _b, _c, _d, _e, _f;
       if (index < 0 || index >= this.tracks.length) {
         console.warn("VidPly Playlist: Invalid track index", index);
         return;
@@ -18527,12 +19545,19 @@
         if (typeof this.player.invalidateTrackCache === "function") {
           this.player.invalidateTrackCache();
         }
-        if (this.player.audioDescriptionManager && typeof this.player.audioDescriptionManager.initFromSourceElements === "function") {
+        const reinitAudioDescription = (adm) => {
+          if (!adm || typeof adm.initFromSourceElements !== "function") return;
           try {
-            this.player.audioDescriptionManager.captionTracks = [];
-            this.player.audioDescriptionManager.initFromSourceElements(this.player.sourceElements, this.player.trackElements);
+            adm.captionTracks = [];
+            adm.initFromSourceElements(this.player.sourceElements, this.player.trackElements);
           } catch {
           }
+        };
+        if (this.player.audioDescriptionManager) {
+          reinitAudioDescription(this.player.audioDescriptionManager);
+        } else if ((_f = (_e = this.player).hasAudioDescriptionContent) == null ? void 0 : _f.call(_e)) {
+          void this.player.ensureAudioDescriptionManager().then(reinitAudioDescription).catch(() => {
+          });
         }
         if (this.player.captionManager && typeof this.player.captionManager.loadTracks === "function") {
           try {
@@ -19397,6 +20422,9 @@
       signLanguageDisplayMode: "signLanguageDisplayMode",
       audioDescriptionSrc: "audioDescriptionSrc",
       audioDescriptionButton: "audioDescriptionButton",
+      audioDescriptionMode: "audioDescriptionMode",
+      audioDescriptionSpeech: "audioDescriptionSpeech",
+      audioDescriptionExtended: "audioDescriptionExtended",
       autoplay: "autoplay",
       loop: "loop",
       muted: "muted",