artplayer-plugin-p2p 1.0.0

package/dist/index.mjs

@@ -0,0 +1,677 @@
+import {
+  BANDWIDTH_WINDOW_MS,
+  DEFAULT_FATAL_RETRY_MAX,
+  DEFAULT_TYPE,
+  P2PStatsEngine,
+  P2P_EVENT_BRIDGE_MAP,
+  STATS_POLLING_MS,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  applyRuntimeToggle,
+  mergeCoreConfig,
+  resolveOptions
+} from "./chunk-IX2RPNML.mjs";
+
+// src/index.ts
+import Hls2 from "hls.js";
+
+// src/controller.ts
+import Hls from "hls.js";
+
+// src/bridge.ts
+function attachEventBridge(art, engine, stats) {
+  const subscribe = engine.addEventListener.bind(engine);
+  for (const [eventName, artEventName] of Object.entries(P2P_EVENT_BRIDGE_MAP)) {
+    subscribe(eventName, (...args) => {
+      art.emit(artEventName, ...args);
+    });
+  }
+  engine.addEventListener("onChunkDownloaded", (bytesLength, downloadSource) => {
+    stats.recordDownload(bytesLength, downloadSource);
+  });
+  engine.addEventListener("onChunkUploaded", (bytesLength) => {
+    stats.recordUpload(bytesLength);
+  });
+  engine.addEventListener("onPeerConnect", () => {
+    stats.recordPeerConnect();
+  });
+  engine.addEventListener("onPeerClose", () => {
+    stats.recordPeerClose();
+  });
+}
+
+// src/engine.ts
+import { HlsJsP2PEngine } from "p2p-media-loader-hlsjs";
+
+// src/recovery.ts
+var _retryCount, _isMediaRecoveryAttempted, _options, _FatalRecoveryPolicy_instances, handleFatal_fn;
+var FatalRecoveryPolicy = class {
+  /**
+   * @param hls - 目标 hls.js 实例
+   * @param hlsConstructor - hls.js 构造器（Events/ErrorTypes 枚举来源，
+   *   避免本模块引入 hls.js 运行时值以保持可移植性）
+   * @param options - 回调集合
+   */
+  constructor(hls, hlsConstructor, options) {
+    __privateAdd(this, _FatalRecoveryPolicy_instances);
+    __privateAdd(this, _retryCount, 0);
+    __privateAdd(this, _isMediaRecoveryAttempted, false);
+    __privateAdd(this, _options);
+    __privateSet(this, _options, options);
+    hls.on(hlsConstructor.Events.ERROR, (_event, data) => {
+      if (!data.fatal) return;
+      __privateMethod(this, _FatalRecoveryPolicy_instances, handleFatal_fn).call(this, hls, hlsConstructor, data);
+    });
+  }
+};
+_retryCount = new WeakMap();
+_isMediaRecoveryAttempted = new WeakMap();
+_options = new WeakMap();
+_FatalRecoveryPolicy_instances = new WeakSet();
+/**
+ * fatal 分级处理
+ *
+ * 网络级：重新拉起加载；媒体级：软恢复（连续失败时切换音频编解码）；
+ * 其他：软恢复无效，交由上层重建。超限后停止一切动作，
+ * 仅保留通知，由宿主决策后续（如提示用户或换源）
+ */
+handleFatal_fn = function(hls, hlsConstructor, data) {
+  const { retryMax, onFatalError, onUnrecoverable } = __privateGet(this, _options);
+  if (__privateGet(this, _retryCount) >= retryMax) {
+    onFatalError(data, __privateGet(this, _retryCount));
+    return;
+  }
+  __privateSet(this, _retryCount, __privateGet(this, _retryCount) + 1);
+  onFatalError(data, __privateGet(this, _retryCount));
+  const { ErrorTypes } = hlsConstructor;
+  if (data.type === ErrorTypes.NETWORK_ERROR) {
+    hls.startLoad();
+  } else if (data.type === ErrorTypes.MEDIA_ERROR) {
+    if (__privateGet(this, _isMediaRecoveryAttempted)) {
+      hls.swapAudioCodec();
+    }
+    hls.recoverMediaError();
+    __privateSet(this, _isMediaRecoveryAttempted, true);
+  } else {
+    onUnrecoverable(data, __privateGet(this, _retryCount));
+  }
+};
+
+// src/engine.ts
+var hlsWithP2PCache = /* @__PURE__ */ new WeakMap();
+function getHlsWithP2PClass(hlsConstructor) {
+  let cached = hlsWithP2PCache.get(hlsConstructor);
+  if (!cached) {
+    cached = HlsJsP2PEngine.injectMixin(hlsConstructor);
+    hlsWithP2PCache.set(hlsConstructor, cached);
+  }
+  return cached;
+}
+function createHlsWithP2P(options, hlsConstructor, hooks) {
+  const HlsWithP2PClass = getHlsWithP2PClass(hlsConstructor);
+  const hls = new HlsWithP2PClass({
+    ...options.hls,
+    p2p: {
+      core: applyRuntimeToggle(mergeCoreConfig(options), options.p2pEnabled, options.uploadEnabled),
+      onHlsJsCreated(instance) {
+        hooks.onEngineCreated(instance.p2pEngine);
+      }
+    }
+  });
+  new FatalRecoveryPolicy(hls, hlsConstructor, {
+    retryMax: options.fatalRetryMax ?? DEFAULT_FATAL_RETRY_MAX,
+    onFatalError: hooks.onFatalError,
+    onUnrecoverable: hooks.onUnrecoverable
+  });
+  return hls;
+}
+
+// src/controller.ts
+var _art, _options2, _stats, _state, _p2pEnabled, _uploadEnabled, _recreateCount, _currentUrl, _currentVideo, _instance, _destroyHandler, _P2PController_instances, start_fn, stop_fn, emitStateChange_fn, handleUnrecoverable_fn;
+var P2PController = class {
+  /**
+   * @param art - ArtPlayer 实例
+   * @param options - 解析后的插件选项（p2pEnabled / uploadEnabled 为初始开关状态）
+   * @param stats - 统计引擎实例（由入口层创建并共享给句柄）
+   */
+  constructor(art, options, stats) {
+    __privateAdd(this, _P2PController_instances);
+    __privateAdd(this, _art);
+    __privateAdd(this, _options2);
+    __privateAdd(this, _stats);
+    __privateAdd(this, _state, "idle");
+    __privateAdd(this, _p2pEnabled);
+    __privateAdd(this, _uploadEnabled);
+    /** 跨实例的 fatal 重建计数（外部显式激活时归零，防止无限重建循环） */
+    __privateAdd(this, _recreateCount, 0);
+    __privateAdd(this, _currentUrl);
+    __privateAdd(this, _currentVideo);
+    __privateAdd(this, _instance);
+    /** 当前实例在 art 上的 destroy 监听（实例切换时注销，避免累积监听） */
+    __privateAdd(this, _destroyHandler);
+    __privateSet(this, _art, art);
+    __privateSet(this, _options2, options);
+    __privateSet(this, _stats, stats);
+    __privateSet(this, _p2pEnabled, options.p2pEnabled);
+    __privateSet(this, _uploadEnabled, options.uploadEnabled);
+  }
+  /** 当前控制器状态 */
+  get state() {
+    return __privateGet(this, _state);
+  }
+  /** 当前 P2P 开关状态 */
+  get p2pEnabled() {
+    return __privateGet(this, _p2pEnabled);
+  }
+  /** 当前上传开关状态 */
+  get uploadEnabled() {
+    return __privateGet(this, _uploadEnabled);
+  }
+  /** 当前播放实例（与 art.hls 槽位同步） */
+  get hls() {
+    return __privateGet(this, _instance);
+  }
+  /**
+   * 外部显式激活（customType 回调：首次加载 / 换源 / 重连共用）
+   *
+   * 视为新的播放意图：统计与重建计数全部归零，
+   * 以控制器当前开关状态创建实例（不接受模式参数）
+   *
+   * @param url - 播放地址
+   * @param video - 视频元素
+   */
+  activate(url, video) {
+    if (__privateGet(this, _state) === "destroyed") return;
+    __privateMethod(this, _P2PController_instances, stop_fn).call(this);
+    __privateGet(this, _stats).reset();
+    __privateSet(this, _recreateCount, 0);
+    __privateMethod(this, _P2PController_instances, start_fn).call(this, url, video);
+  }
+  /** 销毁当前播放实例（注销监听、清空 art.hls 槽位） */
+  deactivate() {
+    if (__privateGet(this, _state) === "destroyed") return;
+    __privateMethod(this, _P2PController_instances, stop_fn).call(this);
+  }
+  /** 销毁现有实例后按最近地址与当前开关模式重建 */
+  reload() {
+    if (__privateGet(this, _state) === "destroyed" || __privateGet(this, _currentUrl) === void 0) return;
+    this.activate(__privateGet(this, _currentUrl), __privateGet(this, _currentVideo));
+  }
+  /**
+   * P2P 运行时开关：经 applyDynamicConfig 无损切换
+   *
+   * 不销毁实例、不中断播放；关闭时 HybridLoader 被引擎销毁、
+   * peer 连接全断，主动清零 peer 计数防止残留（迟到关闭事件
+   * 由统计引擎的非负保护兜底）；字节统计冻结保留供模式对照
+   *
+   * @param enabled - 目标 P2P 状态
+   */
+  setP2PEnabled(enabled) {
+    if (__privateGet(this, _state) === "destroyed" || enabled === __privateGet(this, _p2pEnabled)) return;
+    __privateSet(this, _p2pEnabled, enabled);
+    const engine = __privateGet(this, _instance)?.p2pEngine;
+    if (engine) {
+      engine.applyDynamicConfig({ core: { isP2PDisabled: !enabled } });
+      if (!enabled) {
+        __privateGet(this, _stats).resetPeers();
+      }
+    }
+    __privateMethod(this, _P2PController_instances, emitStateChange_fn).call(this);
+  }
+  /**
+   * 上行运行时开关：仅信令广播（引擎内部处理），完全无缝
+   *
+   * @param enabled - 目标上传状态
+   */
+  setUploadEnabled(enabled) {
+    if (__privateGet(this, _state) === "destroyed" || enabled === __privateGet(this, _uploadEnabled)) return;
+    __privateSet(this, _uploadEnabled, enabled);
+    __privateGet(this, _instance)?.p2pEngine.applyDynamicConfig({ core: { isP2PUploadDisabled: !enabled } });
+    __privateMethod(this, _P2PController_instances, emitStateChange_fn).call(this);
+  }
+  /** 播放器销毁：终止一切并进入 destroyed（幂等） */
+  destroy() {
+    if (__privateGet(this, _state) === "destroyed") return;
+    __privateMethod(this, _P2PController_instances, stop_fn).call(this);
+    __privateSet(this, _state, "destroyed");
+  }
+};
+_art = new WeakMap();
+_options2 = new WeakMap();
+_stats = new WeakMap();
+_state = new WeakMap();
+_p2pEnabled = new WeakMap();
+_uploadEnabled = new WeakMap();
+_recreateCount = new WeakMap();
+_currentUrl = new WeakMap();
+_currentVideo = new WeakMap();
+_instance = new WeakMap();
+_destroyHandler = new WeakMap();
+_P2PController_instances = new WeakSet();
+/**
+ * 创建并绑定播放实例（内部路径，不重置任何状态）
+ *
+ * 构造 EngineOptions 时以控制器当前开关状态覆盖选项初始值：
+ * fatal 重建 / 换源 / 重连的实例重建均经此路径，
+ * 保证重建后 P2P 与上传模式与用户当前选择一致
+ *
+ * @param url - 播放地址
+ * @param video - 视频元素
+ */
+start_fn = function(url, video) {
+  const engineOptions = {
+    core: __privateGet(this, _options2).core,
+    tracker: __privateGet(this, _options2).tracker,
+    hls: __privateGet(this, _options2).hls,
+    fatalRetryMax: __privateGet(this, _options2).fatalRetryMax,
+    p2pEnabled: __privateGet(this, _p2pEnabled),
+    uploadEnabled: __privateGet(this, _uploadEnabled)
+  };
+  const hooks = {
+    onEngineCreated: (engine) => {
+      attachEventBridge(__privateGet(this, _art), engine, __privateGet(this, _stats));
+    },
+    onFatalError: (data, retryCount) => {
+      __privateGet(this, _art).emit("p2p:fatalError", data, retryCount);
+    },
+    onUnrecoverable: (data, retryCount) => {
+      __privateMethod(this, _P2PController_instances, handleUnrecoverable_fn).call(this, data, retryCount);
+    }
+  };
+  const instance = createHlsWithP2P(engineOptions, Hls, hooks);
+  instance.loadSource(url);
+  instance.attachMedia(video);
+  __privateGet(this, _art).hls = instance;
+  __privateSet(this, _instance, instance);
+  __privateSet(this, _currentUrl, url);
+  __privateSet(this, _currentVideo, video);
+  __privateSet(this, _state, "active");
+  __privateSet(this, _destroyHandler, () => {
+    __privateSet(this, _instance, void 0);
+    __privateSet(this, _currentVideo, void 0);
+    __privateSet(this, _state, "destroyed");
+    instance.destroy();
+  });
+  __privateGet(this, _art).on("destroy", __privateGet(this, _destroyHandler));
+};
+/** 销毁当前实例并回到 idle（不改变开关模式与重建计数） */
+stop_fn = function() {
+  if (__privateGet(this, _destroyHandler)) {
+    __privateGet(this, _art).off("destroy", __privateGet(this, _destroyHandler));
+    __privateSet(this, _destroyHandler, void 0);
+  }
+  const instance = __privateGet(this, _instance);
+  __privateSet(this, _instance, void 0);
+  __privateGet(this, _art).hls = void 0;
+  __privateSet(this, _state, "idle");
+  __privateGet(this, _stats).resetPeers();
+  if (instance) {
+    instance.destroy();
+  }
+};
+/** 开关状态变化后派发 p2p:stateChange，供宿主同步自定义 UI */
+emitStateChange_fn = function() {
+  const details = {
+    p2pEnabled: __privateGet(this, _p2pEnabled),
+    uploadEnabled: __privateGet(this, _uploadEnabled)
+  };
+  __privateGet(this, _art).emit("p2p:stateChange", details);
+};
+/**
+ * 不可恢复 fatal 的有界重建
+ *
+ * 重建计数超限后停止动作，发出带原因的 fatalError
+ * 事件交由宿主决策（提示用户 / 换源）
+ */
+handleUnrecoverable_fn = function(_data, _retryCount2) {
+  if (__privateGet(this, _recreateCount) >= __privateGet(this, _options2).fatalRetryMax) {
+    __privateGet(this, _art).emit("p2p:fatalError", { reason: "recreate-limit-exceeded", recreateCount: __privateGet(this, _recreateCount) }, __privateGet(this, _recreateCount));
+    return;
+  }
+  __privateSet(this, _recreateCount, __privateGet(this, _recreateCount) + 1);
+  const url = __privateGet(this, _currentUrl);
+  const video = __privateGet(this, _currentVideo);
+  if (url === void 0 || video === void 0) return;
+  __privateMethod(this, _P2PController_instances, stop_fn).call(this);
+  __privateGet(this, _stats).reset();
+  __privateMethod(this, _P2PController_instances, start_fn).call(this, url, video);
+};
+
+// src/ui/styles.ts
+var STYLE_TAG = "data-artp2p";
+var P2P_UI_CSS = `
+.art-video-player .art-info.artp2p-info {
+  display: none !important;
+}
+
+.art-video-player.artp2p-stats-show .art-info.artp2p-info {
+  display: flex !important;
+}
+`;
+function injectStyles() {
+  const doc = document;
+  if (doc.querySelector(`style[${STYLE_TAG}]`)) return;
+  const style = doc.createElement("style");
+  style.setAttribute(STYLE_TAG, "");
+  style.textContent = P2P_UI_CSS;
+  doc.head.appendChild(style);
+}
+
+// src/ui/format.ts
+function formatBytes(bytes) {
+  if (bytes >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
+  if (bytes >= 1024 ** 2) return `${(bytes / 1024 ** 2).toFixed(2)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${Math.round(bytes)} B`;
+}
+function formatSpeed(bytesPerSecond) {
+  return `${formatBytes(bytesPerSecond)}/s`;
+}
+function formatPercent(ratio) {
+  return `${Math.round(ratio * 100)}%`;
+}
+
+// src/ui/stats-menu.ts
+var CONTEXTMENU_NAME = "artp2pStats";
+var SHOW_CLASS = "artp2p-stats-show";
+var PANEL_HTML = `
+<div class="art-info artp2p-info">
+  <div class="art-info-panel">
+    <div class="art-info-item">
+      <div class="art-info-title">P2P \u72B6\u6001:</div>
+      <div class="art-info-content" data-field="state"></div>
+    </div>
+    <div class="art-info-item">
+      <div class="art-info-title">\u4E0B\u884C\u901F\u7387:</div>
+      <div class="art-info-content" data-field="download"></div>
+    </div>
+    <div class="art-info-item">
+      <div class="art-info-title">P2P \u5360\u6BD4:</div>
+      <div class="art-info-content" data-field="ratio"></div>
+    </div>
+    <div class="art-info-item">
+      <div class="art-info-title">\u4E0A\u884C\u901F\u7387:</div>
+      <div class="art-info-content" data-field="upload"></div>
+    </div>
+    <div class="art-info-item">
+      <div class="art-info-title">Peers:</div>
+      <div class="art-info-content" data-field="peers"></div>
+    </div>
+    <div class="art-info-item">
+      <div class="art-info-title">\u7D2F\u8BA1\u6D41\u91CF:</div>
+      <div class="art-info-content" data-field="total"></div>
+    </div>
+  </div>
+  <div class="art-info-close">[x]</div>
+</div>
+`;
+function resolveStateText(controller) {
+  if (!controller.p2pEnabled) return "\u5DF2\u5173\u95ED";
+  if (!controller.uploadEnabled) return "\u4EC5\u4E0A\u4F20";
+  return "\u8FD0\u884C\u4E2D";
+}
+function mountStatsMenu(art, controller, stats) {
+  const wrapper = document.createElement("div");
+  wrapper.innerHTML = PANEL_HTML;
+  const root = wrapper.firstElementChild;
+  const fields = {
+    state: root.querySelector('[data-field="state"]'),
+    download: root.querySelector('[data-field="download"]'),
+    ratio: root.querySelector('[data-field="ratio"]'),
+    upload: root.querySelector('[data-field="upload"]'),
+    peers: root.querySelector('[data-field="peers"]'),
+    total: root.querySelector('[data-field="total"]')
+  };
+  const $close = root.querySelector(".art-info-close");
+  art.template.$player.appendChild(root);
+  let timer = 0;
+  let opened = false;
+  const visibilityCallbacks = [];
+  function update() {
+    const snapshot = stats.snapshot();
+    const p2pOn = controller.p2pEnabled;
+    fields.state.textContent = resolveStateText(controller);
+    fields.download.textContent = p2pOn ? `${formatSpeed(snapshot.downloadSpeed)}\uFF08P2P ${formatSpeed(snapshot.p2pDownloadSpeed)}\uFF09` : formatSpeed(snapshot.downloadSpeed);
+    fields.ratio.textContent = p2pOn ? formatPercent(snapshot.p2pDownloadRatio) : "\u2014";
+    fields.upload.textContent = formatSpeed(snapshot.uploadSpeed);
+    fields.peers.textContent = `${snapshot.peers} / ${snapshot.peakPeers}`;
+    fields.total.textContent = `\u2193 ${formatBytes(snapshot.totalDownloadedBytes)} \xB7 \u2191 ${formatBytes(snapshot.uploadedBytes)}`;
+  }
+  function notifyVisibility() {
+    for (const callback of visibilityCallbacks) callback(opened);
+  }
+  function openPanel() {
+    if (opened) return;
+    opened = true;
+    art.template.$player.classList.add(SHOW_CLASS);
+    art.info.show = false;
+    update();
+    timer = window.setInterval(update, STATS_POLLING_MS);
+    notifyVisibility();
+  }
+  function closePanel() {
+    if (!opened) return;
+    opened = false;
+    art.template.$player.classList.remove(SHOW_CLASS);
+    window.clearInterval(timer);
+    notifyVisibility();
+  }
+  function onCloseClick(event) {
+    event.stopPropagation();
+    closePanel();
+  }
+  $close.addEventListener("click", onCloseClick);
+  const onNativeInfo = (open) => {
+    if (open) closePanel();
+  };
+  art.on("info", onNativeInfo);
+  art.contextmenu.add({
+    name: CONTEXTMENU_NAME,
+    index: 45,
+    html: "P2P \u7EDF\u8BA1",
+    click: (contextmenu) => {
+      contextmenu.show = false;
+      openPanel();
+    }
+  });
+  return {
+    open: openPanel,
+    close: closePanel,
+    isOpen: () => opened,
+    onVisibilityChange(callback) {
+      visibilityCallbacks.push(callback);
+    },
+    destroy() {
+      closePanel();
+      art.off("info", onNativeInfo);
+      $close.removeEventListener("click", onCloseClick);
+    }
+  };
+}
+
+// src/ui/setting.ts
+var ICON_P2P_ENABLED = '<svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor"><path d="M11 21h-1l1-7H7.5c-.58 0-.57-.32-.38-.66l.07-.12C8.48 10.94 10.42 7.54 13 3h1l-1 7h3.5c.49 0 .56.33.47.51l-.07.15C12.96 17.55 11 21 11 21z"/></svg>';
+var ICON_UPLOAD_ONLY = '<svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor"><path d="M9 16h6v-6h4l-7-7-7 7h4v6zm-4 2h14v2H5v-2z"/></svg>';
+var ICON_STATS = '<svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor"><path d="M5 9.2h3V19H5V9.2zM10.6 5h2.8v14h-2.8V5zm5.6 8H19v6h-2.8v-6z"/></svg>';
+function mountP2PSettings(art, controller, panel, items) {
+  if (!art.option.setting) {
+    console.info("[artplayer-plugin-p2p] option.setting \u672A\u5F00\u542F\uFF0C\u8DF3\u8FC7 P2P \u8BBE\u7F6E\u5F00\u5173\u6302\u8F7D");
+    return false;
+  }
+  let mounted = 0;
+  if (items.p2pEnabled) {
+    art.setting.add({
+      name: "artp2pSetting",
+      html: "P2P \u52A0\u901F",
+      tooltip: "P2P \u52A0\u901F",
+      icon: ICON_P2P_ENABLED,
+      switch: controller.p2pEnabled,
+      onSwitch(item) {
+        const next = !item.switch;
+        controller.setP2PEnabled(next);
+        return next;
+      }
+    });
+    mounted += 1;
+  }
+  if (items.uploadOnly) {
+    art.setting.add({
+      name: "artp2pUploadSetting",
+      html: "\u4EC5\u4E0A\u4F20\u6A21\u5F0F",
+      tooltip: "\u4EC5\u4E0A\u4F20\u6A21\u5F0F",
+      icon: ICON_UPLOAD_ONLY,
+      switch: !controller.uploadEnabled,
+      onSwitch(item) {
+        const next = !item.switch;
+        controller.setUploadEnabled(!next);
+        return next;
+      }
+    });
+    mounted += 1;
+  }
+  if (panel && items.stats) {
+    const panelItem = {
+      name: "artp2pStatsSetting",
+      html: "P2P \u7EDF\u8BA1",
+      tooltip: "P2P \u7EDF\u8BA1",
+      icon: ICON_STATS,
+      switch: panel.isOpen(),
+      onSwitch(item) {
+        const next = !item.switch;
+        if (next) {
+          panel.open();
+        } else {
+          panel.close();
+        }
+        return next;
+      }
+    };
+    art.setting.add(panelItem);
+    panel.onVisibilityChange((open) => {
+      panelItem.switch = open;
+    });
+    mounted += 1;
+  }
+  return mounted > 0;
+}
+
+// src/ui/index.ts
+function mountUI(art, controller, stats, options) {
+  if (!options.uiEnabled) return;
+  injectStyles();
+  let panel = null;
+  if (options.statsEnabled) {
+    panel = mountStatsMenu(art, controller, stats);
+  }
+  if (options.settingEnabled) {
+    mountP2PSettings(art, controller, panel, options.settingItems);
+  }
+  art.on("destroy", () => {
+    panel?.destroy();
+  });
+}
+
+// src/index.ts
+function getUrlExtension(url) {
+  const withoutHash = url.split("#")[0];
+  const withoutQuery = withoutHash.split("?")[0];
+  const lastDotIndex = withoutQuery.lastIndexOf(".");
+  if (lastDotIndex === -1) return "";
+  return withoutQuery.slice(lastDotIndex + 1).toLowerCase();
+}
+function artplayerPluginP2P(options = {}) {
+  return (art) => {
+    const resolved = resolveOptions(options);
+    const stats = new P2PStatsEngine();
+    const controller = new P2PController(art, resolved, stats);
+    mountUI(art, controller, stats, resolved);
+    function typeCallback(video, url) {
+      if (!Hls2.isSupported()) {
+        if (video.canPlayType("application/vnd.apple.mpegurl")) {
+          video.src = url;
+        } else {
+          art.notice.show = `Unsupported playback format: ${resolved.typeName}`;
+        }
+        return;
+      }
+      controller.activate(url, video);
+    }
+    let registered = false;
+    const customTypeMap = art.option.customType ?? (art.option.customType = {});
+    if (customTypeMap[resolved.typeName]) {
+      console.warn(`[artplayer-plugin-p2p] customType "${resolved.typeName}" already exists, skip registering`);
+    } else {
+      customTypeMap[resolved.typeName] = typeCallback;
+      registered = true;
+    }
+    if (registered) {
+      const optionUrl = art.option.url;
+      if (optionUrl) {
+        const currentType = art.option.type || getUrlExtension(optionUrl);
+        if (currentType === resolved.typeName) {
+          const { $video } = art.template;
+          const rawSrc = $video.getAttribute("src");
+          if (rawSrc && !rawSrc.startsWith("blob:")) {
+            $video.removeAttribute("src");
+            $video.load();
+          }
+          art.url = optionUrl;
+        }
+      }
+    }
+    return {
+      name: "artplayerPluginP2P",
+      get engine() {
+        return controller.hls?.p2pEngine;
+      },
+      get hls() {
+        return controller.hls;
+      },
+      destroy() {
+        controller.destroy();
+      },
+      reload() {
+        controller.reload();
+      },
+      getStats() {
+        return stats.snapshot();
+      },
+      setP2PEnabled(enabled) {
+        controller.setP2PEnabled(enabled);
+      },
+      isP2PEnabled() {
+        return controller.p2pEnabled;
+      },
+      setUploadEnabled(enabled) {
+        controller.setUploadEnabled(enabled);
+      },
+      isUploadEnabled() {
+        return controller.uploadEnabled;
+      },
+      /**
+       * 运行时动态配置透传：转发到当前引擎的 Core.applyDynamicConfig；
+       * 无活跃实例时不生效（即时调参语义，不做延迟补发）
+       */
+      applyDynamicConfig(patch) {
+        controller.hls?.p2pEngine.applyDynamicConfig({ core: patch });
+      }
+    };
+  };
+}
+export {
+  BANDWIDTH_WINDOW_MS,
+  DEFAULT_FATAL_RETRY_MAX,
+  DEFAULT_TYPE,
+  FatalRecoveryPolicy,
+  P2PController,
+  P2PStatsEngine,
+  P2P_EVENT_BRIDGE_MAP,
+  STATS_POLLING_MS,
+  applyRuntimeToggle,
+  createHlsWithP2P,
+  artplayerPluginP2P as default,
+  mergeCoreConfig,
+  resolveOptions
+};