@volcengine/veplayer 2.6.2 → 2.7.0

package/esm/veplayer.biz.live.development.js

@@ -50,235 +50,6 @@ function create(errorCode, i18n) {
     i18n
   );
 }
-const DynamicModule$4 = window["VePlayer"].DynamicModule;
-const load$5 = window["VePlayer"].load;
-async function isRTMSupported() {
-  const { RtmPlugin } = await load$5(DynamicModule$4.PluginRtm);
-  return RtmPlugin.isSupported();
-}
-async function isRTMSupportCodec(codec = RTMCodec.H264) {
-  const { RtmPlugin } = await load$5(DynamicModule$4.PluginRtm);
-  if (codec === RTMCodec.H264)
-    return RtmPlugin.isSupportedH264();
-  return false;
-}
-const getUrlObject = (url) => {
-  if (!url) {
-    return;
-  }
-  const withoutProtocol = url.startsWith("//");
-  if (withoutProtocol) {
-    url = location.protocol + url;
-  }
-  try {
-    return new URL(url);
-  } catch (error2) {
-    return;
-  }
-};
-const strategy$2 = window["VePlayer"].strategy;
-const util$6 = window["VePlayer"].util;
-const DynamicModule$3 = window["VePlayer"].DynamicModule;
-const load$4 = window["VePlayer"].load;
-const Codec$3 = window["VePlayer"].Codec;
-const Sniffer$4 = window["VePlayer"].Sniffer;
-const rtmStrategy = {
-  options: {},
-  module: DynamicModule$3.PluginRtm
-};
-const generateFallbackUrl = (url) => {
-  if (Sniffer$4.device === "pc") {
-    return url.replace(".sdp", ".flv");
-  } else {
-    return url.replace(".sdp", ".m3u8");
-  }
-};
-const getRtmStrategy = async (options, player, i18n) => {
-  var _a, _b;
-  let backupStrategy;
-  let actualFallbackUrl = "";
-  const { url, playlist } = options;
-  const { fallbackUrl, enableRTMAutoTranscode, ...ret } = options.rtm || {};
-  let { enableFallback = true } = options.rtm || {};
-  if (playlist == null ? void 0 : playlist.length) {
-    enableFallback = false;
-  }
-  const isRTMAutoTranscode = enableRTMAutoTranscode || ((_a = getUrlObject(url)) == null ? void 0 : _a.searchParams.get("enableRTMAutoTranscode")) === "true";
-  if (enableFallback) {
-    if (fallbackUrl) {
-      actualFallbackUrl = fallbackUrl;
-    } else if (isRTMAutoTranscode && url) {
-      actualFallbackUrl = generateFallbackUrl(url);
-    } else {
-      console.warn(
-        create(ErrorCode.EMPTY_RTM_FALLBACK_PARAMETER, i18n).message
-      );
-    }
-  }
-  const backupType = actualFallbackUrl && util$6.getStreamType(actualFallbackUrl);
-  if (backupType === "flv" && util$6.isMseSupported(Codec$3.H264)) {
-    backupStrategy = strategy$2.createFlvMseStrategy(options);
-  } else if (backupType === "hls" && (Sniffer$4.device !== "mobile" || ((_b = options == null ? void 0 : options.hls) == null ? void 0 : _b.enableMSE)) && util$6.isMseSupported(Codec$3.H264)) {
-    backupStrategy = strategy$2.createHlsMseStrategy(options);
-  }
-  const [rtmCdn, backupCdn] = await Promise.all([
-    load$4(rtmStrategy.module).then((module) => {
-      return module.RtmPlugin;
-    }).catch(() => void 0),
-    backupStrategy && load$4(backupStrategy.module).then((module) => {
-      if ((backupStrategy == null ? void 0 : backupStrategy.module) === DynamicModule$3.PluginFlv) {
-        return module.FlvPlugin;
-      } else if ((backupStrategy == null ? void 0 : backupStrategy.module) === DynamicModule$3.PluginHls) {
-        return module.HlsPlugin;
-      }
-    }).catch(() => void 0)
-  ]);
-  if (actualFallbackUrl) {
-    const [RTMSupported, RTMSupportCodec] = await Promise.all([
-      isRTMSupported(),
-      isRTMSupportCodec()
-    ]);
-    if (!RTMSupported || !RTMSupportCodec) {
-      if (player) {
-        player.emit("degrade", {
-          url: actualFallbackUrl,
-          originRtmUrl: url,
-          code: "NOT_SUPPORT",
-          message: "not support rtm or h264",
-          isRTMSupported: RTMSupported,
-          isRTMSupportCodec: RTMSupportCodec
-        });
-      }
-      return {
-        options: {
-          ...(backupStrategy == null ? void 0 : backupStrategy.options) || {},
-          url: actualFallbackUrl,
-          _RTMdegrade: {
-            _originRtmUrl: url,
-            _isRTMSupported: RTMSupported,
-            _isRTMSupportCodec: RTMSupportCodec
-          }
-        },
-        plugins: backupCdn ? [backupCdn] : []
-      };
-    }
-  }
-  return {
-    options: {
-      ...(backupStrategy == null ? void 0 : backupStrategy.options) || {},
-      url: enableRTMAutoTranscode ? util$6.appendSearchParams(url, { enableRTMAutoTranscode: "true" }) : void 0,
-      _RTMdegrade: void 0,
-      rts: {
-        retryCount: 0,
-        ...ret,
-        backupURL: actualFallbackUrl,
-        backupConstruct: backupCdn
-      }
-    },
-    plugins: rtmCdn ? [rtmCdn] : []
-  };
-};
-const Sniffer$3 = window["VePlayer"].Sniffer;
-var DrmType = /* @__PURE__ */ ((DrmType2) => {
-  DrmType2["Fairplay"] = "fairplay";
-  return DrmType2;
-})(DrmType || {});
-function getDrmType(drm) {
-  if ((drm == null ? void 0 : drm.fairplay) && (Sniffer$3.browser === "safari" || Sniffer$3.os.isIos)) {
-    return "fairplay";
-  }
-  return;
-}
-function isMseSupportedWithDrm({
-  drm,
-  streamType
-}) {
-  const drmType = getDrmType(drm);
-  if (!drmType) {
-    return true;
-  }
-  if (drmType === "fairplay" && streamType === "hls") {
-    return false;
-  }
-  return true;
-}
-const Sniffer$2 = window["VePlayer"].Sniffer;
-const Codec$2 = window["VePlayer"].Codec;
-const util$5 = window["VePlayer"].util;
-const { isMMSSupported: isMMSSupported$1, isMseSupported: isMseSupported$1 } = util$5;
-function enableMMS() {
-  return Sniffer$2.os.isIos;
-}
-function isFLVSupported(codec = Codec$2.H264) {
-  const isMediaSourceSupported = enableMMS() ? isMMSSupported$1 : isMseSupported$1;
-  return isMediaSourceSupported(codec);
-}
-const strategy$1 = window["VePlayer"].strategy;
-const load$3 = window["VePlayer"].load;
-const Codec$1 = window["VePlayer"].Codec;
-const util$4 = window["VePlayer"].util;
-const { appendSearchParams } = util$4;
-const getFlvStrategy = async (options) => {
-  var _a, _b, _c, _d, _e, _f;
-  let mseStrategy;
-  let softStrategy;
-  const enableLowLatency = (_a = options == null ? void 0 : options.flv) == null ? void 0 : _a.enableLowLatency;
-  const enableFrameChasing = ((_c = (_b = options == null ? void 0 : options.flv) == null ? void 0 : _b.lowLatency) == null ? void 0 : _c.enableFrameChasing) ?? true;
-  const abrPts = ((_e = (_d = options == null ? void 0 : options.flv) == null ? void 0 : _d.lowLatency) == null ? void 0 : _e.abrPts) ?? "-800";
-  const codec = await strategy$1.getCodec(options);
-  const isSoftDecode = await strategy$1.isSoftDecode(options, codec);
-  if (isSoftDecode) {
-    softStrategy = codec === Codec$1.H265 ? strategy$1.createSoftDecodeH265Strategy() : strategy$1.createSoftDecodeH264Strategy();
-    mseStrategy = strategy$1.createFlvMseStrategy(options);
-  }
-  if (codec === "unknown" ? isFLVSupported(Codec$1.H264) : isFLVSupported(codec)) {
-    mseStrategy = enableMMS() ? strategy$1.createFlvMssStrategy(options) : strategy$1.createFlvMseStrategy(options);
-  }
-  if (!mseStrategy && !softStrategy) {
-    return {};
-  }
-  const [mseModule, softModule] = await Promise.all([
-    (mseStrategy == null ? void 0 : mseStrategy.module) && load$3(mseStrategy.module).catch(() => void 0),
-    (softStrategy == null ? void 0 : softStrategy.module) && load$3(softStrategy.module).catch(() => void 0)
-  ]);
-  (softModule == null ? void 0 : softModule.XGVideoPlugin) && ((_f = softStrategy == null ? void 0 : softStrategy.afterLoad) == null ? void 0 : _f.call(softStrategy, softModule == null ? void 0 : softModule.XGVideoPlugin));
-  const combineOptions = strategy$1.combineOptions([mseStrategy, softStrategy]);
-  const plugins = [];
-  if (enableLowLatency) {
-    combineOptions.url = appendSearchParams(options.url, { abr_pts: abrPts });
-  }
-  if (mseModule) {
-    plugins.push(mseModule.FlvPlugin);
-    if (enableLowLatency && enableFrameChasing) {
-      plugins.push(mseModule.Adaptive);
-    }
-  }
-  return {
-    options: combineOptions,
-    plugins
-  };
-};
-const util$3 = window["VePlayer"].util;
-const strategy = window["VePlayer"].strategy;
-const getTypeStrategy = async (options, player, i18n) => {
-  const type = options.url ? util$3.getStreamType(options.url) : "";
-  if (!type || type === "unknown") {
-    return { options: {}, plugins: [] };
-  }
-  if (type === "rtm") {
-    return await getRtmStrategy(options, player, i18n);
-  }
-  if (type === "flv") {
-    return await getFlvStrategy(options);
-  }
-  if (type === "hls") {
-    if (!isMseSupportedWithDrm({ drm: options.drm, streamType: type })) {
-      return { options: {}, plugins: [] };
-    }
-    return await strategy.getHlsStrategy(options);
-  }
-  return { options: {}, plugins: [] };
-};
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x2) {
   return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
@@ -424,7 +195,7 @@ function RefreshIcon() {
 }
 var refresh = "";
 const Plugin$3 = window["VePlayer"].Plugin;
-const Sniffer$1 = window["VePlayer"].Sniffer;
+const Sniffer$5 = window["VePlayer"].Sniffer;
 const XGEvents = window["VePlayer"].XGEvents;
 const { POSITIONS: POSITIONS$1 } = Plugin$3;
 class Refresh extends Plugin$3 {
@@ -488,7 +259,7 @@ class Refresh extends Plugin$3 {
   }
   _initEvents() {
     this._handleRefresh = debounce$1(this._handleRefresh.bind(this), 200);
-    const event2 = Sniffer$1.device === "mobile" ? "touchend" : "click";
+    const event2 = Sniffer$5.device === "mobile" ? "touchend" : "click";
     this.bind(event2, this._handleRefresh);
     this.show();
   }
@@ -2969,7 +2740,7 @@ function v4(options, buf, offset) {
   }
   return unsafeStringify(rnds);
 }
-const util$2 = window["VePlayer"].util;
+const util$7 = window["VePlayer"].util;
 const DEVICE_ID_KEY = "veplayer_live_device_id";
 const USER_ID_Key = "veplayer_live_user_id";
 const genRandomID2 = (length) => {
@@ -2996,12 +2767,12 @@ const getUserId2 = () => {
   return userId;
 };
 const generateUrlWithSessionId = (url) => {
-  const urlObject = util$2.getUrlObject(url);
+  const urlObject = util$7.getUrlObject(url);
   if (!urlObject) {
     return url ?? "";
   }
   if (!(urlObject == null ? void 0 : urlObject.searchParams.get("_session_id"))) {
-    return util$2.appendSearchParams(url, { _session_id: generateSessionId() });
+    return util$7.appendSearchParams(url, { _session_id: generateSessionId() });
   }
   return url;
 };
@@ -3190,7 +2961,7 @@ function getSoftDecodeRow(data) {
   };
 }
 var infoPanel = "";
-const util$1 = window["VePlayer"].util;
+const util$6 = window["VePlayer"].util;
 const Plugin$1 = window["VePlayer"].Plugin;
 const XGUtil = window["VePlayer"].XGUtil;
 class InfoPanel extends Plugin$1 {
@@ -3210,7 +2981,7 @@ class InfoPanel extends Plugin$1 {
     };
   }
   get _streamType() {
-    return util$1.getStreamType(this.player.config.url);
+    return util$6.getStreamType(this.player.config.url);
   }
   afterCreate() {
     this._playPlugin = this.player.plugins[this._streamType];
@@ -3385,39 +3156,6 @@ const ZH_CN$1 = {
   DECODE_INFO: "软解信息",
   REFRESH: "刷新"
 };
-const DynamicModule$2 = window["VePlayer"].DynamicModule;
-const load$2 = window["VePlayer"].load;
-const getDrmStrategy = async (options, player) => {
-  var _a;
-  const drmType = getDrmType(options.drm);
-  if (options.url && drmType === DrmType.Fairplay) {
-    try {
-      const { getDrmConfig, ...originFairplayConfig } = ((_a = options == null ? void 0 : options.drm) == null ? void 0 : _a.fairplay) ?? {};
-      const [drmPlugin, drmConfig] = await Promise.all([
-        load$2(DynamicModule$2.PluginDrm).then((module) => module.DrmPlugin).catch(() => void 0),
-        getDrmConfig == null ? void 0 : getDrmConfig({
-          url: options.url
-        })
-      ]);
-      const fairplayDrmConfig = Object.assign(
-        {},
-        originFairplayConfig,
-        options == null ? void 0 : options.drm,
-        drmConfig
-      );
-      drmConfig && (player == null ? void 0 : player.updateDrmConfig(drmConfig));
-      return {
-        options: {
-          drm: fairplayDrmConfig
-        },
-        plugins: drmPlugin ? [drmPlugin] : []
-      };
-    } catch (error2) {
-      console.log(error2);
-    }
-  }
-  return {};
-};
 var FUNC_ERROR_TEXT = "Expected a function";
 var PLACEHOLDER = "__lodash_placeholder__";
 var BIND_FLAG = 1, BIND_KEY_FLAG = 2, CURRY_BOUND_FLAG = 4, CURRY_FLAG = 8, CURRY_RIGHT_FLAG = 16, PARTIAL_FLAG = 32, PARTIAL_RIGHT_FLAG = 64, ARY_FLAG = 128, REARG_FLAG = 256, FLIP_FLAG = 512;
@@ -3907,6 +3645,20 @@ function identity(value) {
 curry.placeholder = {};
 var lodash_curry = curry;
 var curry$1 = /* @__PURE__ */ getDefaultExportFromCjs(lodash_curry);
+const getUrlObject = (url) => {
+  if (!url) {
+    return;
+  }
+  const withoutProtocol = url.startsWith("//");
+  if (withoutProtocol) {
+    url = location.protocol + url;
+  }
+  try {
+    return new URL(url);
+  } catch (error2) {
+    return;
+  }
+};
 const isType = curry$1(function(suffix, url) {
   return url == null ? void 0 : url.split("?")[0].toLowerCase().includes(suffix);
 });
@@ -3933,31 +3685,916 @@ function getStreamType(url) {
   }
   return "unknown";
 }
-const DynamicModule$1 = window["VePlayer"].DynamicModule;
-const load$1 = window["VePlayer"].load;
-const getAbrStrategy = async (options) => {
-  var _a, _b;
-  const streamType = options.url && getStreamType(options.url);
-  if (streamType === "rtm") {
-    return {};
-  }
-  const abrOptions = streamType === "flv" ? (_a = options == null ? void 0 : options.flv) == null ? void 0 : _a.abr : (_b = options == null ? void 0 : options.hls) == null ? void 0 : _b.abr;
-  if (!abrOptions) {
-    return {};
-  }
-  const abrPlugin = await load$1(DynamicModule$1.PluginAbr).catch(() => void 0);
-  return {
-    options: {
-      [streamType === "flv" ? "abr" : "hlsabr"]: {
-        ...abrOptions,
-        open: abrOptions.enable ?? true
-      }
-    },
-    plugins: [
-      streamType === "flv" ? abrPlugin == null ? void 0 : abrPlugin.AbrPlugin : abrPlugin == null ? void 0 : abrPlugin.HlsAbrPlugin
-    ]
-  };
+const LiveUrlType = {
+  Hls: "hls",
+  LLHls: "ll-hls",
+  Flv: "flv",
+  Rtm: "rtm",
+  LLFlv: "ll-flv"
 };
+const Sniffer$4 = window["VePlayer"].Sniffer;
+const Codec$4 = window["VePlayer"].Codec;
+const util$5 = window["VePlayer"].util;
+const { isMMSSupported: isMMSSupported$1, isMseSupported: isMseSupported$2 } = util$5;
+function enableMMS() {
+  return Sniffer$4.os.isIos;
+}
+function isFLVSupported(codec = Codec$4.H264) {
+  const isMediaSourceSupported = enableMMS() ? isMMSSupported$1 : isMseSupported$2;
+  return isMediaSourceSupported(codec);
+}
+var FallbackKind = /* @__PURE__ */ ((FallbackKind2) => {
+  FallbackKind2["Error"] = "Error";
+  FallbackKind2["Stall"] = "Stall";
+  return FallbackKind2;
+})(FallbackKind || {});
+class BaseProtocol {
+  constructor(options) {
+    // 下一个 protocol 类
+    __publicField(this, "nextProtocol");
+    __publicField(this, "preProtocol");
+    __publicField(this, "protocolStrategy");
+    __publicField(this, "_fallback");
+    this._fallback = options.fallback;
+  }
+  _getKindFallbackStrategy(kind) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    return ((_c = (_b = (_a = this._fallback) == null ? void 0 : _a.fallbackStrategy) == null ? void 0 : _b[this.protocolType]) == null ? void 0 : _c[kind]) ?? ((_f = (_e = (_d = this._fallback) == null ? void 0 : _d.fallbackStrategy) == null ? void 0 : _e["all"]) == null ? void 0 : _f[kind]) ?? ((_g = this.defaultFallbackStrategy) == null ? void 0 : _g[kind]);
+  }
+  // eslint-disable-next-line @typescript-eslint/member-ordering
+  get errorFallbackStrategy() {
+    return this._getKindFallbackStrategy(
+      "Error"
+      /* Error */
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/member-ordering
+  get stallFallbackStrategy() {
+    return this._getKindFallbackStrategy(
+      "Stall"
+      /* Stall */
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/member-ordering
+  shouldFallbackWhenError(params) {
+    var _a, _b, _c;
+    if ((_a = this.errorFallbackStrategy) == null ? void 0 : _a.shouldFallback) {
+      return (_b = this.errorFallbackStrategy) == null ? void 0 : _b.shouldFallback(
+        this.protocolType,
+        params
+      );
+    }
+    if ((_c = this.errorFallbackStrategy) == null ? void 0 : _c.excludeList) {
+      return !this.errorFallbackStrategy.excludeList.includes(
+        params.error.errorCode
+      );
+    }
+    return false;
+  }
+}
+const strategy$2 = window["VePlayer"].strategy;
+const load$7 = window["VePlayer"].load;
+const Codec$3 = window["VePlayer"].Codec;
+const util$4 = window["VePlayer"].util;
+const { appendSearchParams } = util$4;
+const getFlvStrategy = async (options) => {
+  var _a, _b, _c, _d, _e, _f;
+  let mseStrategy;
+  let softStrategy;
+  const enableLowLatency = (_a = options == null ? void 0 : options.flv) == null ? void 0 : _a.enableLowLatency;
+  const enableFrameChasing = ((_c = (_b = options == null ? void 0 : options.flv) == null ? void 0 : _b.lowLatency) == null ? void 0 : _c.enableFrameChasing) ?? true;
+  const abrPts = ((_e = (_d = options == null ? void 0 : options.flv) == null ? void 0 : _d.lowLatency) == null ? void 0 : _e.abrPts) ?? "-800";
+  const codec = await strategy$2.getCodec(options);
+  const isSoftDecode = await strategy$2.isSoftDecode(options, codec);
+  if (isSoftDecode) {
+    softStrategy = codec === Codec$3.H265 ? strategy$2.createSoftDecodeH265Strategy() : strategy$2.createSoftDecodeH264Strategy();
+    mseStrategy = strategy$2.createFlvMseStrategy(options);
+  }
+  if (codec === "unknown" ? isFLVSupported(Codec$3.H264) : isFLVSupported(codec)) {
+    mseStrategy = enableMMS() ? strategy$2.createFlvMssStrategy(options) : strategy$2.createFlvMseStrategy(options);
+  }
+  if (!mseStrategy && !softStrategy) {
+    return {};
+  }
+  const [mseModule, softModule] = await Promise.all([
+    (mseStrategy == null ? void 0 : mseStrategy.module) && load$7(mseStrategy.module).catch(() => void 0),
+    (softStrategy == null ? void 0 : softStrategy.module) && load$7(softStrategy.module).catch(() => void 0)
+  ]);
+  (softModule == null ? void 0 : softModule.XGVideoPlugin) && ((_f = softStrategy == null ? void 0 : softStrategy.afterLoad) == null ? void 0 : _f.call(softStrategy, softModule == null ? void 0 : softModule.XGVideoPlugin));
+  const combineOptions = strategy$2.combineOptions([mseStrategy, softStrategy]);
+  const plugins = [];
+  if (enableLowLatency) {
+    combineOptions.url = appendSearchParams(options.url, { abr_pts: abrPts });
+  }
+  if (mseModule) {
+    plugins.push(mseModule.FlvPlugin);
+    if (enableLowLatency && enableFrameChasing) {
+      plugins.push(mseModule.Adaptive);
+    }
+  }
+  return {
+    options: combineOptions,
+    plugins
+  };
+};
+const DynamicModule$5 = window["VePlayer"].DynamicModule;
+const load$6 = window["VePlayer"].load;
+class FlvProtocol extends BaseProtocol {
+  static get suffix() {
+    return ".flv";
+  }
+  get protocolType() {
+    return LiveUrlType.Flv;
+  }
+  get defaultFallbackStrategy() {
+    return {};
+  }
+  static generateUrl(urls, {
+    generateUrlFromOtherProtocol: generateUrlFromOtherProtocol2
+  }) {
+    return urls[LiveUrlType.Flv] ?? generateUrlFromOtherProtocol2();
+  }
+  static canGenerateOtherProtocol() {
+    return true;
+  }
+  async canPlay() {
+    return {
+      canPlay: isFLVSupported()
+    };
+  }
+  shouldFallbackWhenStall() {
+    return false;
+  }
+  async getProtocolStrategy(options, {
+    enableSelector
+  }) {
+    return getFlvStrategy(
+      enableSelector ? {
+        ...options,
+        flv: {
+          ...options.flv,
+          enableLowLatency: false
+        }
+      } : options
+    );
+  }
+  async getAbrStrategy(options) {
+    var _a;
+    const abrOptions = (_a = options == null ? void 0 : options.flv) == null ? void 0 : _a.abr;
+    if (!abrOptions) {
+      return {};
+    }
+    const abrPlugin = await load$6(DynamicModule$5.PluginAbr).catch(
+      () => void 0
+    );
+    return {
+      options: {
+        abr: {
+          ...abrOptions,
+          open: abrOptions.enable ?? true
+        }
+      },
+      plugins: [abrPlugin == null ? void 0 : abrPlugin.AbrPlugin]
+    };
+  }
+  getDrmStrategy() {
+    return void 0;
+  }
+}
+class FlvLowLatencyProtocol extends FlvProtocol {
+  get protocolType() {
+    return LiveUrlType.LLFlv;
+  }
+  async getProtocolStrategy(options) {
+    return getFlvStrategy({
+      ...options,
+      flv: {
+        ...options.flv,
+        enableLowLatency: true
+      }
+    });
+  }
+}
+const Sniffer$3 = window["VePlayer"].Sniffer;
+var DrmType = /* @__PURE__ */ ((DrmType2) => {
+  DrmType2["Fairplay"] = "fairplay";
+  return DrmType2;
+})(DrmType || {});
+function getDrmType(drm) {
+  if ((drm == null ? void 0 : drm.fairplay) && (Sniffer$3.browser === "safari" || Sniffer$3.os.isIos)) {
+    return "fairplay";
+  }
+  return;
+}
+function isMseSupportedWithDrm({
+  drm,
+  streamType
+}) {
+  const drmType = getDrmType(drm);
+  if (!drmType) {
+    return true;
+  }
+  if (drmType === "fairplay" && streamType === "hls") {
+    return false;
+  }
+  return true;
+}
+const Codec$2 = window["VePlayer"].Codec;
+const strategy$1 = window["VePlayer"].strategy;
+const load$5 = window["VePlayer"].load;
+const Sniffer$2 = window["VePlayer"].Sniffer;
+const util$3 = window["VePlayer"].util;
+const { isMseSupported: isMseSupported$1 } = util$3;
+function enableHlsJs(options) {
+  var _a, _b;
+  if ((_a = options == null ? void 0 : options.hls) == null ? void 0 : _a.enableHlsJs) {
+    return true;
+  }
+  if (((_b = options == null ? void 0 : options.ad) == null ? void 0 : _b.adType) === "ssai") {
+    return true;
+  }
+  return false;
+}
+const getHlsStrategy = async (options) => {
+  var _a, _b;
+  let mseStrategy;
+  let softStrategy;
+  if (!isMseSupportedWithDrm({ drm: options.drm, streamType: "hls" })) {
+    return { options: {}, plugins: [] };
+  }
+  const codec = await strategy$1.getCodec(options);
+  const isSoftDecode = await strategy$1.isSoftDecode(options, codec);
+  const useHlsJs = enableHlsJs(options);
+  if (isSoftDecode) {
+    softStrategy = codec === Codec$2.H265 ? strategy$1.createSoftDecodeH265Strategy() : strategy$1.createSoftDecodeH264Strategy();
+    mseStrategy = strategy$1.createHlsMseStrategy(options, useHlsJs);
+  }
+  if ((Sniffer$2.device !== "mobile" || ((_a = options == null ? void 0 : options.hls) == null ? void 0 : _a.enableMSE)) && (codec === "unknown" ? isMseSupported$1(Codec$2.H264) : isMseSupported$1(codec))) {
+    mseStrategy = strategy$1.createHlsMseStrategy(options, useHlsJs);
+  }
+  if (!mseStrategy && !softStrategy) {
+    return {};
+  }
+  const [mseModule, softModule] = await Promise.all([
+    (mseStrategy == null ? void 0 : mseStrategy.module) && load$5(mseStrategy.module).catch(() => void 0),
+    (softStrategy == null ? void 0 : softStrategy.module) && load$5(softStrategy.module).catch(() => void 0)
+  ]);
+  (softModule == null ? void 0 : softModule.XGVideoPlugin) && ((_b = softStrategy == null ? void 0 : softStrategy.afterLoad) == null ? void 0 : _b.call(softStrategy, softModule == null ? void 0 : softModule.XGVideoPlugin));
+  const combineOptions = strategy$1.combineOptions([mseStrategy, softStrategy]);
+  return {
+    options: combineOptions,
+    plugins: (mseModule == null ? void 0 : mseModule.HlsPlugin) ? [mseModule.HlsPlugin] : []
+  };
+};
+function getType(definition) {
+  if (typeof definition === "string") {
+    return getStreamType(definition);
+  }
+  if (definition.type) {
+    return definition.type;
+  }
+  return getStreamType(definition.url);
+}
+function pushToEmpty(obj, key, value) {
+  if (!obj[key]) {
+    obj[key] = [];
+  }
+  obj[key].push(value);
+}
+function splitPlaylist(playlist) {
+  return playlist.reduce((pre, source) => {
+    const definitionMap = source.definitions.reduce(
+      (preDefinition, definition) => {
+        const type = getType(definition);
+        pushToEmpty(preDefinition, type, definition);
+        return preDefinition;
+      },
+      {}
+    );
+    Object.keys(definitionMap).map((type) => {
+      pushToEmpty(pre, type, {
+        ...source,
+        definitions: definitionMap[type]
+      });
+    });
+    return pre;
+  }, {});
+}
+function generateUrlFromOtherProtocol(playlist, suffix, targetSuffix) {
+  return modifyPlaylistUrl(playlist, (url) => {
+    return url.replace(suffix, targetSuffix);
+  });
+}
+function modifyPlaylistUrl(playlist, callback) {
+  const newPlaylist = [];
+  playlist == null ? void 0 : playlist.forEach((source) => {
+    const definitions = [];
+    source.definitions.forEach((definition) => {
+      var _a;
+      if (typeof definition === "string") {
+        definitions.push(callback(definition));
+      } else {
+        definitions.push({
+          ...definition,
+          url: callback(definition.url),
+          fallbackUrls: (_a = definition.fallbackUrls) == null ? void 0 : _a.map(
+            (fallbackUrl) => callback(fallbackUrl)
+          )
+        });
+      }
+    });
+    newPlaylist.push({
+      ...source,
+      definitions
+    });
+  });
+  return newPlaylist;
+}
+const DynamicModule$4 = window["VePlayer"].DynamicModule;
+const load$4 = window["VePlayer"].load;
+const getDrmStrategy = async (options, player) => {
+  var _a;
+  const drmType = getDrmType(options.drm);
+  if (options.url && drmType === DrmType.Fairplay) {
+    try {
+      const { getDrmConfig, ...originFairplayConfig } = ((_a = options == null ? void 0 : options.drm) == null ? void 0 : _a.fairplay) ?? {};
+      const [drmPlugin, drmConfig] = await Promise.all([
+        load$4(DynamicModule$4.PluginDrm).then((module) => module.DrmPlugin).catch(() => void 0),
+        getDrmConfig == null ? void 0 : getDrmConfig({
+          url: options.url
+        })
+      ]);
+      const fairplayDrmConfig = Object.assign(
+        {},
+        originFairplayConfig,
+        options == null ? void 0 : options.drm,
+        drmConfig
+      );
+      drmConfig && (player == null ? void 0 : player.updateDrmConfig(drmConfig));
+      return {
+        options: {
+          drm: fairplayDrmConfig
+        },
+        plugins: drmPlugin ? [drmPlugin] : []
+      };
+    } catch (error2) {
+      console.log(error2);
+    }
+  }
+  return {};
+};
+const DynamicModule$3 = window["VePlayer"].DynamicModule;
+const load$3 = window["VePlayer"].load;
+const util$2 = window["VePlayer"].util;
+class HlsProtocol extends BaseProtocol {
+  static get suffix() {
+    return ".m3u8";
+  }
+  get protocolType() {
+    return LiveUrlType.Hls;
+  }
+  get defaultFallbackStrategy() {
+    return {};
+  }
+  static canGenerateOtherProtocol() {
+    return true;
+  }
+  static generateUrl(urls, {
+    generateUrlFromOtherProtocol: generateUrlFromOtherProtocol2
+  }) {
+    if (urls[LiveUrlType.Hls]) {
+      return urls[LiveUrlType.Hls];
+    }
+    if (urls[LiveUrlType.LLHls]) {
+      return modifyPlaylistUrl(urls[LiveUrlType.LLHls], (url) => {
+        return util$2.appendSearchParams(url, {
+          fpkey_normal_hls: "1"
+        });
+      });
+    }
+    return generateUrlFromOtherProtocol2();
+  }
+  async canPlay() {
+    return { canPlay: true };
+  }
+  shouldFallbackWhenStall() {
+    return false;
+  }
+  async getProtocolStrategy(options) {
+    return getHlsStrategy(options);
+  }
+  async getAbrStrategy(options) {
+    var _a;
+    const abrOptions = (_a = options == null ? void 0 : options.hls) == null ? void 0 : _a.abr;
+    if (!abrOptions) {
+      return {};
+    }
+    const abrPlugin = await load$3(DynamicModule$3.PluginAbr).catch(
+      () => void 0
+    );
+    return {
+      options: {
+        hlsabr: {
+          ...abrOptions,
+          open: abrOptions.enable ?? true
+        }
+      },
+      plugins: [abrPlugin == null ? void 0 : abrPlugin.HlsAbrPlugin]
+    };
+  }
+  getDrmStrategy(options, player) {
+    return getDrmStrategy(options, player);
+  }
+}
+class HlsLowLatencyProtocol extends BaseProtocol {
+  static get suffix() {
+    return ".m3u8";
+  }
+  get protocolType() {
+    return LiveUrlType.LLHls;
+  }
+  get defaultFallbackStrategy() {
+    return {};
+  }
+  static generateUrl(urls) {
+    return urls[LiveUrlType.LLHls];
+  }
+  static canGenerateOtherProtocol() {
+    return true;
+  }
+  async canPlay() {
+    return { canPlay: true };
+  }
+  shouldFallbackWhenStall() {
+    return false;
+  }
+  async getProtocolStrategy(options) {
+    return getHlsStrategy(options);
+  }
+  getAbrStrategy() {
+    return void 0;
+  }
+  getDrmStrategy() {
+    return void 0;
+  }
+}
+const DynamicModule$2 = window["VePlayer"].DynamicModule;
+const load$2 = window["VePlayer"].load;
+async function isRTMSupported() {
+  const { RtmPlugin } = await load$2(DynamicModule$2.PluginRtm);
+  return RtmPlugin.isSupported();
+}
+async function isRTMSupportCodec(codec = RTMCodec.H264) {
+  const { RtmPlugin } = await load$2(DynamicModule$2.PluginRtm);
+  if (codec === RTMCodec.H264)
+    return RtmPlugin.isSupportedH264();
+  return false;
+}
+const strategy = window["VePlayer"].strategy;
+const util$1 = window["VePlayer"].util;
+const DynamicModule$1 = window["VePlayer"].DynamicModule;
+const load$1 = window["VePlayer"].load;
+const Codec$1 = window["VePlayer"].Codec;
+const Sniffer$1 = window["VePlayer"].Sniffer;
+const rtmStrategy = {
+  options: {},
+  module: DynamicModule$1.PluginRtm
+};
+const generateFallbackUrl = (url) => {
+  if (Sniffer$1.device === "pc") {
+    return url.replace(".sdp", ".flv");
+  } else {
+    return url.replace(".sdp", ".m3u8");
+  }
+};
+const getRtmStrategy = async (options, player, i18n) => {
+  var _a, _b;
+  let backupStrategy;
+  let actualFallbackUrl = "";
+  const { url, playlist } = options;
+  const { fallbackUrl, enableRTMAutoTranscode, ...ret } = options.rtm || {};
+  let { enableFallback = true } = options.rtm || {};
+  if (playlist == null ? void 0 : playlist.length) {
+    enableFallback = false;
+  }
+  const isRTMAutoTranscode = enableRTMAutoTranscode || ((_a = getUrlObject(url)) == null ? void 0 : _a.searchParams.get("enableRTMAutoTranscode")) === "true";
+  if (enableFallback) {
+    if (fallbackUrl) {
+      actualFallbackUrl = fallbackUrl;
+    } else if (isRTMAutoTranscode && url) {
+      actualFallbackUrl = generateFallbackUrl(url);
+    } else {
+      console.warn(
+        create(ErrorCode.EMPTY_RTM_FALLBACK_PARAMETER, i18n).message
+      );
+    }
+  }
+  const backupType = actualFallbackUrl && util$1.getStreamType(actualFallbackUrl);
+  if (backupType === "flv" && util$1.isMseSupported(Codec$1.H264)) {
+    backupStrategy = strategy.createFlvMseStrategy(options);
+  } else if (backupType === "hls" && (Sniffer$1.device !== "mobile" || ((_b = options == null ? void 0 : options.hls) == null ? void 0 : _b.enableMSE)) && util$1.isMseSupported(Codec$1.H264)) {
+    backupStrategy = strategy.createHlsMseStrategy(options);
+  }
+  const [rtmCdn, backupCdn] = await Promise.all([
+    load$1(rtmStrategy.module).then((module) => {
+      return module.RtmPlugin;
+    }).catch(() => void 0),
+    backupStrategy && load$1(backupStrategy.module).then((module) => {
+      if ((backupStrategy == null ? void 0 : backupStrategy.module) === DynamicModule$1.PluginFlv) {
+        return module.FlvPlugin;
+      } else if ((backupStrategy == null ? void 0 : backupStrategy.module) === DynamicModule$1.PluginHls) {
+        return module.HlsPlugin;
+      }
+    }).catch(() => void 0)
+  ]);
+  if (actualFallbackUrl) {
+    const [RTMSupported, RTMSupportCodec] = await Promise.all([
+      isRTMSupported(),
+      isRTMSupportCodec()
+    ]);
+    if (!RTMSupported || !RTMSupportCodec) {
+      if (player) {
+        player.emit("degrade", {
+          url: actualFallbackUrl,
+          originRtmUrl: url,
+          code: "NOT_SUPPORT",
+          message: "not support rtm or h264",
+          isRTMSupported: RTMSupported,
+          isRTMSupportCodec: RTMSupportCodec
+        });
+      }
+      return {
+        options: {
+          ...(backupStrategy == null ? void 0 : backupStrategy.options) || {},
+          url: actualFallbackUrl,
+          _RTMdegrade: {
+            _originRtmUrl: url,
+            _isRTMSupported: RTMSupported,
+            _isRTMSupportCodec: RTMSupportCodec
+          }
+        },
+        plugins: backupCdn ? [backupCdn] : []
+      };
+    }
+  }
+  return {
+    options: {
+      ...(backupStrategy == null ? void 0 : backupStrategy.options) || {},
+      url: enableRTMAutoTranscode ? util$1.appendSearchParams(url, { enableRTMAutoTranscode: "true" }) : void 0,
+      _RTMdegrade: void 0,
+      rts: {
+        retryCount: 0,
+        ...ret,
+        backupURL: actualFallbackUrl,
+        backupConstruct: backupCdn
+      }
+    },
+    plugins: rtmCdn ? [rtmCdn] : []
+  };
+};
+class RtmProtocol extends BaseProtocol {
+  static get suffix() {
+    return ".sdp";
+  }
+  get protocolType() {
+    return LiveUrlType.Rtm;
+  }
+  get defaultFallbackStrategy() {
+    return { [FallbackKind.Error]: { shouldFallback: () => true } };
+  }
+  static canGenerateOtherProtocol(options) {
+    var _a;
+    return (_a = options.rtm) == null ? void 0 : _a.enableRTMAutoTranscode;
+  }
+  static generateUrl(urls, {
+    generateUrlFromOtherProtocol: generateUrlFromOtherProtocol2,
+    options
+  }) {
+    var _a;
+    if (urls[LiveUrlType.Rtm]) {
+      return urls[LiveUrlType.Rtm];
+    }
+    if ((_a = options.rtm) == null ? void 0 : _a.enableRTMAutoTranscode) {
+      return generateUrlFromOtherProtocol2();
+    }
+    console.warn("生成 rtm 地址失败。请传入 rtm 播放地址，或开启自动转码");
+    return;
+  }
+  async canPlay() {
+    const [isSupported, isSupportCodec] = await Promise.all([
+      isRTMSupported(),
+      isRTMSupportCodec()
+    ]);
+    return {
+      canPlay: isSupported && isSupportCodec
+    };
+  }
+  shouldFallbackWhenStall() {
+    return false;
+  }
+  async getProtocolStrategy(options, {
+    player,
+    i18n,
+    enableSelector
+  }) {
+    this.protocolStrategy = await getRtmStrategy(
+      enableSelector ? {
+        options,
+        rtm: {
+          ...options.rtm,
+          enableFallback: false
+        }
+      } : options,
+      player,
+      i18n
+    );
+    return this.protocolStrategy;
+  }
+  getAbrStrategy() {
+    return void 0;
+  }
+  getDrmStrategy() {
+    return void 0;
+  }
+}
+class ProtocolSelector {
+  constructor({ queue, streams, options }) {
+    // 链开始的类
+    // start?: AbstractProtocol;
+    // 链结束的类，也是当前正在播放的类型
+    __publicField(this, "current");
+    // 降级顺序
+    __publicField(this, "_queue");
+    __publicField(this, "_streams");
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    __publicField(this, "_options");
+    this._queue = queue;
+    this._streams = streams;
+    this._options = options;
+    this.current = this._getStartProtocol();
+  }
+  // 获取最终返回的播放类型和参数。
+  async getProtocol() {
+    if (!this.current) {
+      return;
+    }
+    const { canPlay } = await this.current.canPlay() ?? {};
+    if (canPlay) {
+      return this.current;
+    }
+    this.next();
+    return this.getProtocol();
+  }
+  // 降级时，将指针指到上次结束的位置
+  next() {
+    var _a;
+    this.current = (_a = this.current) == null ? void 0 : _a.nextProtocol;
+  }
+  // 生成责任链
+  _getStartProtocol() {
+    let nextProtocol;
+    for (let index = this._queue.length - 1; index >= 0; index--) {
+      const type = this._queue[index];
+      const protocol = this._streams[type];
+      if (protocol) {
+        if (nextProtocol) {
+          nextProtocol.preProtocol = protocol;
+          protocol.nextProtocol = nextProtocol;
+        }
+        nextProtocol = protocol;
+      }
+    }
+    return nextProtocol;
+  }
+}
+const _LowLatencySelector = class extends ProtocolSelector {
+  // 目前默认传入了默认的低延迟选择顺序，
+  // 也可以支持自定义配置
+  constructor({
+    streams,
+    options
+  }) {
+    super({
+      queue: _LowLatencySelector.queue,
+      streams,
+      options
+    });
+  }
+};
+let LowLatencySelector = _LowLatencySelector;
+__publicField(LowLatencySelector, "queue", [
+  LiveUrlType.Rtm,
+  LiveUrlType.LLFlv,
+  LiveUrlType.Flv,
+  LiveUrlType.LLHls,
+  LiveUrlType.Hls
+]);
+class CustomSelector extends ProtocolSelector {
+  constructor({
+    streams,
+    options
+  }) {
+    var _a;
+    super({
+      queue: (_a = options.fallback) == null ? void 0 : _a.fallbackOrder,
+      streams,
+      options
+    });
+  }
+}
+__publicField(CustomSelector, "queue");
+const _ProtocolManager = class {
+  constructor(options) {
+    __publicField(this, "_options");
+    __publicField(this, "_selector");
+    __publicField(this, "_protocol");
+    __publicField(this, "_playlistMap", {});
+    this._options = options;
+    this._init({
+      url: options.url,
+      playlist: options.playlist
+    });
+  }
+  get enableSelector() {
+    return !!this._selector;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  get playlist() {
+    var _a;
+    return ((_a = this._protocol) == null ? void 0 : _a.protocolType) && this._playlistMap ? this._playlistMap[this._protocol.protocolType] : void 0;
+  }
+  static async create(options) {
+    const protocolManager = new _ProtocolManager(options);
+    await protocolManager.getProtocol();
+    return protocolManager;
+  }
+  static _generateProtocolMap(queue, splittedPlaylist, options) {
+    const protocolMap = {};
+    const playlistMap = {};
+    const baseGenerateProtocol = queue.find((type) => {
+      return _ProtocolManager._protocolMap[type].canGenerateOtherProtocol(options) && splittedPlaylist[type];
+    });
+    queue.forEach((protocolType) => {
+      var _a;
+      const playlist = ((_a = _ProtocolManager._protocolMap[protocolType]) == null ? void 0 : _a.generateUrl(
+        splittedPlaylist,
+        {
+          generateUrlFromOtherProtocol: () => {
+            if (!baseGenerateProtocol) {
+              return;
+            }
+            return generateUrlFromOtherProtocol(
+              splittedPlaylist[baseGenerateProtocol],
+              _ProtocolManager._protocolMap[baseGenerateProtocol].suffix,
+              _ProtocolManager._protocolMap[protocolType].suffix
+            );
+          },
+          options
+        }
+      )) ?? splittedPlaylist[protocolType];
+      if (playlist) {
+        playlistMap[protocolType] = playlist;
+        protocolMap[protocolType] = new _ProtocolManager._protocolMap[protocolType](options);
+      }
+    });
+    return { protocolMap, playlistMap };
+  }
+  async getProtocol() {
+    if (this._selector) {
+      this._protocol = await this._selector.getProtocol();
+    }
+    return this._protocol;
+  }
+  async update({
+    url,
+    playlist
+  }) {
+    this._options = { ...this._options, url, playlist };
+    this._init({
+      url,
+      playlist
+    });
+    await this.getProtocol();
+  }
+  async next() {
+    if (!this._selector) {
+      return;
+    }
+    this._selector.next();
+    await this.getProtocol();
+    return this._protocol;
+  }
+  async getStrategy(player, i18n) {
+    var _a, _b, _c;
+    const protocol = this._protocol;
+    const [typeStrategy, drmStrategy, abrStrategy] = await Promise.all([
+      protocol == null ? void 0 : protocol.getProtocolStrategy(this._options, {
+        player,
+        i18n,
+        enableSelector: !!this._selector
+      }),
+      (_a = protocol == null ? void 0 : protocol.getDrmStrategy) == null ? void 0 : _a.call(protocol, this._options, player),
+      (_b = protocol == null ? void 0 : protocol.getAbrStrategy) == null ? void 0 : _b.call(protocol, this._options)
+    ]);
+    const { options, plugins } = typeStrategy ?? {};
+    const { options: drmOptions, plugins: drmPlugins } = drmStrategy ?? {};
+    const { options: abrOptions, plugins: abrPlugins } = abrStrategy ?? {};
+    return {
+      options: Object.assign({}, options, drmOptions, abrOptions),
+      plugins: [
+        ...plugins ?? [],
+        ...drmPlugins ?? [],
+        ...abrPlugins ?? []
+      ],
+      useSrc: !((_c = typeStrategy == null ? void 0 : typeStrategy.plugins) == null ? void 0 : _c.length),
+      protocol: protocol == null ? void 0 : protocol.protocolType
+    };
+  }
+  _init({
+    url,
+    playlist
+  }) {
+    var _a;
+    if (playlist) {
+      const splittedPlaylist = splitPlaylist(playlist);
+      const Selector = this._options.latencyMode === "low" ? LowLatencySelector : CustomSelector;
+      const queue = (Selector == null ? void 0 : Selector.queue) ?? ((_a = this._options.fallback) == null ? void 0 : _a.fallbackOrder);
+      if (queue == null ? void 0 : queue.length) {
+        const { protocolMap, playlistMap } = _ProtocolManager._generateProtocolMap(
+          queue,
+          splittedPlaylist,
+          this._options
+        );
+        this._playlistMap = playlistMap;
+        this._selector = new Selector({
+          streams: protocolMap,
+          options: this._options
+        });
+        return;
+      }
+      this._playlistMap = splittedPlaylist;
+      this._initSingleProtocol(Object.keys(splittedPlaylist)[0]);
+    } else if (url) {
+      this._initSingleProtocol(getStreamType(url));
+    }
+  }
+  _initSingleProtocol(protocol) {
+    if (protocol) {
+      this._protocol = new _ProtocolManager._protocolMap[protocol](
+        this._options
+      );
+    }
+  }
+};
+let ProtocolManager = _ProtocolManager;
+__publicField(ProtocolManager, "_protocolMap", {
+  [LiveUrlType.Flv]: FlvProtocol,
+  [LiveUrlType.LLFlv]: FlvLowLatencyProtocol,
+  [LiveUrlType.Hls]: HlsProtocol,
+  [LiveUrlType.LLHls]: HlsLowLatencyProtocol,
+  [LiveUrlType.Rtm]: RtmProtocol
+});
+class Fallback {
+  constructor() {
+    __publicField(this, "player");
+    __publicField(this, "protocolManager");
+    __publicField(this, "beforeFallbackError", async (error2) => {
+      var _a, _b, _c, _d, _e, _f;
+      if (!((_b = (_a = this.protocolManager) == null ? void 0 : _a.protocol) == null ? void 0 : _b.shouldFallbackWhenError({ error: error2 })) || !((_d = (_c = this.protocolManager) == null ? void 0 : _c.protocol) == null ? void 0 : _d.nextProtocol)) {
+        return { canEmitError: true };
+      }
+      const nextProtocol = await ((_e = this.protocolManager) == null ? void 0 : _e.next());
+      if (!nextProtocol || !((_f = this.protocolManager) == null ? void 0 : _f.playlist)) {
+        return { canEmitError: true };
+      }
+      this.fallback();
+      return { canEmitError: false };
+    });
+  }
+  initErrorFallback(player, protocolManager) {
+    this.player = player;
+    this.protocolManager = protocolManager;
+  }
+  async fallback() {
+    var _a, _b, _c, _d;
+    if (!((_a = this.protocolManager) == null ? void 0 : _a.playlist))
+      return;
+    const definition = (_b = this.player) == null ? void 0 : _b.definition;
+    const source = (_c = this.player) == null ? void 0 : _c.source;
+    (_d = this.player) == null ? void 0 : _d.updatePlaylist(
+      this.protocolManager.playlist,
+      {
+        definition,
+        source
+      },
+      false
+    );
+  }
+}
+const fallback = new Fallback();
 const DEFAULT_PLUGINS = window["VePlayer"].DEFAULT_PLUGINS;
 const VePlayerBase = window["VePlayer"].VePlayerBase;
 const VeI18n = window["VePlayer"].VeI18n;
@@ -3992,6 +4629,7 @@ class VePlayerLive extends VePlayerBase {
    */
   constructor(options) {
     super(options);
+    __publicField(this, "_protocolManager");
   }
   /** {zh}
    * @brief 获取已经播放的时长，不包含暂停和等待时间，单位为秒。
@@ -4182,6 +4820,13 @@ class VePlayerLive extends VePlayerBase {
     var _a, _b, _c;
     return (_c = (_b = (_a = this._player) == null ? void 0 : _a.plugins) == null ? void 0 : _b.hls) == null ? void 0 : _c.getStats();
   }
+  async updatePlaylist(playlist, target, needUpdateProtocol = true) {
+    var _a;
+    if (needUpdateProtocol) {
+      await ((_a = this._protocolManager) == null ? void 0 : _a.update({ playlist }));
+    }
+    return super.updatePlaylist(playlist, target);
+  }
 }
 async function createLivePlayer(options) {
   var _a, _b, _c, _d;
@@ -4200,10 +4845,16 @@ async function createLivePlayer(options) {
     ...options,
     plugins: [...LIVE_DEFAULT_PLUGINS, ...options.plugins ?? []]
   };
+  const protocolManager = await ProtocolManager.create(finalOptions);
+  if (!options.url && !(protocolManager == null ? void 0 : protocolManager.playlist)) {
+    throw create(ErrorCode.INVALID_PARAMETER, i18n);
+  }
   player = await VePlayerBase.create(
     {
       ...LIVE_DEFAULT_OPTIONS,
       ...finalOptions,
+      playlist: protocolManager == null ? void 0 : protocolManager.playlist,
+      beforeFallbackError: fallback.beforeFallbackError,
       isLive: true,
       i18nManager: i18n,
       preProcessUrl: (url) => {
@@ -4215,44 +4866,16 @@ async function createLivePlayer(options) {
         };
       },
       async preparePlugins(url) {
-        var _a2;
-        const [typeStrategy, drmStrategy, abrStrategy] = await Promise.all([
-          getTypeStrategy(
-            {
-              ...finalOptions,
-              url
-            },
-            player,
-            i18n
-          ),
-          getDrmStrategy(
-            {
-              ...finalOptions,
-              url
-            },
-            player
-          ),
-          getAbrStrategy({
-            ...finalOptions,
-            url
-          })
-        ]);
-        const { options: options2, plugins } = typeStrategy ?? {};
-        const { options: drmOptions, plugins: drmPlugins } = drmStrategy ?? {};
-        const { options: abrOptions, plugins: abrPlugins } = abrStrategy ?? {};
-        return {
-          options: Object.assign({}, options2, drmOptions, abrOptions),
-          plugins: [
-            ...plugins ?? [],
-            ...drmPlugins ?? [],
-            ...abrPlugins ?? []
-          ],
-          useSrc: !((_a2 = typeStrategy.plugins) == null ? void 0 : _a2.length)
-        };
+        if (!protocolManager.enableSelector) {
+          await protocolManager.update({ url });
+        }
+        return protocolManager.getStrategy(player, i18n);
       }
     },
     VePlayerLive
   );
+  player._protocolManager = protocolManager;
+  fallback.initErrorFallback(player, protocolManager);
   if (player) {
     const RTMDegrade = (_d = (_c = player == null ? void 0 : player._player) == null ? void 0 : _c.config) == null ? void 0 : _d._RTMdegrade;
     if (RTMDegrade) {