@therealtinhtute/baroiplayer 1.0.1 → 1.0.2

package/dist/core.mjs

@@ -0,0 +1,1217 @@
+var k = Object.defineProperty;
+var A = (o, e, t) => e in o ? k(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var u = (o, e, t) => A(o, typeof e != "symbol" ? e + "" : e, t);
+import { C as B, P as R } from "./core-plugins-Bq9KLany.js";
+import { A as ye, B as we, a as Te, d as Se, c as ve, i as be, b as Pe, h as Me, j as Le, g as Ee, f as Ce, e as ke, l as Ae, k as Be } from "./core-plugins-Bq9KLany.js";
+import { E as I } from "./core-events-B5W_j8yU.js";
+import { a as Ie, b as Ne, M as $e, f as xe, c as Fe, d as Ue, e as De, n as Oe, u as ze, m as _e, p as Ve, h as He, j as je, k as Ye, g as Qe, l as We, i as Ke, o as Je } from "./core-events-B5W_j8yU.js";
+import { j as f } from "./context-Af84FynT.js";
+import m, { useMemo as N, createContext as $, useContext as x, lazy as h } from "react";
+import { a as F } from "./performance-monitor--rzKTlbj.js";
+import { b as Ge, P as Xe, d as Ze, p as et, u as tt, w as rt } from "./performance-monitor--rzKTlbj.js";
+class P {
+  constructor() {
+    u(this, "results", []);
+    u(this, "regressionDetector", new F());
+  }
+  async runTest(e, t) {
+    const r = [];
+    let n = 0, s = 0, i;
+    try {
+      for (let d = 0; d < e.warmupIterations; d++)
+        await t();
+      global.gc && global.gc(), n = this.getMemoryUsage();
+      for (let d = 0; d < e.iterations; d++) {
+        const S = performance.now();
+        await t();
+        const C = performance.now();
+        r.push(C - S);
+      }
+      s = this.getMemoryUsage();
+    } catch (d) {
+      i = d instanceof Error ? d.message : String(d);
+    }
+    const a = r.reduce((d, S) => d + S, 0) / r.length, c = Math.min(...r), g = Math.max(...r), T = s - n, y = !i && a <= e.expectedThreshold.renderTime && T <= e.expectedThreshold.memoryUsage, w = {
+      testName: e.name,
+      passed: y,
+      metrics: {
+        averageRenderTime: a,
+        minRenderTime: isFinite(c) ? c : 0,
+        maxRenderTime: isFinite(g) ? g : 0,
+        memoryUsage: T,
+        iterations: e.iterations
+      },
+      threshold: e.expectedThreshold,
+      error: i
+    };
+    return this.results.push(w), w;
+  }
+  getMemoryUsage() {
+    return "memory" in performance && performance.memory.usedJSHeapSize || 0;
+  }
+  // Component rendering performance test
+  async testComponentRender(e, t, r = 16) {
+    const n = {
+      name: `${e} Render Performance`,
+      iterations: 100,
+      warmupIterations: 10,
+      timeout: 5e3,
+      expectedThreshold: {
+        renderTime: r,
+        memoryUsage: 1048576
+        // 1MB
+      }
+    };
+    return this.runTest(n, t);
+  }
+  // Bundle loading performance test
+  async testBundleLoading(e, t = 1e3) {
+    const r = {
+      name: `Bundle Loading: ${e}`,
+      iterations: 5,
+      warmupIterations: 1,
+      timeout: 1e4,
+      expectedThreshold: {
+        renderTime: t,
+        memoryUsage: 5242880
+        // 5MB
+      }
+    };
+    return this.runTest(r, async () => {
+      const n = performance.now();
+      try {
+        const i = await fetch(e);
+        if (!i.ok)
+          throw new Error(`Failed to load bundle: ${i.status}`);
+        await i.blob();
+      } catch (i) {
+        console.warn(`Bundle loading test failed for ${e}:`, i);
+      }
+      return performance.now() - n;
+    });
+  }
+  // Memory leak detection test
+  async testMemoryLeaks(e, t = 1e3) {
+    const r = {
+      name: "Memory Leak Detection",
+      iterations: t,
+      warmupIterations: 100,
+      timeout: 3e4,
+      expectedThreshold: {
+        renderTime: 1 / 0,
+        // Not testing render time
+        memoryUsage: 10485760
+        // 10MB max increase
+      }
+    }, n = this.getMemoryUsage(), s = await this.runTest(r, e), a = this.getMemoryUsage() - n, c = a > r.expectedThreshold.memoryUsage;
+    return {
+      ...s,
+      passed: s.passed && !c,
+      error: c ? `Potential memory leak detected: ${Math.round(a / 1024 / 1024)}MB increase` : s.error
+    };
+  }
+  // Interaction delay test
+  async testInteractionDelay(e, t = 100) {
+    const r = {
+      name: "Interaction Delay",
+      iterations: 50,
+      warmupIterations: 5,
+      timeout: 5e3,
+      expectedThreshold: {
+        renderTime: t,
+        memoryUsage: 1048576
+        // 1MB
+      }
+    };
+    return this.runTest(r, e);
+  }
+  // Regression testing
+  async runRegressionTests(e, t) {
+    t && this.regressionDetector.setBaseline(t);
+    const r = this.regressionDetector.detectRegression(e);
+    return { passed: r.length === 0, regressions: r };
+  }
+  // Get all test results
+  getResults() {
+    return [...this.results];
+  }
+  // Get test summary
+  getSummary() {
+    const e = this.results.length, t = this.results.filter((s) => s.passed).length, r = e - t, n = e > 0 ? t / e * 100 : 0;
+    return { totalTests: e, passedTests: t, failedTests: r, passRate: n };
+  }
+  // Clear test results
+  clearResults() {
+    this.results = [];
+  }
+  // Generate performance report
+  generateReport() {
+    const e = this.getSummary();
+    let t = `Performance Test Report
+`;
+    return t += `========================
+
+`, t += `Total Tests: ${e.totalTests}
+`, t += `Passed: ${e.passedTests}
+`, t += `Failed: ${e.failedTests}
+`, t += `Pass Rate: ${e.passRate.toFixed(1)}%
+
+`, this.results.length > 0 && (t += `Detailed Results:
+`, t += `-----------------
+
+`, this.results.forEach((r, n) => {
+      t += `${n + 1}. ${r.testName}
+`, t += `   Status: ${r.passed ? "PASS" : "FAIL"}
+`, t += `   Average Render Time: ${r.metrics.averageRenderTime.toFixed(2)}ms
+`, t += `   Min/Max Render Time: ${r.metrics.minRenderTime.toFixed(2)}ms / ${r.metrics.maxRenderTime.toFixed(2)}ms
+`, t += `   Memory Usage: ${Math.round(r.metrics.memoryUsage / 1024)} KB
+`, t += `   Iterations: ${r.metrics.iterations}
+`, r.error && (t += `   Error: ${r.error}
+`), t += `
+`;
+    })), t;
+  }
+}
+const v = new P(), te = {
+  // Test component rendering performance
+  async testComponent(o, e = {}, t = 16) {
+    return v.testComponentRender(
+      o.displayName || o.name || "Component",
+      () => ({ type: o, props: e }),
+      t
+    );
+  },
+  // Test hook performance
+  async testHook(o, e, t = 1) {
+    const r = {
+      name: `Hook Performance: ${e}`,
+      iterations: 1e3,
+      warmupIterations: 100,
+      timeout: 5e3,
+      expectedThreshold: {
+        renderTime: t,
+        memoryUsage: 1048576
+        // 1MB
+      }
+    };
+    return v.runTest(r, o);
+  },
+  // Test async operation performance
+  async testAsyncOperation(o, e, t = 1e3) {
+    const r = {
+      name: `Async Operation: ${e}`,
+      iterations: 10,
+      warmupIterations: 2,
+      timeout: 3e4,
+      expectedThreshold: {
+        renderTime: t,
+        memoryUsage: 2097152
+        // 2MB
+      }
+    };
+    return v.runTest(r, o);
+  },
+  // Test bundle size impact
+  async measureBundleImpact(o, e, t) {
+    const r = performance.memory?.usedJSHeapSize || 0, n = performance.now();
+    o();
+    const s = performance.memory?.usedJSHeapSize || 0, i = performance.now();
+    e();
+    const a = performance.memory?.usedJSHeapSize || 0, c = performance.now();
+    return {
+      bundleIncrease: a - r,
+      memoryIncrease: s - r,
+      renderTimeImpact: c - i - (i - n)
+    };
+  }
+};
+class U {
+  constructor() {
+    u(this, "benchmark", new P());
+    u(this, "suites", /* @__PURE__ */ new Map());
+  }
+  // Register a test suite
+  registerSuite(e, t) {
+    this.suites.set(e, t);
+  }
+  // Run all tests in a suite
+  async runSuite(e, t) {
+    const r = this.suites.get(e);
+    if (!r)
+      throw new Error(`Test suite '${e}' not found`);
+    const n = [];
+    for (const s of r) {
+      const i = t.get(s.name);
+      if (!i) {
+        console.warn(`No implementation found for test '${s.name}'`);
+        continue;
+      }
+      const a = await this.benchmark.runTest(s, i);
+      n.push(a);
+    }
+    return n;
+  }
+  // Run all registered test suites
+  async runAllSuites(e) {
+    const t = /* @__PURE__ */ new Map();
+    for (const [r] of this.suites) {
+      const n = e.get(r);
+      if (!n) {
+        console.warn(`No implementations found for suite '${r}'`);
+        continue;
+      }
+      const s = await this.runSuite(r, n);
+      t.set(r, s);
+    }
+    return t;
+  }
+  // Generate comprehensive report
+  generateComprehensiveReport() {
+    this.benchmark.getSummary();
+    let e = this.benchmark.generateReport();
+    if (this.suites.size > 0) {
+      e += `
+Test Suites:
+`, e += `============
+
+`;
+      for (const [t, r] of this.suites)
+        e += `Suite: ${t}
+`, e += `Tests: ${r.length}
+
+`;
+    }
+    return e;
+  }
+}
+const re = new U(), D = [
+  // Bundle size budgets
+  {
+    name: "Main Bundle Size (ESM)",
+    category: "bundle",
+    limit: 250 * 1024,
+    // 250KB
+    unit: "bytes",
+    severity: "error",
+    description: "Main bundle should stay under 250KB for fast initial loading"
+  },
+  {
+    name: "Main Bundle Size (CJS)",
+    category: "bundle",
+    limit: 200 * 1024,
+    // 200KB
+    unit: "bytes",
+    severity: "error",
+    description: "CJS bundle should be smaller due to better compression"
+  },
+  {
+    name: "Core Module Size",
+    category: "bundle",
+    limit: 15 * 1024,
+    // 15KB
+    unit: "bytes",
+    severity: "warning",
+    description: "Core architecture should remain lightweight"
+  },
+  {
+    name: "Enhanced Components Size",
+    category: "bundle",
+    limit: 40 * 1024,
+    // 40KB
+    unit: "bytes",
+    severity: "warning",
+    description: "Enhanced components bundle size"
+  },
+  // Runtime performance budgets
+  {
+    name: "Component Render Time",
+    category: "runtime",
+    limit: 16,
+    // 16ms for 60fps
+    unit: "ms",
+    severity: "error",
+    description: "Component rendering should complete within one frame"
+  },
+  {
+    name: "First Input Delay",
+    category: "runtime",
+    limit: 100,
+    // 100ms
+    unit: "ms",
+    severity: "error",
+    description: "First Input Delay should be under 100ms for good UX"
+  },
+  {
+    name: "Largest Contentful Paint",
+    category: "runtime",
+    limit: 2500,
+    // 2.5s
+    unit: "ms",
+    severity: "warning",
+    description: "LCP should be under 2.5s for good Core Web Vitals score"
+  },
+  {
+    name: "Cumulative Layout Shift",
+    category: "runtime",
+    limit: 0.1,
+    unit: "score",
+    severity: "warning",
+    description: "CLS should be under 0.1 for good visual stability"
+  },
+  // Memory budgets
+  {
+    name: "Memory Usage",
+    category: "memory",
+    limit: 50 * 1024 * 1024,
+    // 50MB
+    unit: "bytes",
+    severity: "warning",
+    description: "Memory usage should stay under 50MB for good performance"
+  },
+  {
+    name: "Memory Increase Per Operation",
+    category: "memory",
+    limit: 1024 * 1024,
+    // 1MB
+    unit: "bytes",
+    severity: "error",
+    description: "Each operation should not increase memory by more than 1MB"
+  },
+  // Network budgets (for media loading)
+  {
+    name: "Media Load Time",
+    category: "network",
+    limit: 3e3,
+    // 3s
+    unit: "ms",
+    severity: "warning",
+    description: "Media should start loading within 3 seconds"
+  }
+];
+class O {
+  constructor(e = D, t = {
+    enabled: !0,
+    channels: [{ type: "console", config: {} }],
+    threshold: 1,
+    cooldown: 300 * 1e3
+    // 5 minutes
+  }) {
+    u(this, "budgets", /* @__PURE__ */ new Map());
+    u(this, "violations", []);
+    u(this, "alertConfig");
+    u(this, "lastAlertTime", 0);
+    e.forEach((r) => {
+      this.budgets.set(r.name, r);
+    }), this.alertConfig = t;
+  }
+  // Check a single metric against budgets
+  checkMetric(e, t, r = "runtime") {
+    const n = [];
+    for (const [s, i] of this.budgets)
+      if (i.category === r && (s.includes(e) || e.includes(s.split(" ")[0]?.toLowerCase() || "")) && t > i.limit) {
+        const a = {
+          budget: i,
+          actualValue: t,
+          overageAmount: t - i.limit,
+          overagePercentage: (t - i.limit) / i.limit * 100,
+          timestamp: Date.now()
+        };
+        n.push(a), this.violations.push(a);
+      }
+    return n.length > 0 && this.handleViolations(n), n;
+  }
+  // Check bundle sizes
+  async checkBundleSizes(e) {
+    const t = [];
+    return typeof window < "u" || typeof process > "u" ? (console.warn("Bundle size checking is only available in Node.js environment"), t) : (console.warn("Bundle size checking disabled - use Node.js cicdIntegration from @rp/baroiplayer/core/performance/cicd for CI/CD environments"), t);
+  }
+  // Check runtime performance
+  checkRuntimeMetrics(e) {
+    const t = [];
+    return e.renderTime !== void 0 && t.push(...this.checkMetric("Component Render Time", e.renderTime, "runtime")), e.fid !== void 0 && t.push(...this.checkMetric("First Input Delay", e.fid, "runtime")), e.lcp !== void 0 && t.push(...this.checkMetric("Largest Contentful Paint", e.lcp, "runtime")), e.cls !== void 0 && t.push(...this.checkMetric("Cumulative Layout Shift", e.cls, "runtime")), e.memoryUsage !== void 0 && t.push(...this.checkMetric("Memory Usage", e.memoryUsage, "memory")), e.mediaLoadTime !== void 0 && t.push(...this.checkMetric("Media Load Time", e.mediaLoadTime, "network")), t;
+  }
+  // Handle budget violations
+  async handleViolations(e) {
+    if (!this.alertConfig.enabled) return;
+    const t = Date.now();
+    e.filter((n) => n.budget.severity === "error").length >= this.alertConfig.threshold && t - this.lastAlertTime >= this.alertConfig.cooldown && (await this.sendAlerts(e), this.lastAlertTime = t);
+  }
+  // Send alerts through configured channels
+  async sendAlerts(e) {
+    const t = this.formatAlertMessage(e);
+    for (const r of this.alertConfig.channels)
+      try {
+        await this.sendAlert(r, t);
+      } catch (n) {
+        console.error(`Failed to send alert via ${r.type}:`, n);
+      }
+  }
+  // Format alert message
+  formatAlertMessage(e) {
+    let t = `🚨 Performance Budget Violations Detected!
+
+`;
+    return e.forEach((r) => {
+      const { budget: n, actualValue: s, overageAmount: i, overagePercentage: a } = r;
+      this.getUnitDisplay(n.unit), t += `❌ ${n.name}
+`, t += `   Limit: ${this.formatValue(n.limit, n.unit)}
+`, t += `   Actual: ${this.formatValue(s, n.unit)}
+`, t += `   Overage: ${this.formatValue(i, n.unit)} (+${a.toFixed(1)}%)
+`, t += `   Severity: ${n.severity.toUpperCase()}
+
+`;
+    }), t += `Time: ${(/* @__PURE__ */ new Date()).toISOString()}
+`, t += `Total Violations: ${e.length}`, t;
+  }
+  // Send alert to specific channel
+  async sendAlert(e, t) {
+    switch (e.type) {
+      case "console":
+        console.error(t);
+        break;
+      case "webhook":
+        if (e.config.url) {
+          const r = await fetch(e.config.url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ text: t, timestamp: Date.now() })
+          });
+          if (!r.ok)
+            throw new Error(`Webhook failed: ${r.status}`);
+        }
+        break;
+      case "slack":
+        if (e.config.url) {
+          const r = await fetch(e.config.url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              text: t,
+              channel: e.config.channel,
+              username: "BaroiPlayer Performance Monitor"
+            })
+          });
+          if (!r.ok)
+            throw new Error(`Slack webhook failed: ${r.status}`);
+        }
+        break;
+      default:
+        console.warn(`Unsupported alert channel: ${e.type}`);
+    }
+  }
+  // Helper methods
+  formatValue(e, t) {
+    switch (t) {
+      case "bytes":
+        return this.formatBytes(e);
+      case "ms":
+        return `${e.toFixed(2)}ms`;
+      case "score":
+        return e.toFixed(3);
+      case "percent":
+        return `${e.toFixed(1)}%`;
+      default:
+        return e.toString();
+    }
+  }
+  formatBytes(e) {
+    return e >= 1024 * 1024 ? `${(e / 1024 / 1024).toFixed(2)}MB` : e >= 1024 ? `${(e / 1024).toFixed(2)}KB` : `${e}B`;
+  }
+  getUnitDisplay(e) {
+    return {
+      bytes: "bytes",
+      ms: "milliseconds",
+      score: "score",
+      percent: "percent"
+    }[e] || e;
+  }
+  // Management methods
+  addBudget(e) {
+    this.budgets.set(e.name, e);
+  }
+  removeBudget(e) {
+    this.budgets.delete(e);
+  }
+  updateBudget(e, t) {
+    const r = this.budgets.get(e);
+    r && this.budgets.set(e, { ...r, ...t });
+  }
+  getBudgets() {
+    return Array.from(this.budgets.values());
+  }
+  getViolations(e) {
+    return e ? this.violations.filter((t) => t.timestamp >= e) : [...this.violations];
+  }
+  clearViolations() {
+    this.violations = [];
+  }
+  getViolationSummary() {
+    const e = {}, t = {};
+    return this.violations.forEach((r) => {
+      const n = r.budget.category, s = r.budget.severity;
+      e[n] = (e[n] || 0) + 1, t[s] = (t[s] || 0) + 1;
+    }), {
+      total: this.violations.length,
+      byCategory: e,
+      bySeverity: t
+    };
+  }
+}
+const ne = new O(), z = {
+  preloadStrategy: "metadata",
+  adaptiveBitrate: !0,
+  maxPreloadSize: 2 * 1024 * 1024,
+  // 2MB
+  networkThresholds: {
+    "2g": { maxBitrate: 128, preload: !1 },
+    // 128 kbps
+    "3g": { maxBitrate: 500, preload: !1 },
+    // 500 kbps  
+    "4g": { maxBitrate: 2e3, preload: !0 },
+    // 2 Mbps
+    "5g": { maxBitrate: 1e4, preload: !0 }
+    // 10 Mbps
+  },
+  bufferSize: 10,
+  // 10 seconds
+  enableServiceWorker: !0
+};
+class _ {
+  constructor() {
+    u(this, "connection");
+    u(this, "listeners", /* @__PURE__ */ new Set());
+    u(this, "currentInfo");
+    if (typeof window > "u" || typeof navigator > "u") {
+      this.connection = null, this.currentInfo = {
+        effectiveType: "unknown",
+        downlink: 0,
+        rtt: 0,
+        saveData: !1,
+        isOnline: !0
+      };
+      return;
+    }
+    this.connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection, this.currentInfo = this.getNetworkInfo(), this.initializeListeners();
+  }
+  getNetworkInfo() {
+    if (typeof navigator > "u")
+      return {
+        effectiveType: "unknown",
+        downlink: 0,
+        rtt: 0,
+        saveData: !1,
+        isOnline: !0
+      };
+    const e = navigator.onLine;
+    return this.connection ? {
+      effectiveType: this.connection.effectiveType || "unknown",
+      downlink: this.connection.downlink || 0,
+      rtt: this.connection.rtt || 0,
+      saveData: this.connection.saveData || !1,
+      isOnline: e
+    } : {
+      effectiveType: "unknown",
+      downlink: 0,
+      rtt: 0,
+      saveData: !1,
+      isOnline: e
+    };
+  }
+  initializeListeners() {
+    typeof window > "u" || (this.connection && this.connection.addEventListener("change", this.handleNetworkChange.bind(this)), window.addEventListener("online", this.handleNetworkChange.bind(this)), window.addEventListener("offline", this.handleNetworkChange.bind(this)));
+  }
+  handleNetworkChange() {
+    const e = this.getNetworkInfo();
+    this.currentInfo = e, this.listeners.forEach((t) => t(e));
+  }
+  getCurrentNetworkInfo() {
+    return { ...this.currentInfo };
+  }
+  subscribe(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  // Estimate available bandwidth with fallback detection
+  async estimateBandwidth() {
+    if (this.connection && this.connection.downlink)
+      return this.connection.downlink * 1e3;
+    try {
+      const e = performance.now(), n = await (await fetch("/api/bandwidth-test?size=100kb")).blob(), i = (performance.now() - e) / 1e3;
+      return n.size * 8 / i / 1e3;
+    } catch (e) {
+      return console.warn("Bandwidth estimation failed:", e), 1e3;
+    }
+  }
+}
+class M {
+  constructor(e = {}) {
+    u(this, "config");
+    u(this, "networkMonitor");
+    u(this, "loadingMetrics", /* @__PURE__ */ new Map());
+    u(this, "preloadCache", /* @__PURE__ */ new Map());
+    this.config = { ...z, ...e }, this.networkMonitor = new _(), this.initializeNetworkMonitoring();
+  }
+  initializeNetworkMonitoring() {
+    this.networkMonitor.subscribe((e) => {
+      this.handleNetworkChange(e);
+    });
+  }
+  handleNetworkChange(e) {
+    console.log("Network changed:", e), this.config.adaptiveBitrate && this.adjustQualityForNetwork(e), (e.effectiveType === "2g" || e.saveData) && this.clearPreloadCache();
+  }
+  // Optimize media loading based on network conditions
+  async optimizeMediaLoading(e, t, r = {}) {
+    const n = performance.now(), s = this.networkMonitor.getCurrentNetworkInfo(), i = {
+      loadStartTime: n,
+      bytesLoaded: 0,
+      loadSpeed: 0,
+      networkType: s.effectiveType,
+      quality: r.quality || "auto",
+      bufferHealth: 0,
+      stallsCount: 0,
+      stallsDuration: 0
+    };
+    this.loadingMetrics.set(e, i);
+    try {
+      const a = this.chooseLoadingStrategy(s, r);
+      return a.shouldPreload && await this.preloadMedia(e, a.preloadAmount), t.preload = a.preloadAttribute, this.monitorLoadingProgress(t, i), this.config.adaptiveBitrate && a.suggestedQuality && this.applyQualitySettings(t, a.suggestedQuality), i;
+    } catch (a) {
+      return console.error("Media loading optimization failed:", a), i;
+    }
+  }
+  chooseLoadingStrategy(e, t) {
+    const r = e.effectiveType === "unknown" ? "4g" : e.effectiveType, n = this.config.networkThresholds[r] || this.config.networkThresholds["4g"];
+    return {
+      shouldPreload: t.preload !== !1 && n.preload && !e.saveData,
+      preloadAmount: e.saveData ? 0 : this.config.maxPreloadSize,
+      preloadAttribute: this.getPreloadAttribute(e),
+      suggestedQuality: this.getSuggestedQuality(e, n.maxBitrate),
+      bufferTarget: this.getBufferTarget(e)
+    };
+  }
+  getPreloadAttribute(e) {
+    return e.saveData || e.effectiveType === "2g" ? "none" : e.effectiveType === "3g" ? "metadata" : this.config.preloadStrategy;
+  }
+  getSuggestedQuality(e, t) {
+    const r = e.downlink * 1e3;
+    return r >= t * 2 ? "high" : r >= t ? "medium" : "low";
+  }
+  getBufferTarget(e) {
+    switch (e.effectiveType) {
+      case "2g":
+        return 2;
+      // 2 seconds
+      case "3g":
+        return 5;
+      // 5 seconds
+      case "4g":
+        return this.config.bufferSize;
+      case "5g":
+        return this.config.bufferSize * 1.5;
+      default:
+        return this.config.bufferSize;
+    }
+  }
+  // Preload media content
+  async preloadMedia(e, t) {
+    if (this.preloadCache.has(e))
+      return;
+    const r = this.fetchWithProgress(e, t);
+    this.preloadCache.set(e, r);
+    try {
+      await r;
+    } catch (n) {
+      console.warn(`Preload failed for ${e}:`, n), this.preloadCache.delete(e);
+    }
+  }
+  async fetchWithProgress(e, t) {
+    const r = await fetch(e, {
+      headers: {
+        Range: `bytes=0-${t - 1}`
+        // Limit preload size
+      }
+    });
+    if (!r.ok)
+      throw new Error(`Failed to preload: ${r.status}`);
+    const n = r.body?.getReader();
+    if (!n)
+      throw new Error("Response body not readable");
+    const s = [];
+    let i = 0;
+    try {
+      for (; i < t; ) {
+        const { done: a, value: c } = await n.read();
+        if (a) break;
+        s.push(c), i += c.length;
+      }
+    } finally {
+      n.releaseLock();
+    }
+    return new Blob(s);
+  }
+  // Monitor loading progress and update metrics
+  monitorLoadingProgress(e, t) {
+    let r = null;
+    const n = () => {
+      if (e.buffered.length > 0) {
+        const y = e.buffered.end(e.buffered.length - 1), w = e.currentTime;
+        t.bufferHealth = Math.min((y - w) / this.config.bufferSize, 1);
+      }
+    }, s = () => {
+      t.firstByteTime = performance.now();
+    }, i = () => {
+      t.loadCompleteTime = performance.now(), t.totalLoadTime = t.loadCompleteTime - t.loadStartTime, t.totalLoadTime && t.bytesLoaded > 0 && (t.loadSpeed = t.bytesLoaded / (t.totalLoadTime / 1e3));
+    }, a = () => {
+      r === null && (r = performance.now(), t.stallsCount++);
+    }, c = () => {
+      r !== null && (t.stallsDuration += performance.now() - r, r = null), n();
+    }, g = () => {
+      if (e.buffered.length > 0) {
+        const y = e.buffered.end(0) * 1e3;
+        t.bytesLoaded = y;
+      }
+      n();
+    };
+    e.addEventListener("loadstart", s), e.addEventListener("canplay", i), e.addEventListener("waiting", a), e.addEventListener("playing", c), e.addEventListener("progress", g), setTimeout(() => {
+      e.removeEventListener("loadstart", s), e.removeEventListener("canplay", i), e.removeEventListener("waiting", a), e.removeEventListener("playing", c), e.removeEventListener("progress", g);
+    }, 300 * 1e3);
+  }
+  // Apply quality settings (would integrate with HLS.js or similar)
+  applyQualitySettings(e, t) {
+    console.log(`Applying quality setting: ${t} to`, e);
+  }
+  adjustQualityForNetwork(e) {
+    console.log("Adjusting quality for network conditions:", e.effectiveType);
+  }
+  // Clear preload cache to save memory
+  clearPreloadCache() {
+    this.preloadCache.clear();
+  }
+  // Get loading metrics for a specific media URL
+  getLoadingMetrics(e) {
+    return this.loadingMetrics.get(e);
+  }
+  // Get all loading metrics
+  getAllMetrics() {
+    return Array.from(this.loadingMetrics.values());
+  }
+  // Calculate average loading performance
+  getAverageLoadingTime() {
+    const t = this.getAllMetrics().filter((n) => n.totalLoadTime !== void 0);
+    return t.length === 0 ? 0 : t.reduce((n, s) => n + (s.totalLoadTime || 0), 0) / t.length;
+  }
+  // Get network-specific performance stats
+  getNetworkPerformanceStats() {
+    const e = /* @__PURE__ */ new Map();
+    return this.getAllMetrics().forEach((t) => {
+      const r = t.networkType;
+      e.has(r) || e.set(r, []), e.get(r).push(t);
+    }), Array.from(e.entries()).map(([t, r]) => ({
+      networkType: t,
+      avgLoadTime: r.reduce((n, s) => n + (s.totalLoadTime || 0), 0) / r.length,
+      avgStalls: r.reduce((n, s) => n + s.stallsCount, 0) / r.length,
+      avgBufferHealth: r.reduce((n, s) => n + s.bufferHealth, 0) / r.length
+    }));
+  }
+}
+const V = new M();
+function oe(o) {
+  const [e] = m.useState(
+    () => o ? new M(o) : V
+  ), [t, r] = m.useState(null), [n, s] = m.useState([]);
+  m.useEffect(() => {
+    const a = e.networkMonitor.subscribe(r);
+    r(e.networkMonitor.getCurrentNetworkInfo());
+    const c = setInterval(() => {
+      s(e.getAllMetrics());
+    }, 1e3);
+    return () => {
+      a(), clearInterval(c);
+    };
+  }, [e]);
+  const i = m.useCallback(
+    (a, c, g) => e.optimizeMediaLoading(a, c, g),
+    [e]
+  );
+  return {
+    networkInfo: t,
+    loadingMetrics: n,
+    optimizeLoading: i,
+    averageLoadTime: e.getAverageLoadingTime(),
+    networkStats: e.getNetworkPerformanceStats()
+  };
+}
+class H {
+  get(e) {
+    try {
+      const t = localStorage.getItem(`baroi-player-${e}`);
+      return t ? JSON.parse(t) : null;
+    } catch {
+      return null;
+    }
+  }
+  set(e, t) {
+    try {
+      localStorage.setItem(`baroi-player-${e}`, JSON.stringify(t));
+    } catch (r) {
+      console.warn("Failed to store data:", r);
+    }
+  }
+  remove(e) {
+    try {
+      localStorage.removeItem(`baroi-player-${e}`);
+    } catch (t) {
+      console.warn("Failed to remove data:", t);
+    }
+  }
+  clear() {
+    try {
+      Object.keys(localStorage).forEach((e) => {
+        e.startsWith("baroi-player-") && localStorage.removeItem(e);
+      });
+    } catch (e) {
+      console.warn("Failed to clear data:", e);
+    }
+  }
+}
+class j {
+  track(e, t) {
+    console.log("Analytics:", e, t);
+  }
+  identify(e, t) {
+    console.log("Analytics identify:", e, t);
+  }
+  page(e, t) {
+    console.log("Analytics page:", e, t);
+  }
+}
+const L = $(null);
+function Y({ children: o, services: e = {} }) {
+  const t = N(() => {
+    const r = e.logger || new B("[BaroiPlayer]"), n = e.eventBus || new I(), s = e.pluginRegistry || new R(r), i = e.storage || new H(), a = e.analytics || new j();
+    return {
+      eventBus: n,
+      pluginRegistry: s,
+      storage: i,
+      analytics: a,
+      logger: r
+    };
+  }, [e]);
+  return /* @__PURE__ */ f.jsx(L.Provider, { value: t, children: o });
+}
+function p() {
+  const o = x(L);
+  if (!o)
+    throw new Error("useServices must be used within ServiceProvider");
+  return o;
+}
+function se() {
+  return p().eventBus;
+}
+function ie() {
+  return p().pluginRegistry;
+}
+function ae() {
+  return p().storage;
+}
+function ce() {
+  return p().analytics;
+}
+function le() {
+  return p().logger;
+}
+function ue(o) {
+  return function(t) {
+    const r = p();
+    return /* @__PURE__ */ f.jsx(o, { ...t, services: r });
+  };
+}
+function de(o = {}) {
+  return function({ children: t }) {
+    return /* @__PURE__ */ f.jsx(Y, { services: o.services, children: t });
+  };
+}
+const l = {
+  SUBTITLES: "subtitles",
+  PLAYLISTS: "playlists",
+  ADVANCED_CONTROLS: "advanced_controls",
+  ANALYTICS: "analytics",
+  PICTURE_IN_PICTURE: "picture_in_picture",
+  QUALITY_SELECTOR: "quality_selector",
+  PLAYBACK_SPEED: "playback_speed",
+  CHAPTERS: "chapters",
+  THUMBNAILS: "thumbnails",
+  KEYBOARD_SHORTCUTS: "keyboard_shortcuts"
+}, Q = {
+  enabledFeatures: [
+    l.SUBTITLES,
+    l.ADVANCED_CONTROLS,
+    l.KEYBOARD_SHORTCUTS
+  ],
+  loadingStrategy: "lazy",
+  fallbackTimeout: 5e3,
+  retryAttempts: 3
+}, me = {
+  // Subtitle system
+  SubtitleSelector: h(
+    () => import("./enhanced-components-Da0TSvKe.js").then((o) => o.g).then((o) => ({ default: o.SubtitleSelector }))
+  ),
+  // Playlist functionality  
+  PlaylistManager: h(
+    () => import("./enhanced-components-Da0TSvKe.js").then((o) => o.g).then((o) => ({ default: o.SubtitleSelector }))
+    // Use existing component as placeholder
+  ),
+  // Advanced controls
+  QualitySelector: h(
+    () => import("./enhanced-components-Da0TSvKe.js").then((o) => o.g).then((o) => ({ default: o.QualitySelector }))
+  ),
+  PlaybackSpeedSelector: h(
+    () => import("./enhanced-components-Da0TSvKe.js").then((o) => o.g).then((o) => ({ default: o.PlaybackSpeedSelector }))
+  ),
+  ChaptersPanel: h(
+    () => import("./enhanced-components-Da0TSvKe.js").then((o) => o.g).then((o) => ({ default: o.ChaptersPanel }))
+  ),
+  PictureInPictureButton: h(
+    () => import("./enhanced-components-Da0TSvKe.js").then((o) => o.g).then((o) => ({ default: o.PictureInPictureButton }))
+  ),
+  // Analytics
+  AnalyticsTracker: h(
+    () => import("./enhanced-components-Da0TSvKe.js").then((o) => o.g).then((o) => ({ default: o.SubtitleSelector }))
+    // Use existing component as placeholder
+  )
+};
+class E {
+  static async isSupported(e) {
+    if (this.cache.has(e))
+      return this.cache.get(e);
+    const t = await this.checkFeatureSupport(e);
+    return this.cache.set(e, t), t;
+  }
+  static async checkFeatureSupport(e) {
+    if (typeof window > "u" || typeof document > "u")
+      return !0;
+    switch (e) {
+      case l.SUBTITLES:
+        return "TextTrack" in window;
+      case l.PICTURE_IN_PICTURE:
+        return "pictureInPictureEnabled" in document;
+      case l.ADVANCED_CONTROLS:
+        return !0;
+      // Always supported
+      case l.PLAYLISTS:
+        return "MediaSession" in window;
+      case l.ANALYTICS:
+        return "IntersectionObserver" in window;
+      case l.QUALITY_SELECTOR:
+        return "MediaSource" in window;
+      case l.PLAYBACK_SPEED:
+        return !0;
+      // HTML5 video supports this
+      case l.CHAPTERS:
+        return "TextTrack" in window;
+      case l.THUMBNAILS:
+        return "OffscreenCanvas" in window || "canvas" in document.createElement("canvas");
+      case l.KEYBOARD_SHORTCUTS:
+        return "KeyboardEvent" in window;
+      default:
+        return !1;
+    }
+  }
+}
+u(E, "cache", /* @__PURE__ */ new Map());
+class W {
+  constructor(e = {}) {
+    u(this, "config");
+    u(this, "loadedFeatures", /* @__PURE__ */ new Set());
+    u(this, "loadingPromises", /* @__PURE__ */ new Map());
+    this.config = { ...Q, ...e };
+  }
+  async loadFeature(e) {
+    if (!this.config.enabledFeatures.includes(e))
+      return null;
+    if (this.loadedFeatures.has(e))
+      return this.getLoadedFeature(e);
+    if (this.loadingPromises.has(e))
+      return this.loadingPromises.get(e);
+    if (!await E.isSupported(e))
+      return console.warn(`Feature ${e} is not supported in this browser`), null;
+    const r = this.loadWithRetry(e);
+    this.loadingPromises.set(e, r);
+    try {
+      const n = await r;
+      return this.loadedFeatures.add(e), n;
+    } catch (n) {
+      return console.error(`Failed to load feature ${e}:`, n), this.loadingPromises.delete(e), null;
+    }
+  }
+  async loadWithRetry(e, t = 1) {
+    try {
+      return await this.loadFeatureModule(e);
+    } catch (r) {
+      if (t < this.config.retryAttempts)
+        return console.warn(`Loading feature ${e} failed, retrying (${t}/${this.config.retryAttempts})`), await new Promise((n) => setTimeout(n, 1e3 * t)), this.loadWithRetry(e, t + 1);
+      throw r;
+    }
+  }
+  async loadFeatureModule(e) {
+    switch (e) {
+      case l.SUBTITLES:
+        return import("./hooks-BhW_i-9L.js").then((t) => t.x);
+      case l.PLAYLISTS:
+        return import("./enhanced-components-Da0TSvKe.js").then((t) => t.g);
+      // Use existing features
+      case l.ADVANCED_CONTROLS:
+        return import("./enhanced-components-Da0TSvKe.js").then((t) => t.g);
+      case l.ANALYTICS:
+        return import("./enhanced-components-Da0TSvKe.js").then((t) => t.g);
+      // Use existing features
+      case l.PICTURE_IN_PICTURE:
+        return import("./enhanced-components-Da0TSvKe.js").then((t) => t.g);
+      // Use existing features
+      case l.QUALITY_SELECTOR:
+        return import("./enhanced-components-Da0TSvKe.js").then((t) => t.g);
+      // Use existing features
+      case l.PLAYBACK_SPEED:
+        return import("./enhanced-components-Da0TSvKe.js").then((t) => t.g);
+      // Use existing features
+      case l.CHAPTERS:
+        return import("./enhanced-components-Da0TSvKe.js").then((t) => t.g);
+      // Use existing features
+      case l.THUMBNAILS:
+        return import("./enhanced-components-Da0TSvKe.js").then((t) => t.g);
+      // Use existing features
+      case l.KEYBOARD_SHORTCUTS:
+        return import("./hooks-BhW_i-9L.js").then((t) => t.w);
+      default:
+        throw new Error(`Unknown feature: ${e}`);
+    }
+  }
+  getLoadedFeature(e) {
+    return this.loadingPromises.get(e);
+  }
+  // Preload features for faster access
+  async preloadFeatures(e = this.config.enabledFeatures) {
+    const t = e.map((r) => this.loadFeature(r));
+    await Promise.allSettled(t);
+  }
+  // Get loading state
+  getLoadingState() {
+    return {
+      loaded: Array.from(this.loadedFeatures),
+      loading: Array.from(this.loadingPromises.keys()),
+      enabled: this.config.enabledFeatures
+    };
+  }
+}
+const b = new W();
+function K(o) {
+  const [e, t] = m.useState(null), [r, n] = m.useState(!1), [s, i] = m.useState(null), a = m.useCallback(async () => {
+    if (!(r || e)) {
+      n(!0), i(null);
+      try {
+        const c = await b.loadFeature(o);
+        t(c);
+      } catch (c) {
+        i(c);
+      } finally {
+        n(!1);
+      }
+    }
+  }, [o, r, e]);
+  return m.useEffect(() => {
+    b.config.loadingStrategy === "immediate" && a();
+  }, [a]), {
+    feature: e,
+    loading: r,
+    error: s,
+    load: a
+  };
+}
+function ge(o, e, t) {
+  return function(n) {
+    const { feature: s, loading: i, error: a } = K(e);
+    if (i)
+      return /* @__PURE__ */ f.jsx("div", { className: "h-8 animate-pulse rounded bg-gray-200" });
+    if (a || !s) {
+      const c = t;
+      return c ? /* @__PURE__ */ f.jsx(c, { ...n }) : null;
+    }
+    return /* @__PURE__ */ f.jsx(o, { ...n });
+  };
+}
+const he = "1.0.0";
+export {
+  ye as AnalyticsPlugin,
+  we as BasePlugin,
+  he as CORE_ARCHITECTURE_VERSION,
+  B as ConsolePluginLogger,
+  Ie as EVENT_SYSTEM_VERSION,
+  I as EventBus,
+  Ne as EventDelegator,
+  l as FEATURES,
+  E as FeatureDetector,
+  M as MediaLoadingOptimizer,
+  $e as MiddlewareBuilder,
+  _ as NetworkMonitor,
+  Te as PLUGIN_SYSTEM_VERSION,
+  P as PerformanceBenchmark,
+  O as PerformanceBudgetMonitor,
+  Ge as PerformanceDashboard,
+  Xe as PerformanceMonitor,
+  F as PerformanceRegressionDetector,
+  U as PerformanceTestFramework,
+  Se as PluginConflictError,
+  ve as PluginDependencyError,
+  be as PluginDevelopmentHelpers,
+  Pe as PluginError,
+  Me as PluginPerformanceMonitor,
+  R as PluginRegistry,
+  Le as PluginStorage,
+  Ee as PluginValidator,
+  W as ProgressiveLoader,
+  Y as ServiceProvider,
+  xe as commonMiddlewares,
+  Ce as createAnalyticsPlugin,
+  de as createArchitecture,
+  Fe as createMiddleware,
+  ke as createPlugin,
+  Ue as defaultEventBus,
+  z as defaultMediaLoadingConfig,
+  D as defaultPerformanceBudgets,
+  Ae as defaultPerformanceMonitor,
+  Be as defaultPluginLogger,
+  Q as defaultProgressiveConfig,
+  Ze as defaultThresholds,
+  De as eventMiddlewares,
+  me as lazyComponents,
+  V as mediaLoadingOptimizer,
+  v as performanceBenchmark,
+  ne as performanceBudgetMonitor,
+  et as performanceMonitor,
+  re as performanceTestFramework,
+  te as performanceTestUtils,
+  b as progressiveLoader,
+  ce as useAnalytics,
+  Oe as useConditionalEventListener,
+  ze as useEventBus,
+  _e as useEventDebugger,
+  Ve as useEventEffect,
+  He as useEventEmitter,
+  je as useEventHandlers,
+  Ye as useEventHistory,
+  Qe as useEventListener,
+  We as useEventMetrics,
+  Ke as useEventOnce,
+  Je as useEventState,
+  le as useLogger,
+  oe as useMediaLoadingOptimizer,
+  tt as usePerformanceMonitor,
+  ie as usePluginRegistry,
+  K as useProgressiveFeature,
+  se as useServiceEventBus,
+  p as useServices,
+  ae as useStorage,
+  rt as withPerformanceMonitoring,
+  ge as withProgressiveFeature,
+  ue as withServices
+};
+//# sourceMappingURL=core.mjs.map