artplayer-plugin-p2p 1.0.0

package/dist/index.js

@@ -0,0 +1,969 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BANDWIDTH_WINDOW_MS: () => BANDWIDTH_WINDOW_MS,
+  DEFAULT_FATAL_RETRY_MAX: () => DEFAULT_FATAL_RETRY_MAX,
+  DEFAULT_TYPE: () => DEFAULT_TYPE,
+  FatalRecoveryPolicy: () => FatalRecoveryPolicy,
+  P2PController: () => P2PController,
+  P2PStatsEngine: () => P2PStatsEngine,
+  P2P_EVENT_BRIDGE_MAP: () => P2P_EVENT_BRIDGE_MAP,
+  STATS_POLLING_MS: () => STATS_POLLING_MS,
+  applyRuntimeToggle: () => applyRuntimeToggle,
+  createHlsWithP2P: () => createHlsWithP2P,
+  default: () => artplayerPluginP2P,
+  mergeCoreConfig: () => mergeCoreConfig,
+  resolveOptions: () => resolveOptions
+});
+module.exports = __toCommonJS(index_exports);
+var import_hls2 = __toESM(require("hls.js"));
+
+// src/bandwidth.ts
+var _windowMs, _samples, _BandwidthCalculator_instances, removeExpired_fn;
+var BandwidthCalculator = class {
+  /**
+   * @param windowMs - 滑动时间窗长度（毫秒），窗口越长速率越平滑
+   */
+  constructor(windowMs) {
+    __privateAdd(this, _BandwidthCalculator_instances);
+    __privateAdd(this, _windowMs);
+    __privateAdd(this, _samples, []);
+    __privateSet(this, _windowMs, windowMs);
+  }
+  /**
+   * 记录一笔字节
+   *
+   * @param bytes - 字节数（非正值直接忽略，防御脏数据）
+   * @param timestampMs - 样本时间戳；缺省取 performance.now()，测试可注入固定时间
+   */
+  record(bytes, timestampMs = performance.now()) {
+    if (bytes <= 0) return;
+    __privateGet(this, _samples).push({ timestampMs, bytes });
+  }
+  /**
+   * 计算窗口内平均速率
+   *
+   * 读取时惰性清理过期样本；速率按整个窗口长度折算而非
+   * 首尾样本间隔，保证窗口未填满时（刚启动）读数平滑趋近真实值
+   *
+   * @param nowMs - 当前时间戳；缺省取 performance.now()，测试可注入固定时间
+   * @returns 速率 B/s
+   */
+  getSpeed(nowMs = performance.now()) {
+    __privateMethod(this, _BandwidthCalculator_instances, removeExpired_fn).call(this, nowMs);
+    let totalBytes = 0;
+    for (const sample of __privateGet(this, _samples)) {
+      totalBytes += sample.bytes;
+    }
+    return totalBytes / (__privateGet(this, _windowMs) / 1e3);
+  }
+  /** 清空全部样本 */
+  reset() {
+    __privateGet(this, _samples).length = 0;
+  }
+};
+_windowMs = new WeakMap();
+_samples = new WeakMap();
+_BandwidthCalculator_instances = new WeakSet();
+/**
+ * 移除窗口外的过期样本
+ *
+ * 样本时间戳单调递增（缺省时间源 performance.now 单调；
+ * 注入时间戳同样须单调），从头扫描至首个窗口内样本即可。
+ * 边界样本（age 恰等于窗口长）保留在窗口内，与 p2pml
+ * 官方带宽计算的过期判定语义保持一致
+ */
+removeExpired_fn = function(nowMs) {
+  const cutoff = nowMs - __privateGet(this, _windowMs);
+  let firstValid = __privateGet(this, _samples).length;
+  for (let i = 0; i < __privateGet(this, _samples).length; i++) {
+    if (__privateGet(this, _samples)[i].timestampMs >= cutoff) {
+      firstValid = i;
+      break;
+    }
+  }
+  __privateGet(this, _samples).splice(0, firstValid);
+};
+
+// src/constants.ts
+var DEFAULT_TYPE = "m3u8";
+var DEFAULT_FATAL_RETRY_MAX = 2;
+var BANDWIDTH_WINDOW_MS = 1e4;
+var STATS_POLLING_MS = 1e3;
+var P2P_EVENT_BRIDGE_MAP = {
+  onStreamAdded: "p2p:streamAdded",
+  onStreamRegistrationError: "p2p:streamRegistrationError",
+  onSegmentLoaded: "p2p:segmentLoaded",
+  onSegmentError: "p2p:segmentError",
+  onSegmentAbort: "p2p:segmentAbort",
+  onSegmentStart: "p2p:segmentStart",
+  onPeerConnect: "p2p:peerConnect",
+  onPeerConnectError: "p2p:peerConnectError",
+  onPeerClose: "p2p:peerClose",
+  onPeerError: "p2p:peerError",
+  onPeerWarning: "p2p:peerWarning",
+  onChunkDownloaded: "p2p:chunkDownloaded",
+  onChunkUploaded: "p2p:chunkUploaded",
+  onTrackerError: "p2p:trackerError",
+  onTrackerWarning: "p2p:trackerWarning"
+};
+
+// src/stats.ts
+var _peers, _peakPeers, _p2pDownloadedBytes, _httpDownloadedBytes, _uploadedBytes, _downloadBandwidths, _uploadBandwidth;
+var P2PStatsEngine = class {
+  constructor() {
+    __privateAdd(this, _peers, 0);
+    __privateAdd(this, _peakPeers, 0);
+    __privateAdd(this, _p2pDownloadedBytes, 0);
+    __privateAdd(this, _httpDownloadedBytes, 0);
+    __privateAdd(this, _uploadedBytes, 0);
+    __privateAdd(this, _downloadBandwidths, {
+      p2p: new BandwidthCalculator(BANDWIDTH_WINDOW_MS),
+      http: new BandwidthCalculator(BANDWIDTH_WINDOW_MS)
+    });
+    __privateAdd(this, _uploadBandwidth, new BandwidthCalculator(BANDWIDTH_WINDOW_MS));
+  }
+  /** 记录一个 peer 连接建立（同时维护峰值） */
+  recordPeerConnect() {
+    __privateSet(this, _peers, __privateGet(this, _peers) + 1);
+    if (__privateGet(this, _peers) > __privateGet(this, _peakPeers)) {
+      __privateSet(this, _peakPeers, __privateGet(this, _peers));
+    }
+  }
+  /** 记录一个 peer 连接断开（计数不小于零） */
+  recordPeerClose() {
+    if (__privateGet(this, _peers) > 0) {
+      __privateSet(this, _peers, __privateGet(this, _peers) - 1);
+    }
+  }
+  /**
+   * 记录一笔下行字节
+   *
+   * @param bytes - 字节数
+   * @param channel - 下载通道（http / p2p）
+   * @param timestampMs - 样本时间戳；缺省取 performance.now()，测试可注入固定时间
+   */
+  recordDownload(bytes, channel, timestampMs) {
+    if (bytes <= 0) return;
+    if (channel === "p2p") {
+      __privateSet(this, _p2pDownloadedBytes, __privateGet(this, _p2pDownloadedBytes) + bytes);
+    } else {
+      __privateSet(this, _httpDownloadedBytes, __privateGet(this, _httpDownloadedBytes) + bytes);
+    }
+    __privateGet(this, _downloadBandwidths)[channel].record(bytes, timestampMs);
+  }
+  /**
+   * 记录一笔 P2P 上行字节
+   *
+   * @param bytes - 字节数
+   * @param timestampMs - 样本时间戳；缺省取 performance.now()，测试可注入固定时间
+   */
+  recordUpload(bytes, timestampMs) {
+    if (bytes <= 0) return;
+    __privateSet(this, _uploadedBytes, __privateGet(this, _uploadedBytes) + bytes);
+    __privateGet(this, _uploadBandwidth).record(bytes, timestampMs);
+  }
+  /**
+   * 输出当前统计快照（累计量 + 派生指标一次算清）
+   *
+   * 带宽基准时间只取一次、每通道只计算一次，
+   * 保证快照内部指标自洽（downloadSpeed 恒等于两通道之和）
+   *
+   * @param nowMs - 带宽计算基准时间戳；缺省取 performance.now()，测试可注入固定时间
+   */
+  snapshot(nowMs) {
+    const totalDownloadedBytes = __privateGet(this, _p2pDownloadedBytes) + __privateGet(this, _httpDownloadedBytes);
+    const now = nowMs ?? performance.now();
+    const p2pDownloadSpeed = __privateGet(this, _downloadBandwidths).p2p.getSpeed(now);
+    const httpDownloadSpeed = __privateGet(this, _downloadBandwidths).http.getSpeed(now);
+    return {
+      peers: __privateGet(this, _peers),
+      peakPeers: __privateGet(this, _peakPeers),
+      p2pDownloadedBytes: __privateGet(this, _p2pDownloadedBytes),
+      httpDownloadedBytes: __privateGet(this, _httpDownloadedBytes),
+      uploadedBytes: __privateGet(this, _uploadedBytes),
+      totalDownloadedBytes,
+      p2pDownloadRatio: totalDownloadedBytes > 0 ? __privateGet(this, _p2pDownloadedBytes) / totalDownloadedBytes : 0,
+      downloadSpeed: p2pDownloadSpeed + httpDownloadSpeed,
+      p2pDownloadSpeed,
+      uploadSpeed: __privateGet(this, _uploadBandwidth).getSpeed(now)
+    };
+  }
+  /**
+   * 清零当前 peer 计数
+   *
+   * 动态关闭 P2P 或销毁播放实例后连接已全部断开（引擎销毁不保证
+   * 逐个发出 onPeerClose），主动清零防止残留计数污染下一次快照；
+   * 峰值与字节累计保留
+   */
+  resetPeers() {
+    __privateSet(this, _peers, 0);
+  }
+  /** 重置全部计数与样本（换源时调用） */
+  reset() {
+    __privateSet(this, _peers, 0);
+    __privateSet(this, _peakPeers, 0);
+    __privateSet(this, _p2pDownloadedBytes, 0);
+    __privateSet(this, _httpDownloadedBytes, 0);
+    __privateSet(this, _uploadedBytes, 0);
+    __privateGet(this, _downloadBandwidths).p2p.reset();
+    __privateGet(this, _downloadBandwidths).http.reset();
+    __privateGet(this, _uploadBandwidth).reset();
+  }
+};
+_peers = new WeakMap();
+_peakPeers = new WeakMap();
+_p2pDownloadedBytes = new WeakMap();
+_httpDownloadedBytes = new WeakMap();
+_uploadedBytes = new WeakMap();
+_downloadBandwidths = new WeakMap();
+_uploadBandwidth = new WeakMap();
+
+// src/controller.ts
+var import_hls = __toESM(require("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
+var import_p2p_media_loader_hlsjs = require("p2p-media-loader-hlsjs");
+
+// src/config.ts
+function resolveUIOptions(ui) {
+  return ui.setting !== false;
+}
+function resolveSettingItems(setting) {
+  if (setting === void 0 || setting === true) {
+    return { p2pEnabled: true, uploadOnly: true, stats: true };
+  }
+  if (setting === false) {
+    return { p2pEnabled: false, uploadOnly: false, stats: false };
+  }
+  return {
+    p2pEnabled: setting.p2pEnabled ?? true,
+    uploadOnly: setting.uploadOnly ?? true,
+    stats: setting.stats ?? true
+  };
+}
+function resolveOptions(options) {
+  const uiEnabled = options.ui !== false;
+  let settingEnabled;
+  let settingItems;
+  if (typeof options.ui === "object" && options.ui !== null) {
+    settingEnabled = resolveUIOptions(options.ui);
+    settingItems = resolveSettingItems(options.ui.setting);
+  } else {
+    settingEnabled = uiEnabled;
+    settingItems = resolveSettingItems(uiEnabled ? void 0 : false);
+  }
+  return {
+    typeName: options.type ?? DEFAULT_TYPE,
+    fatalRetryMax: options.fatalRetryMax ?? DEFAULT_FATAL_RETRY_MAX,
+    p2pEnabled: options.enabled ?? true,
+    uploadEnabled: options.uploadEnabled ?? true,
+    uiEnabled,
+    statsEnabled: uiEnabled && options.stats !== false,
+    settingEnabled,
+    settingItems,
+    core: options.core,
+    tracker: options.tracker,
+    hls: options.hls
+  };
+}
+function mergeCoreConfig(options) {
+  return { ...options.core, ...options.tracker };
+}
+function applyRuntimeToggle(config, p2pEnabled, uploadEnabled) {
+  return {
+    ...config,
+    isP2PDisabled: !p2pEnabled,
+    isP2PUploadDisabled: !uploadEnabled
+  };
+}
+
+// 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 = import_p2p_media_loader_hlsjs.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, import_hls.default, 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 (!import_hls2.default.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 });
+      }
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BANDWIDTH_WINDOW_MS,
+  DEFAULT_FATAL_RETRY_MAX,
+  DEFAULT_TYPE,
+  FatalRecoveryPolicy,
+  P2PController,
+  P2PStatsEngine,
+  P2P_EVENT_BRIDGE_MAP,
+  STATS_POLLING_MS,
+  applyRuntimeToggle,
+  createHlsWithP2P,
+  mergeCoreConfig,
+  resolveOptions
+});