@byteplus/veplayer-plugin 2.10.3-rc.0 → 2.10.3-rc.1

package/esm/veplayer.plugin.hlsjs.development.js

@@ -1,3 +1,4 @@
+import { DynamicModule } from "@byteplus/veplayer";
 function ownKeys$1(object, enumerableOnly) {
   var keys = Object.keys(object);
   if (Object.getOwnPropertySymbols) {
@@ -32173,7 +32174,7 @@ class Hls {
   }
 }
 Hls.defaultConfig = void 0;
-const optionsMap = {
+const OPTIONS_MAP = {
   liveSyncDuration: {
     key: "targetLatency",
     val: 10
@@ -32190,20 +32191,40 @@ const optionsMap = {
     key: "minSegmentsStartPlay",
     val: 3
   },
-  preferManagedMediaSource: {
-    key: "preferMMS",
-    val: false
-  },
+  preferManagedMediaSource: [
+    {
+      key: "preferMMS",
+      val: false
+    },
+    {
+      key: "preferMMSStreaming",
+      val: false
+    }
+  ],
   lowLatencyMode: {
     key: "useLowLatency",
     val: true
+  },
+  startPosition: {
+    key: "startTime",
+    val: 0
+  },
+  interstitialLiveLookAhead: {
+    key: "preloadTime",
+    val: 30
   }
 };
-function getHlsConfig(config, playerConfig) {
+function getHlsConfig(config) {
   const hlsConfig = {};
-  Object.keys(optionsMap).forEach((keyStr) => {
-    const tmp = optionsMap[keyStr];
-    hlsConfig[keyStr] = config[tmp.key] || tmp.val;
+  Object.keys(OPTIONS_MAP).forEach((keyStr) => {
+    const tmp = OPTIONS_MAP[keyStr];
+    if (tmp instanceof Array) {
+      tmp.forEach((item) => {
+        hlsConfig[keyStr] = item.val;
+      });
+    } else {
+      hlsConfig[keyStr] = config[tmp.key] || tmp.val;
+    }
   });
   const maxNumRetry = typeof config.retryCount === "number" ? config.retryCount : 3;
   const retryDelayMs = typeof config.retryDelay === "number" ? config.retryDelay : 1e3;
@@ -32254,11 +32275,434 @@ function getHlsConfig(config, playerConfig) {
     ...config
   };
 }
+function initHlsEvents(hls, player) {
+  hls.on(Hls.Events.SUBTITLE_FRAG_PROCESSED, (_, { frag }) => {
+    player.emit("core_event", {
+      eventName: "core.subtitlesegments",
+      list: frag
+    });
+  });
+  hls.on(Hls.Events.MANIFEST_PARSED, (_, { levels }) => {
+    player.emit("core_event", {
+      eventName: "core.subtitleplaylist",
+      list: levels
+    });
+  });
+  hls.on(Hls.Events.MANIFEST_LOADING, (_, { url }) => {
+    player.emit("core_event", {
+      eventName: "core.loadstart",
+      url
+    });
+  });
+  hls.on(Hls.Events.LEVEL_LOADING, (_, { url }) => {
+    player.emit("core_event", {
+      eventName: "core.loadstart",
+      url
+    });
+  });
+  hls.on(Hls.Events.FRAG_LOADING, (_, { frag }) => {
+    player.emit("core_event", {
+      eventName: "core.loadstart",
+      url: frag.url
+    });
+  });
+  hls.on(Hls.Events.MANIFEST_LOADED, (_, data) => {
+    const { url } = data;
+    player.emit("core_event", {
+      eventName: "core.loadcomplete",
+      url
+    });
+  });
+  hls.on(Hls.Events.LEVEL_LOADED, (_, data) => {
+    const { details, stats } = data;
+    player.emit("core_event", {
+      eventName: "core.loadcomplete",
+      ...stats,
+      url: details == null ? void 0 : details.url
+    });
+  });
+  hls.on(Hls.Events.FRAG_LOADED, (_, data) => {
+    const { frag } = data;
+    player.emit("core_event", {
+      eventName: "core.loadcomplete",
+      url: frag.url
+    });
+  });
+  hls.on(Hls.Events.FRAG_PARSING_USERDATA, (_, { samples }) => {
+    player.emit("core_event", {
+      eventName: "core.sei",
+      sei: samples
+    });
+  });
+  hls.on(Hls.Events.MANIFEST_LOADED, (_, { levels, networkDetails }) => {
+    player.emit("core_event", {
+      eventName: "core.hlsmanifestloaded",
+      playlist: levels
+    });
+    player.emit("core_event", {
+      eventName: "core.loadresponseheaders",
+      headers: networkDetails.headers
+    });
+  });
+  hls.on(Hls.Events.LEVEL_LOADED, (_, { details }) => {
+    const dateRanges = {};
+    Object.keys(details.dateRanges).forEach((key) => {
+      dateRanges[key] = details.dateRanges[key].attr["START-DATE"];
+    });
+    player.emit("core_event", {
+      eventName: "core.hlslevelloaded",
+      playlist: {
+        ...details,
+        segments: details.fragments,
+        dateRanges
+      }
+    });
+  });
+  hls.on(Hls.Events.ERROR, (_, data) => {
+    const { details, fatal, type, response, reason, error } = data;
+    if (!fatal) {
+      return;
+    }
+    let errorCode;
+    let errorType;
+    switch (type) {
+      case Hls.ErrorTypes.NETWORK_ERROR:
+        errorCode = 2100;
+        if (details.includes("TimeOut")) {
+          errorCode = 2101;
+        } else if ((response == null ? void 0 : response.code) === 403) {
+          errorCode = 2103;
+        } else if ((response == null ? void 0 : response.code) === 404) {
+          errorCode = 2104;
+        }
+        player.emit("error", {
+          errorType: "network",
+          errorCode,
+          message: (error == null ? void 0 : error.message) || details,
+          originError: data
+        });
+        break;
+      case Hls.ErrorTypes.MEDIA_ERROR:
+        errorType = "media";
+        if (details === Hls.ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR) {
+          errorCode = 5104;
+        } else if (details === Hls.ErrorDetails.FRAG_DECRYPT_ERROR) {
+          errorCode = 5105;
+        } else if (details === Hls.ErrorDetails.FRAG_PARSING_ERROR) {
+          errorCode = 1100;
+          errorType = "manifest";
+        } else if (details === Hls.ErrorDetails.FRAG_GAP) {
+          errorCode = 5104;
+        } else if (details === Hls.ErrorDetails.BUFFER_ADD_CODEC_ERROR) {
+          errorCode = 5200;
+        } else if (details === Hls.ErrorDetails.BUFFER_INCOMPATIBLE_CODECS_ERROR) {
+          errorCode = 5104;
+        } else if (details === Hls.ErrorDetails.BUFFER_APPEND_ERROR) {
+          errorCode = 5201;
+        } else if (details === Hls.ErrorDetails.BUFFER_APPENDING_ERROR) {
+          errorCode = 5201;
+        } else if (details === Hls.ErrorDetails.BUFFER_STALLED_ERROR) {
+          errorCode = 5203;
+        } else if (details === Hls.ErrorDetails.BUFFER_FULL_ERROR) {
+          errorCode = 5203;
+        } else if (details === Hls.ErrorDetails.BUFFER_SEEK_OVER_HOLE) {
+          errorCode = 5202;
+        } else if (details === Hls.ErrorDetails.BUFFER_NUDGE_ON_STALL) {
+          errorCode = 5202;
+        }
+        player.emit("error", {
+          errorType: errorType || type,
+          errorCode,
+          message: (error == null ? void 0 : error.message) || details,
+          originError: data
+        });
+        break;
+      case Hls.ErrorTypes.MUX_ERROR:
+        errorCode = 4100;
+        player.emit("error", {
+          errorType: "remux",
+          errorCode,
+          message: (error == null ? void 0 : error.message) || details,
+          originError: data
+        });
+        break;
+      case Hls.ErrorTypes.KEY_SYSTEM_ERROR:
+        errorCode = 7111;
+        if (details === Hls.ErrorDetails.KEY_SYSTEM_NO_KEYS) {
+          errorCode = 7103;
+        } else if (details === Hls.ErrorDetails.KEY_SYSTEM_NO_ACCESS) {
+          errorCode = 7101;
+        } else if (details === Hls.ErrorDetails.KEY_SYSTEM_NO_SESSION) {
+          errorCode = 7104;
+        } else if (details === Hls.ErrorDetails.KEY_SYSTEM_NO_CONFIGURED_LICENSE) {
+          errorCode = 7107;
+        } else if (details === Hls.ErrorDetails.KEY_SYSTEM_LICENSE_REQUEST_FAILED) {
+          errorCode = 7108;
+        } else if (details === Hls.ErrorDetails.KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED) {
+          errorCode = 7110;
+        } else if (details === Hls.ErrorDetails.KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED) {
+          errorCode = 7110;
+        } else if (details === Hls.ErrorDetails.KEY_SYSTEM_SESSION_UPDATE_FAILED) {
+          errorCode = 7104;
+        } else if (details === Hls.ErrorDetails.KEY_SYSTEM_STATUS_INTERNAL_ERROR) {
+          errorCode = 7111;
+        }
+        player.emit("error", {
+          errorType: "drm",
+          errorCode,
+          message: (error == null ? void 0 : error.message) || reason || details,
+          originError: data
+        });
+        break;
+      default:
+        if (details === Hls.ErrorDetails.LEVEL_SWITCH_ERROR) {
+          errorCode = 2100;
+          errorType = "network";
+        }
+        player.emit("error", {
+          errorType: errorType || "other",
+          errorCode,
+          message: (error == null ? void 0 : error.message) || reason || details,
+          originError: data
+        });
+        break;
+    }
+    try {
+      hls.stopLoad();
+      player.pause();
+    } catch (error2) {
+    }
+  });
+  hls.on(Hls.Events.MEDIA_ATTACHED, () => {
+    player.emit("sourceopen");
+  });
+  hls.on(Hls.Events.BUFFER_APPENDED, () => {
+    player.emit("bufferappend");
+  });
+  hls.on(Hls.Events.AUDIO_TRACKS_UPDATED, (_, { audioTracks }) => {
+    player.emit("core_event", {
+      eventName: "core.audiotracksupdate",
+      audioTracks
+    });
+  });
+  hls.on(Hls.Events.AUDIO_TRACK_SWITCHING, (_, data) => {
+    player.emit("core_event", {
+      eventName: "core.audiotrackswitching",
+      ...data
+    });
+  });
+  hls.on(Hls.Events.AUDIO_TRACK_SWITCHED, (_, data) => {
+    player.emit("core_event", {
+      eventName: "core.audiotrackswitched",
+      ...data
+    });
+  });
+  hls.on(Hls.Events.SUBTITLE_TRACKS_UPDATED, (_, { subtitleTracks }) => {
+    player.emit("core_event", {
+      eventName: "core.subtitletracksupdate",
+      subtitleTracks
+    });
+  });
+  hls.on(Hls.Events.SUBTITLE_TRACKS_CLEARED, () => {
+    player.emit("core_event", {
+      eventName: "core.subtitletracksclear"
+    });
+  });
+  hls.on(Hls.Events.SUBTITLE_TRACK_SWITCH, (_, data) => {
+    player.emit("core_event", {
+      eventName: "core.subtitletrackswitch",
+      ...data
+    });
+  });
+  hls.on(Hls.Events.SUBTITLE_TRACK_LOADING, (_, data) => {
+    player.emit("core_event", {
+      eventName: "core.subtitletrackloading",
+      ...data
+    });
+  });
+  hls.on(Hls.Events.SUBTITLE_TRACK_LOADED, (_, data) => {
+    player.emit("core_event", {
+      eventName: "core.subtitletrackloaded",
+      ...data
+    });
+  });
+}
+class TrackManager {
+  constructor(hls, player) {
+    this.hls = hls;
+    this.player = player;
+  }
+  // Audio Track Methods
+  getAudioTracks() {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return [];
+    }
+    try {
+      return this.hls.audioTracks || [];
+    } catch (error) {
+      console.error("Failed to get audio tracks:", error);
+      return [];
+    }
+  }
+  getCurrentAudioTrack() {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return -1;
+    }
+    try {
+      return this.hls.audioTrack;
+    } catch (error) {
+      console.error("Failed to get current audio track:", error);
+      return -1;
+    }
+  }
+  switchAudioTrack(trackId) {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return false;
+    }
+    const audioTracks = this.getAudioTracks();
+    if (audioTracks.length === 0) {
+      console.warn("No audio tracks available");
+      return false;
+    }
+    const trackExists = audioTracks.some((_, index) => index === trackId);
+    if (!trackExists) {
+      console.warn(`Audio track with ID ${trackId} not found`);
+      return false;
+    }
+    try {
+      this.hls.audioTrack = trackId;
+      this.player.emit("core_event", {
+        eventName: "core.audiotrackchange",
+        trackId,
+        trackInfo: audioTracks[trackId] || null
+      });
+      return true;
+    } catch (error) {
+      console.error("Failed to switch audio track:", error);
+      return false;
+    }
+  }
+  // Subtitle Track Methods
+  getSubtitleTracks() {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return [];
+    }
+    try {
+      return this.hls.subtitleTracks || [];
+    } catch (error) {
+      console.error("Failed to get subtitle tracks:", error);
+      return [];
+    }
+  }
+  getAllSubtitleTracks() {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return [];
+    }
+    try {
+      return this.hls.allSubtitleTracks || [];
+    } catch (error) {
+      console.error("Failed to get all subtitle tracks:", error);
+      return [];
+    }
+  }
+  getCurrentSubtitleTrack() {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return -1;
+    }
+    try {
+      return this.hls.subtitleTrack;
+    } catch (error) {
+      console.error("Failed to get current subtitle track:", error);
+      return -1;
+    }
+  }
+  switchSubtitleTrack(trackId) {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return false;
+    }
+    const subtitleTracks = this.getSubtitleTracks();
+    if (trackId === -1) {
+      try {
+        this.hls.subtitleTrack = -1;
+        this.player.emit("core_event", {
+          eventName: "core.subtitletrackchange",
+          trackId: -1,
+          trackInfo: null
+        });
+        return true;
+      } catch (error) {
+        console.error("Failed to disable subtitle track:", error);
+        return false;
+      }
+    }
+    if (subtitleTracks.length === 0) {
+      console.warn("No subtitle tracks available");
+      return false;
+    }
+    const trackExists = subtitleTracks.some((_, index) => index === trackId);
+    if (!trackExists) {
+      console.warn(`Subtitle track with ID ${trackId} not found`);
+      return false;
+    }
+    try {
+      this.hls.subtitleTrack = trackId;
+      this.player.emit("core_event", {
+        eventName: "core.subtitletrackchange",
+        trackId,
+        trackInfo: subtitleTracks[trackId] || null
+      });
+      return true;
+    } catch (error) {
+      console.error("Failed to switch subtitle track:", error);
+      return false;
+    }
+  }
+  getSubtitleDisplay() {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return false;
+    }
+    try {
+      return this.hls.subtitleDisplay;
+    } catch (error) {
+      console.error("Failed to get subtitle display status:", error);
+      return false;
+    }
+  }
+  setSubtitleDisplay(enabled) {
+    if (!this.hls) {
+      console.warn("HLS instance not initialized");
+      return false;
+    }
+    try {
+      this.hls.subtitleDisplay = enabled;
+      this.player.emit("core_event", {
+        eventName: "core.subtitledisplaychange",
+        enabled
+      });
+      return true;
+    } catch (error) {
+      console.error("Failed to set subtitle display:", error);
+      return false;
+    }
+  }
+}
 const MAX_HOLE = 0.1;
 class XgHls extends BasePlugin {
   constructor(options) {
-    super(options);
+    super({
+      ...options,
+      pluginName: XgHls.pluginName
+    });
     this._tickInterval = 500;
+    this._currentIndex = 0;
     this._onPlay = () => {
       this.hls.startLoad();
     };
@@ -32296,8 +32740,7 @@ class XgHls extends BasePlugin {
       var _a;
       (_a = this.hls) == null ? void 0 : _a.on(eventName, func);
     };
-    const config = options.config || {};
-    this.config = config;
+    this.config = options.config || {};
     this.player.handleSource = false;
   }
   static get pluginName() {
@@ -32307,209 +32750,7 @@ class XgHls extends BasePlugin {
     this.register(this.player.config.url);
   }
   initEvt() {
-    this.hls.on(Hls.Events.SUBTITLE_FRAG_PROCESSED, (_, { frag }) => {
-      this.player.emit("core_event", {
-        eventName: "core.subtitlesegments",
-        list: frag
-      });
-    });
-    this.hls.on(Hls.Events.MANIFEST_PARSED, (_, { levels }) => {
-      this.player.emit("core_event", {
-        eventName: "core.subtitleplaylist",
-        list: levels
-      });
-    });
-    this.hls.on(Hls.Events.MANIFEST_LOADING, (_, { url }) => {
-      this.player.emit("core_event", {
-        eventName: "core.loadstart",
-        url
-      });
-    });
-    this.hls.on(Hls.Events.LEVEL_LOADING, (_, { url }) => {
-      this.player.emit("core_event", {
-        eventName: "core.loadstart",
-        url
-      });
-    });
-    this.hls.on(Hls.Events.FRAG_LOADING, (_, { frag }) => {
-      this.player.emit("core_event", {
-        eventName: "core.loadstart",
-        url: frag.url
-      });
-    });
-    this.hls.on(Hls.Events.MANIFEST_LOADED, (_, data) => {
-      const { url } = data;
-      this.player.emit("core_event", {
-        eventName: "core.loadcomplete",
-        url
-      });
-    });
-    this.hls.on(Hls.Events.LEVEL_LOADED, (_, data) => {
-      const { details, stats } = data;
-      this.player.emit("core_event", {
-        eventName: "core.loadcomplete",
-        ...stats,
-        url: details == null ? void 0 : details.url
-      });
-    });
-    this.hls.on(Hls.Events.FRAG_LOADED, (_, data) => {
-      const { frag } = data;
-      this.player.emit("core_event", {
-        eventName: "core.loadcomplete",
-        url: frag.url
-      });
-    });
-    this.hls.on(Hls.Events.FRAG_PARSING_USERDATA, (_, { samples }) => {
-      this.player.emit("core_event", {
-        eventName: "core.sei",
-        sei: samples
-      });
-    });
-    this.hls.on(Hls.Events.MANIFEST_LOADED, (_, { levels, networkDetails }) => {
-      this.player.emit("core_event", {
-        eventName: "core.hlsmanifestloaded",
-        playlist: levels
-      });
-      this.player.emit("core_event", {
-        eventName: "core.loadresponseheaders",
-        headers: networkDetails.headers
-      });
-    });
-    this.hls.on(Hls.Events.LEVEL_LOADED, (_, { details }) => {
-      const dateRanges = {};
-      Object.keys(details.dateRanges).forEach((key) => {
-        dateRanges[key] = details.dateRanges[key].attr["START-DATE"];
-      });
-      this.player.emit("core_event", {
-        eventName: "core.hlslevelloaded",
-        playlist: {
-          ...details,
-          segments: details.fragments,
-          dateRanges
-        }
-      });
-    });
-    this.hls.on(Hls.Events.ERROR, (_, data) => {
-      const { details, fatal, type, response, reason, error } = data;
-      if (!fatal) {
-        return;
-      }
-      let errorCode;
-      let errorType;
-      switch (type) {
-        case Hls.ErrorTypes.NETWORK_ERROR:
-          errorCode = 2100;
-          if (details.includes("TimeOut")) {
-            errorCode = 2101;
-          } else if ((response == null ? void 0 : response.code) === 403) {
-            errorCode = 2103;
-          } else if ((response == null ? void 0 : response.code) === 404) {
-            errorCode = 2104;
-          }
-          this.player.emit("error", {
-            errorType: "network",
-            errorCode,
-            message: (error == null ? void 0 : error.message) || details,
-            originError: data
-          });
-          break;
-        case Hls.ErrorTypes.MEDIA_ERROR:
-          errorType = "media";
-          if (details === Hls.ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR) {
-            errorCode = 5104;
-          } else if (details === Hls.ErrorDetails.FRAG_DECRYPT_ERROR) {
-            errorCode = 5105;
-          } else if (details === Hls.ErrorDetails.FRAG_PARSING_ERROR) {
-            errorCode = 1100;
-            errorType = "manifest";
-          } else if (details === Hls.ErrorDetails.FRAG_GAP) {
-            errorCode = 5104;
-          } else if (details === Hls.ErrorDetails.BUFFER_ADD_CODEC_ERROR) {
-            errorCode = 5200;
-          } else if (details === Hls.ErrorDetails.BUFFER_INCOMPATIBLE_CODECS_ERROR) {
-            errorCode = 5104;
-          } else if (details === Hls.ErrorDetails.BUFFER_APPEND_ERROR) {
-            errorCode = 5201;
-          } else if (details === Hls.ErrorDetails.BUFFER_APPENDING_ERROR) {
-            errorCode = 5201;
-          } else if (details === Hls.ErrorDetails.BUFFER_STALLED_ERROR) {
-            errorCode = 5203;
-          } else if (details === Hls.ErrorDetails.BUFFER_FULL_ERROR) {
-            errorCode = 5203;
-          } else if (details === Hls.ErrorDetails.BUFFER_SEEK_OVER_HOLE) {
-            errorCode = 5202;
-          } else if (details === Hls.ErrorDetails.BUFFER_NUDGE_ON_STALL) {
-            errorCode = 5202;
-          }
-          this.player.emit("error", {
-            errorType: errorType || type,
-            errorCode,
-            message: (error == null ? void 0 : error.message) || details,
-            originError: data
-          });
-          break;
-        case Hls.ErrorTypes.MUX_ERROR:
-          errorCode = 4100;
-          this.player.emit("error", {
-            errorType: "remux",
-            errorCode,
-            message: (error == null ? void 0 : error.message) || details,
-            originError: data
-          });
-          break;
-        case Hls.ErrorTypes.KEY_SYSTEM_ERROR:
-          errorCode = 7111;
-          if (details === Hls.ErrorDetails.KEY_SYSTEM_NO_KEYS) {
-            errorCode = 7103;
-          } else if (details === Hls.ErrorDetails.KEY_SYSTEM_NO_ACCESS) {
-            errorCode = 7101;
-          } else if (details === Hls.ErrorDetails.KEY_SYSTEM_NO_SESSION) {
-            errorCode = 7104;
-          } else if (details === Hls.ErrorDetails.KEY_SYSTEM_NO_CONFIGURED_LICENSE) {
-            errorCode = 7107;
-          } else if (details === Hls.ErrorDetails.KEY_SYSTEM_LICENSE_REQUEST_FAILED) {
-            errorCode = 7108;
-          } else if (details === Hls.ErrorDetails.KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED) {
-            errorCode = 7110;
-          } else if (details === Hls.ErrorDetails.KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED) {
-            errorCode = 7110;
-          } else if (details === Hls.ErrorDetails.KEY_SYSTEM_SESSION_UPDATE_FAILED) {
-            errorCode = 7104;
-          } else if (details === Hls.ErrorDetails.KEY_SYSTEM_STATUS_INTERNAL_ERROR) {
-            errorCode = 7111;
-          }
-          this.player.emit("error", {
-            errorType: "drm",
-            errorCode,
-            message: (error == null ? void 0 : error.message) || reason || details,
-            originError: data
-          });
-          break;
-        default:
-          if (details === Hls.ErrorDetails.LEVEL_SWITCH_ERROR) {
-            errorCode = 2100;
-            errorType = "network";
-          }
-          this.player.emit("error", {
-            errorType: errorType || "other",
-            errorCode,
-            message: (error == null ? void 0 : error.message) || reason || details,
-            originError: data
-          });
-          break;
-      }
-      try {
-        this.hls.stopLoad();
-        this.player.pause();
-      } catch (error2) {
-      }
-    });
-    this.hls.on(Hls.Events.MEDIA_ATTACHED, () => {
-      this.player.emit("sourceopen");
-    });
-    this.hls.on(Hls.Events.BUFFER_APPENDED, () => {
-      this.player.emit("bufferappend");
-    });
+    initHlsEvents(this.hls, this.player);
   }
   afterCreate() {
     const media = this.player.media;
@@ -32535,8 +32776,9 @@ class XgHls extends BasePlugin {
     if (this.hls) {
       this.hls.destroy();
     }
-    const hlsConfig = getHlsConfig(this.config, player.config);
+    const hlsConfig = getHlsConfig(this.config);
     this.hls = new Hls(hlsConfig);
+    this._trackManager = new TrackManager(this.hls, this.player);
     this.initEvt();
     if (player.config.preProcessUrl) {
       const { url: newUrl } = player.config.preProcessUrl(url);
@@ -32550,10 +32792,47 @@ class XgHls extends BasePlugin {
     media.removeEventListener("play", this._onPlay);
     media.addEventListener("play", this._onPlay);
   }
+  switchUrl(url, { startTime, bitrate, seamless }) {
+    this.hls.loadSource(url);
+    if (startTime !== void 0) {
+      const media = this.player.media;
+      media.currentTime = startTime;
+    }
+  }
+  // Audio Track Methods
+  getAudioTracks() {
+    return this._trackManager.getAudioTracks();
+  }
+  getCurrentAudioTrack() {
+    return this._trackManager.getCurrentAudioTrack();
+  }
+  switchAudioTrack(trackId) {
+    return this._trackManager.switchAudioTrack(trackId);
+  }
+  // Subtitle Track Methods
+  getSubtitleTracks() {
+    return this._trackManager.getSubtitleTracks();
+  }
+  getAllSubtitleTracks() {
+    return this._trackManager.getAllSubtitleTracks();
+  }
+  getCurrentSubtitleTrack() {
+    return this._trackManager.getCurrentSubtitleTrack();
+  }
+  switchSubtitleTrack(trackId) {
+    return this._trackManager.switchSubtitleTrack(trackId);
+  }
+  getSubtitleDisplay() {
+    return this._trackManager.getSubtitleDisplay();
+  }
+  setSubtitleDisplay(enabled) {
+    return this._trackManager.setSubtitleDisplay(enabled);
+  }
   destroy() {
+    var _a;
     clearTimeout(this._tickTimer);
     this.player.off(URL_CHANGE, this.onUrlChange);
-    this.hls.destroy();
+    (_a = this.hls) == null ? void 0 : _a.destroy();
   }
 }
 class HlsPlugin extends XgHls {
@@ -32577,7 +32856,6 @@ class HlsPlugin extends XgHls {
     });
   }
 }
-const DynamicModule = window["VePlayer"].DynamicModule;
 const __PLUGIN_NAME__ = DynamicModule.PluginHlsJs;
 export {
   HlsPlugin,