@therealtinhtute/baroiplayer 1.0.7 → 1.1.0

package/dist/context-BYwDoSRX.js

@@ -0,0 +1,1172 @@
+var le = Object.defineProperty;
+var ue = (o, e, t) => e in o ? le(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var M = (o, e, t) => ue(o, typeof e != "symbol" ? e + "" : e, t);
+import T from "react";
+var W = { exports: {} }, K = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var re;
+function Ee() {
+  if (re) return K;
+  re = 1;
+  var o = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function t(r, a, n) {
+    var E = null;
+    if (n !== void 0 && (E = "" + n), a.key !== void 0 && (E = "" + a.key), "key" in a) {
+      n = {};
+      for (var c in a)
+        c !== "key" && (n[c] = a[c]);
+    } else n = a;
+    return a = n.ref, {
+      $$typeof: o,
+      type: r,
+      key: E,
+      ref: a !== void 0 ? a : null,
+      props: n
+    };
+  }
+  return K.Fragment = e, K.jsx = t, K.jsxs = t, K;
+}
+var V = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var se;
+function de() {
+  return se || (se = 1, process.env.NODE_ENV !== "production" && (function() {
+    function o(s) {
+      if (s == null) return null;
+      if (typeof s == "function")
+        return s.$$typeof === l ? null : s.displayName || s.name || null;
+      if (typeof s == "string") return s;
+      switch (s) {
+        case L:
+          return "Fragment";
+        case v:
+          return "Profiler";
+        case U:
+          return "StrictMode";
+        case C:
+          return "Suspense";
+        case h:
+          return "SuspenseList";
+        case J:
+          return "Activity";
+      }
+      if (typeof s == "object")
+        switch (typeof s.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), s.$$typeof) {
+          case D:
+            return "Portal";
+          case j:
+            return (s.displayName || "Context") + ".Provider";
+          case G:
+            return (s._context.displayName || "Context") + ".Consumer";
+          case I:
+            var d = s.render;
+            return s = s.displayName, s || (s = d.displayName || d.name || "", s = s !== "" ? "ForwardRef(" + s + ")" : "ForwardRef"), s;
+          case B:
+            return d = s.displayName || null, d !== null ? d : o(s.type) || "Memo";
+          case w:
+            d = s._payload, s = s._init;
+            try {
+              return o(s(d));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(s) {
+      return "" + s;
+    }
+    function t(s) {
+      try {
+        var d = !1;
+      } catch {
+        d = !0;
+      }
+      if (d) {
+        d = console;
+        var f = d.error, R = typeof Symbol == "function" && Symbol.toStringTag && s[Symbol.toStringTag] || s.constructor.name || "Object";
+        return f.call(
+          d,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          R
+        ), e(s);
+      }
+    }
+    function r(s) {
+      if (s === L) return "<>";
+      if (typeof s == "object" && s !== null && s.$$typeof === w)
+        return "<...>";
+      try {
+        var d = o(s);
+        return d ? "<" + d + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function a() {
+      var s = u.A;
+      return s === null ? null : s.getOwner();
+    }
+    function n() {
+      return Error("react-stack-top-frame");
+    }
+    function E(s) {
+      if (y.call(s, "key")) {
+        var d = Object.getOwnPropertyDescriptor(s, "key").get;
+        if (d && d.isReactWarning) return !1;
+      }
+      return s.key !== void 0;
+    }
+    function c(s, d) {
+      function f() {
+        N || (N = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          d
+        ));
+      }
+      f.isReactWarning = !0, Object.defineProperty(s, "key", {
+        get: f,
+        configurable: !0
+      });
+    }
+    function S() {
+      var s = o(this.type);
+      return z[s] || (z[s] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), s = this.props.ref, s !== void 0 ? s : null;
+    }
+    function _(s, d, f, R, k, P, $, X) {
+      return f = P.ref, s = {
+        $$typeof: A,
+        type: s,
+        key: d,
+        props: P,
+        _owner: k
+      }, (f !== void 0 ? f : null) !== null ? Object.defineProperty(s, "ref", {
+        enumerable: !1,
+        get: S
+      }) : Object.defineProperty(s, "ref", { enumerable: !1, value: null }), s._store = {}, Object.defineProperty(s._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(s, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(s, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: $
+      }), Object.defineProperty(s, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: X
+      }), Object.freeze && (Object.freeze(s.props), Object.freeze(s)), s;
+    }
+    function p(s, d, f, R, k, P, $, X) {
+      var m = d.children;
+      if (m !== void 0)
+        if (R)
+          if (x(m)) {
+            for (R = 0; R < m.length; R++)
+              F(m[R]);
+            Object.freeze && Object.freeze(m);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else F(m);
+      if (y.call(d, "key")) {
+        m = o(s);
+        var Y = Object.keys(d).filter(function(ce) {
+          return ce !== "key";
+        });
+        R = 0 < Y.length ? "{key: someKey, " + Y.join(": ..., ") + ": ...}" : "{key: someKey}", te[m + R] || (Y = 0 < Y.length ? "{" + Y.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          R,
+          m,
+          Y,
+          m
+        ), te[m + R] = !0);
+      }
+      if (m = null, f !== void 0 && (t(f), m = "" + f), E(d) && (t(d.key), m = "" + d.key), "key" in d) {
+        f = {};
+        for (var q in d)
+          q !== "key" && (f[q] = d[q]);
+      } else f = d;
+      return m && c(
+        f,
+        typeof s == "function" ? s.displayName || s.name || "Unknown" : s
+      ), _(
+        s,
+        m,
+        P,
+        k,
+        a(),
+        f,
+        $,
+        X
+      );
+    }
+    function F(s) {
+      typeof s == "object" && s !== null && s.$$typeof === A && s._store && (s._store.validated = 1);
+    }
+    var g = T, A = Symbol.for("react.transitional.element"), D = Symbol.for("react.portal"), L = Symbol.for("react.fragment"), U = Symbol.for("react.strict_mode"), v = Symbol.for("react.profiler"), G = Symbol.for("react.consumer"), j = Symbol.for("react.context"), I = Symbol.for("react.forward_ref"), C = Symbol.for("react.suspense"), h = Symbol.for("react.suspense_list"), B = Symbol.for("react.memo"), w = Symbol.for("react.lazy"), J = Symbol.for("react.activity"), l = Symbol.for("react.client.reference"), u = g.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, y = Object.prototype.hasOwnProperty, x = Array.isArray, O = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    g = {
+      "react-stack-bottom-frame": function(s) {
+        return s();
+      }
+    };
+    var N, z = {}, Z = g["react-stack-bottom-frame"].bind(
+      g,
+      n
+    )(), ee = O(r(n)), te = {};
+    V.Fragment = L, V.jsx = function(s, d, f, R, k) {
+      var P = 1e4 > u.recentlyCreatedOwnerStacks++;
+      return p(
+        s,
+        d,
+        f,
+        !1,
+        R,
+        k,
+        P ? Error("react-stack-top-frame") : Z,
+        P ? O(r(s)) : ee
+      );
+    }, V.jsxs = function(s, d, f, R, k) {
+      var P = 1e4 > u.recentlyCreatedOwnerStacks++;
+      return p(
+        s,
+        d,
+        f,
+        !0,
+        R,
+        k,
+        P ? Error("react-stack-top-frame") : Z,
+        P ? O(r(s)) : ee
+      );
+    };
+  })()), V;
+}
+var ne;
+function fe() {
+  return ne || (ne = 1, process.env.NODE_ENV === "production" ? W.exports = /* @__PURE__ */ Ee() : W.exports = /* @__PURE__ */ de()), W.exports;
+}
+var ae = /* @__PURE__ */ fe();
+const i = {
+  PLAY: "PLAY",
+  PAUSE: "PAUSE",
+  SEEK: "SEEK",
+  SET_VOLUME: "SET_VOLUME",
+  MUTE: "MUTE",
+  UNMUTE: "UNMUTE",
+  TOGGLE_MUTE: "TOGGLE_MUTE",
+  SET_DURATION: "SET_DURATION",
+  SET_CURRENT_TIME: "SET_CURRENT_TIME",
+  SET_BUFFERED: "SET_BUFFERED",
+  SET_LOADING: "SET_LOADING",
+  SET_ERROR: "SET_ERROR",
+  ENTER_FULLSCREEN: "ENTER_FULLSCREEN",
+  EXIT_FULLSCREEN: "EXIT_FULLSCREEN",
+  ENTER_PIP: "ENTER_PIP",
+  EXIT_PIP: "EXIT_PIP",
+  SET_PLAYBACK_RATE: "SET_PLAYBACK_RATE",
+  SET_SUBTITLE_TRACK: "SET_SUBTITLE_TRACK",
+  SET_RENDITION: "SET_RENDITION",
+  TOGGLE_SUBTITLES: "TOGGLE_SUBTITLES",
+  PREVIEW_TIME: "PREVIEW_TIME",
+  CLEAR_PREVIEW: "CLEAR_PREVIEW",
+  // New actions for Video.js adapter
+  SET_BUFFERING: "SET_BUFFERING",
+  SET_QUALITY_LEVEL: "SET_QUALITY_LEVEL",
+  SET_BANDWIDTH_ESTIMATE: "SET_BANDWIDTH_ESTIMATE",
+  SET_ACTIVE_TEXT_TRACKS: "SET_ACTIVE_TEXT_TRACKS"
+}, oe = T.createContext(null);
+function Se() {
+  const o = T.useContext(oe);
+  if (!o)
+    throw new Error("useMediaContext must be used within a MediaPlayer");
+  return o;
+}
+const ie = T.createContext(null);
+function H() {
+  const o = T.useContext(ie);
+  if (!o)
+    throw new Error("useMediaStore must be used within a MediaPlayer");
+  return o;
+}
+function Te(o, e) {
+  if (Object.is(o, e)) return !0;
+  if (typeof o != "object" || o === null || typeof e != "object" || e === null)
+    return !1;
+  const t = Object.keys(o), r = Object.keys(e);
+  if (t.length !== r.length) return !1;
+  for (const a of t) {
+    if (!r.includes(a)) return !1;
+    const n = o[a], E = e[a];
+    if (!Object.is(n, E)) return !1;
+  }
+  return !0;
+}
+function ke(o) {
+  const e = H(), t = () => o(e.getState()), r = T.useRef(void 0), a = T.useCallback(() => {
+    const E = o(e.getState());
+    return r.current = E, E;
+  }, [o]), n = T.useSyncExternalStore(e.subscribe, t, a);
+  return T.useEffect(() => {
+    const E = r.current;
+    E !== void 0 && Te(E, n) || (r.current = n);
+  }, [n]), n;
+}
+function Me() {
+  return H().dispatch;
+}
+function Le(o) {
+  const e = H(), t = "getOptimisticState" in e, r = () => o(t ? e.getOptimisticState() : e.getState());
+  return T.useSyncExternalStore(e.subscribe, r, r);
+}
+function Ue() {
+  const o = H(), e = Se(), t = "getOptimisticState" in o, r = "errorHandler" in e ? e.errorHandler : null, a = "isRehydrated" in e ? e.isRehydrated : !0;
+  return {
+    isEnhanced: t,
+    errorHandler: r,
+    isRehydrated: a,
+    actionsState: t ? o.getActionState() : null
+  };
+}
+const Q = {
+  isPlaying: !1,
+  currentTime: 0,
+  duration: 0,
+  buffered: null,
+  isLoading: !1,
+  isBuffering: !1,
+  error: null,
+  volume: 1,
+  isMuted: !1,
+  isFullscreen: !1,
+  isPictureInPicture: !1,
+  playbackRate: 1,
+  subtitlesShowing: !1,
+  selectedSubtitleTrack: null,
+  selectedRendition: null,
+  qualityLevel: -1,
+  bandwidthEstimate: 0,
+  activeTextTracks: [],
+  previewTime: null,
+  previewImage: null,
+  previewCoords: null,
+  subtitlesList: [],
+  renditionList: []
+}, ye = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 1e4,
+  exponentialBackoff: !0,
+  retryableErrors: [
+    "NETWORK_ERROR",
+    "TIMEOUT_ERROR"
+    /* TIMEOUT_ERROR */
+  ],
+  retryableActions: ["PLAY", "PAUSE", "SEEK", "SET_VOLUME", "ENTER_FULLSCREEN", "EXIT_FULLSCREEN"]
+};
+class Re {
+  canRecover(e) {
+    return e.type === "NETWORK_ERROR" && e.retryCount < 3;
+  }
+  async recover(e) {
+    navigator.onLine === !1 && await new Promise((t) => {
+      const r = () => {
+        window.removeEventListener("online", r), t(void 0);
+      };
+      window.addEventListener("online", r);
+    }), await new Promise((t) => setTimeout(t, 2e3));
+  }
+}
+class me {
+  canRecover(e) {
+    return e.type === "PLAYBACK_ERROR" && e.retryCount < 2;
+  }
+  async recover(e) {
+    const t = document.querySelector("video, audio");
+    t && (t.load(), await new Promise((r) => {
+      const a = () => {
+        t.removeEventListener("canplay", a), r(void 0);
+      };
+      t.addEventListener("canplay", a);
+    }));
+  }
+}
+class pe {
+  canRecover(e) {
+    return e.type === "PERMISSION_ERROR" && e.action?.type === "ENTER_FULLSCREEN";
+  }
+  async recover(e) {
+    console.warn("Fullscreen requires user interaction");
+  }
+}
+class ge {
+  constructor(e = {}, t = []) {
+    M(this, "config");
+    M(this, "recoveryStrategies");
+    M(this, "errorQueue", /* @__PURE__ */ new Map());
+    M(this, "listeners", /* @__PURE__ */ new Set());
+    this.config = { ...ye, ...e }, this.recoveryStrategies = [
+      new Re(),
+      new me(),
+      new pe(),
+      ...t
+    ];
+  }
+  // Create a media error from a generic error
+  createMediaError(e, t, r = 0) {
+    const a = Date.now();
+    if (e instanceof Error) {
+      const n = this.categorizeError(e, t);
+      return {
+        type: n,
+        message: e.message,
+        action: t,
+        timestamp: a,
+        retryable: this.isRetryable(n, t),
+        retryCount: r,
+        originalError: e
+      };
+    }
+    return {
+      type: "UNKNOWN_ERROR",
+      message: typeof e == "string" ? e : "Unknown error occurred",
+      action: t,
+      timestamp: a,
+      retryable: this.isRetryable("UNKNOWN_ERROR", t),
+      retryCount: r
+    };
+  }
+  // Categorize errors based on error properties and action context
+  categorizeError(e, t) {
+    const r = e.message.toLowerCase();
+    return r.includes("network") || r.includes("fetch") || r.includes("connection") || e.name === "NetworkError" ? "NETWORK_ERROR" : r.includes("permission") || r.includes("denied") || r.includes("fullscreen") || e.name === "NotAllowedError" ? "PERMISSION_ERROR" : r.includes("decode") || r.includes("format") || r.includes("codec") || t?.type === "PLAY" ? "PLAYBACK_ERROR" : r.includes("timeout") || e.name === "TimeoutError" ? "TIMEOUT_ERROR" : r.includes("not supported") || r.includes("unsupported") || e.name === "NotSupportedError" ? "NOT_SUPPORTED_ERROR" : "UNKNOWN_ERROR";
+  }
+  // Check if an error/action combination is retryable
+  isRetryable(e, t) {
+    const r = this.config.retryableErrors.includes(e), a = !t || this.config.retryableActions.includes(t.type);
+    return r && a;
+  }
+  // Calculate retry delay with exponential backoff
+  calculateRetryDelay(e) {
+    if (!this.config.exponentialBackoff)
+      return this.config.baseDelay;
+    const t = this.config.baseDelay * Math.pow(2, e);
+    return Math.min(t, this.config.maxDelay);
+  }
+  // Handle an error with automatic retry logic
+  async handleError(e, t, r) {
+    const a = this.createMediaError(e, t, t?.retryCount || 0), n = `${t?.type}-${a.timestamp}`;
+    this.errorQueue.set(n, a), this.listeners.forEach((E) => E(a));
+    for (const E of this.recoveryStrategies)
+      if (E.canRecover(a))
+        try {
+          await E.recover(a);
+          break;
+        } catch (c) {
+          console.warn("Recovery strategy failed:", c);
+        }
+    if (a.retryable && a.retryCount < this.config.maxRetries && r && t) {
+      const E = this.calculateRetryDelay(a.retryCount);
+      console.log(
+        `Retrying action ${t.type} in ${E}ms (attempt ${a.retryCount + 1}/${this.config.maxRetries})`
+      ), setTimeout(async () => {
+        try {
+          await r({
+            ...t,
+            retryCount: a.retryCount + 1
+          }), this.errorQueue.delete(n);
+        } catch (c) {
+          await this.handleError(
+            c,
+            {
+              ...t,
+              retryCount: a.retryCount + 1
+            },
+            r
+          );
+        }
+      }, E);
+    }
+    return a;
+  }
+  // Subscribe to error events
+  subscribe(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  // Get current errors
+  getErrors() {
+    return Array.from(this.errorQueue.values());
+  }
+  // Clear specific error
+  clearError(e) {
+    this.errorQueue.delete(e);
+  }
+  // Clear all errors
+  clearAllErrors() {
+    this.errorQueue.clear();
+  }
+  // Get error statistics
+  getErrorStats() {
+    const e = this.getErrors(), t = Date.now(), r = 300 * 1e3, a = e.reduce(
+      (c, S) => (c[S.type] = (c[S.type] || 0) + 1, c),
+      {}
+    ), n = e.filter((c) => c.retryable).length, E = e.filter((c) => t - c.timestamp < r);
+    return {
+      totalErrors: e.length,
+      errorsByType: a,
+      retryableErrors: n,
+      recentErrors: E
+    };
+  }
+}
+const _e = {
+  enabled: !0,
+  key: "baroi-player-state",
+  persist: ["volume", "isMuted", "playbackRate", "subtitlesShowing"],
+  debounceMs: 500
+};
+function he(o = Q, e = {}) {
+  let t = { ...o }, r = { ...o }, a = {
+    pending: !1,
+    error: null,
+    lastAction: null,
+    retryCount: 0
+  };
+  const n = { ..._e, ...e }, E = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
+  let S = null;
+  const _ = (l) => (E.add(l), () => E.delete(l)), p = () => {
+    E.forEach((l) => l());
+  }, F = () => t, g = () => r, A = () => a, D = async () => {
+    if (!n.enabled || typeof window > "u") return;
+    const l = n.persist.reduce(
+      (u, y) => (u[y] = t[y], u),
+      {}
+    );
+    try {
+      localStorage.setItem(
+        n.key,
+        JSON.stringify({
+          ...l,
+          timestamp: Date.now()
+        })
+      );
+    } catch (u) {
+      console.warn("Failed to persist media state:", u);
+    }
+  }, L = () => {
+    S && clearTimeout(S), S = setTimeout(D, n.debounceMs);
+  }, U = async () => {
+    if (!(!n.enabled || typeof window > "u"))
+      try {
+        const l = localStorage.getItem(n.key);
+        if (!l) return;
+        const u = JSON.parse(l), { timestamp: y, ...x } = u, O = 10080 * 60 * 1e3;
+        if (y && Date.now() - y > O) {
+          v();
+          return;
+        }
+        const N = { ...t, ...x };
+        JSON.stringify(N) !== JSON.stringify(t) && (t = N, r = { ...N }, p());
+      } catch (l) {
+        console.warn("Failed to rehydrate media state:", l);
+      }
+  }, v = () => {
+    if (!(typeof window > "u"))
+      try {
+        localStorage.removeItem(n.key);
+      } catch (l) {
+        console.warn("Failed to clear persisted state:", l);
+      }
+  }, G = (l) => {
+    Object.assign(n, l);
+  }, j = (l) => {
+    const u = { ...t, ...l };
+    JSON.stringify(u) !== JSON.stringify(t) && (t = u, r = { ...u }, L(), p());
+  }, I = (l) => {
+    const u = `${l.type}-${Date.now()}-${Math.random()}`;
+    c.set(u, { ...l, timestamp: Date.now() });
+    const y = h(r, l);
+    return r = { ...r, ...y }, p(), u;
+  }, C = (l) => {
+    if (c.has(l)) {
+      c.delete(l), r = { ...t };
+      for (const [, u] of c) {
+        const y = h(r, u);
+        r = { ...r, ...y };
+      }
+      p();
+    }
+  }, h = (l, u) => {
+    switch (u.type) {
+      case i.PLAY:
+        return { isPlaying: !0, error: null };
+      case i.PAUSE:
+        return { isPlaying: !1 };
+      case i.SEEK:
+        return { currentTime: u.detail };
+      case i.SET_VOLUME:
+        return { volume: Math.max(0, Math.min(1, u.detail)) };
+      case i.MUTE:
+        return { isMuted: !0 };
+      case i.UNMUTE:
+        return { isMuted: !1 };
+      case i.TOGGLE_MUTE:
+        return { isMuted: !l.isMuted };
+      case i.SET_DURATION:
+        return { duration: u.detail };
+      case i.SET_CURRENT_TIME:
+        return { currentTime: u.detail };
+      case i.SET_BUFFERED:
+        return { buffered: u.detail };
+      case i.SET_LOADING:
+        return { isLoading: u.detail };
+      case i.SET_ERROR:
+        return { error: u.detail, isLoading: !1 };
+      case i.ENTER_FULLSCREEN:
+        return { isFullscreen: !0 };
+      case i.EXIT_FULLSCREEN:
+        return { isFullscreen: !1 };
+      case i.ENTER_PIP:
+        return { isPictureInPicture: !0 };
+      case i.EXIT_PIP:
+        return { isPictureInPicture: !1 };
+      case i.SET_PLAYBACK_RATE:
+        return { playbackRate: u.detail };
+      case i.SET_SUBTITLE_TRACK:
+        return { selectedSubtitleTrack: u.detail };
+      case i.SET_RENDITION:
+        return { selectedRendition: u.detail };
+      case i.TOGGLE_SUBTITLES:
+        return { subtitlesShowing: !l.subtitlesShowing };
+      case i.PREVIEW_TIME:
+        return { previewTime: u.detail };
+      case i.CLEAR_PREVIEW:
+        return { previewTime: null, previewImage: null, previewCoords: null };
+      default:
+        return console.warn(`Unknown media action type: ${u.type}`), {};
+    }
+  }, B = (l) => {
+    const u = h(t, l);
+    j(u);
+  }, w = async (l) => {
+    a = {
+      pending: !0,
+      error: null,
+      lastAction: l,
+      retryCount: l.retryCount || 0
+    };
+    const u = I(l);
+    try {
+      await new Promise((O) => setTimeout(O, 0));
+      const y = h(t, l), x = { ...t, ...y };
+      JSON.stringify(x) !== JSON.stringify(t) && (t = x, L()), c.delete(u), a = {
+        pending: !1,
+        error: null,
+        lastAction: l,
+        retryCount: 0
+      }, r = { ...t };
+      for (const [, O] of c) {
+        const N = h(r, O);
+        r = { ...r, ...N };
+      }
+    } catch (y) {
+      C(u), a = {
+        pending: !1,
+        error: y instanceof Error ? y.message : "Unknown error occurred",
+        lastAction: l,
+        retryCount: (l.retryCount || 0) + 1
+      }, a.retryCount < 3 && J(l.type) && setTimeout(() => {
+        w({
+          ...l,
+          retryCount: a.retryCount
+        });
+      }, Math.pow(2, a.retryCount) * 1e3);
+    }
+    p();
+  }, J = (l) => [
+    i.PLAY,
+    i.PAUSE,
+    i.SEEK,
+    i.SET_VOLUME,
+    i.MUTE,
+    i.UNMUTE,
+    i.TOGGLE_MUTE
+  ].includes(l);
+  return U(), {
+    subscribe: _,
+    getState: F,
+    setState: j,
+    dispatch: B,
+    getOptimisticState: g,
+    dispatchOptimistic: w,
+    rollbackOptimistic: C,
+    getActionState: A,
+    setPersistenceConfig: G,
+    rehydrateFromStorage: U,
+    clearPersistedState: v
+  };
+}
+const b = {
+  USER_PREFERENCES: "baroi-player-preferences",
+  SESSION_STATE: "baroi-player-session",
+  PLAYBACK_HISTORY: "baroi-player-history",
+  CACHE_TIMESTAMP: "baroi-player-cache-ts"
+};
+class be {
+  async getItem(e) {
+    if (typeof window > "u") return null;
+    try {
+      return localStorage.getItem(e);
+    } catch (t) {
+      return console.warn("Failed to read from localStorage:", t), null;
+    }
+  }
+  async setItem(e, t) {
+    if (!(typeof window > "u"))
+      try {
+        localStorage.setItem(e, t);
+      } catch (r) {
+        console.warn("Failed to write to localStorage:", r);
+      }
+  }
+  async removeItem(e) {
+    if (!(typeof window > "u"))
+      try {
+        localStorage.removeItem(e);
+      } catch (t) {
+        console.warn("Failed to remove from localStorage:", t);
+      }
+  }
+  async clear() {
+    if (!(typeof window > "u"))
+      try {
+        Object.values(b).forEach((e) => {
+          localStorage.removeItem(e);
+        });
+      } catch (e) {
+        console.warn("Failed to clear localStorage:", e);
+      }
+  }
+}
+const we = {
+  userPreferences: !0,
+  sessionState: !0,
+  playbackHistory: !0,
+  maxHistoryItems: 50,
+  maxCacheAge: 10080 * 60 * 1e3,
+  // 7 days
+  debounceMs: 1e3,
+  storage: new be()
+};
+class Pe {
+  constructor(e = {}) {
+    M(this, "config");
+    M(this, "storage");
+    M(this, "debounceTimeouts", /* @__PURE__ */ new Map());
+    this.config = { ...we, ...e }, this.storage = this.config.storage;
+  }
+  // User preferences methods
+  async getUserPreferences() {
+    if (!this.config.userPreferences) return null;
+    try {
+      const e = await this.storage.getItem(b.USER_PREFERENCES);
+      if (!e) return null;
+      const t = JSON.parse(e);
+      return this.isCacheExpired(t.timestamp) ? (await this.clearUserPreferences(), null) : t.preferences;
+    } catch (e) {
+      return console.warn("Failed to get user preferences:", e), null;
+    }
+  }
+  async saveUserPreferences(e) {
+    this.config.userPreferences && this.debounce(b.USER_PREFERENCES, async () => {
+      try {
+        const r = { ...await this.getUserPreferences() || {}, ...e };
+        await this.storage.setItem(
+          b.USER_PREFERENCES,
+          JSON.stringify({
+            preferences: r,
+            timestamp: Date.now()
+          })
+        );
+      } catch (t) {
+        console.warn("Failed to save user preferences:", t);
+      }
+    });
+  }
+  async clearUserPreferences() {
+    try {
+      await this.storage.removeItem(b.USER_PREFERENCES);
+    } catch (e) {
+      console.warn("Failed to clear user preferences:", e);
+    }
+  }
+  // Session state methods
+  async getSessionState() {
+    if (!this.config.sessionState) return null;
+    try {
+      const e = await this.storage.getItem(b.SESSION_STATE);
+      return e ? JSON.parse(e).state : null;
+    } catch (e) {
+      return console.warn("Failed to get session state:", e), null;
+    }
+  }
+  async saveSessionState(e) {
+    this.config.sessionState && this.debounce(b.SESSION_STATE, async () => {
+      try {
+        const r = { ...await this.getSessionState() || {
+          currentTime: 0,
+          playbackPosition: {}
+        }, ...e };
+        await this.storage.setItem(
+          b.SESSION_STATE,
+          JSON.stringify({
+            state: r,
+            timestamp: Date.now()
+          })
+        );
+      } catch (t) {
+        console.warn("Failed to save session state:", t);
+      }
+    });
+  }
+  async clearSessionState() {
+    try {
+      await this.storage.removeItem(b.SESSION_STATE);
+    } catch (e) {
+      console.warn("Failed to clear session state:", e);
+    }
+  }
+  // Playback history methods
+  async getPlaybackHistory() {
+    if (!this.config.playbackHistory) return [];
+    try {
+      const e = await this.storage.getItem(b.PLAYBACK_HISTORY);
+      if (!e) return [];
+      const t = JSON.parse(e);
+      return this.isCacheExpired(t.timestamp) ? (await this.clearPlaybackHistory(), []) : t.history || [];
+    } catch (e) {
+      return console.warn("Failed to get playback history:", e), [];
+    }
+  }
+  async addToPlaybackHistory(e) {
+    if (this.config.playbackHistory)
+      try {
+        const t = await this.getPlaybackHistory(), r = {
+          ...e,
+          timestamp: Date.now()
+        }, a = t.filter((E) => E.mediaId !== e.mediaId), n = [r, ...a].slice(0, this.config.maxHistoryItems);
+        await this.storage.setItem(
+          b.PLAYBACK_HISTORY,
+          JSON.stringify({
+            history: n,
+            timestamp: Date.now()
+          })
+        );
+      } catch (t) {
+        console.warn("Failed to add to playback history:", t);
+      }
+  }
+  async clearPlaybackHistory() {
+    try {
+      await this.storage.removeItem(b.PLAYBACK_HISTORY);
+    } catch (e) {
+      console.warn("Failed to clear playback history:", e);
+    }
+  }
+  // Utility methods
+  async savePlaybackPosition(e, t) {
+    const a = (await this.getSessionState())?.playbackPosition || {};
+    await this.saveSessionState({
+      playbackPosition: {
+        ...a,
+        [e]: t
+      }
+    });
+  }
+  async getPlaybackPosition(e) {
+    return (await this.getSessionState())?.playbackPosition?.[e] || 0;
+  }
+  // Extract preferences from MediaState
+  extractUserPreferences(e) {
+    return {
+      volume: e.volume,
+      isMuted: e.isMuted,
+      playbackRate: e.playbackRate,
+      subtitlesShowing: e.subtitlesShowing,
+      selectedSubtitleTrack: e.selectedSubtitleTrack?.id || null,
+      preferredRendition: e.selectedRendition,
+      autoplay: !1,
+      // This would come from config
+      keyboardShortcuts: !0
+      // This would come from config
+    };
+  }
+  // Extract session state from MediaState
+  extractSessionState(e, t) {
+    return {
+      currentTime: e.currentTime,
+      mediaId: t,
+      playbackPosition: {}
+    };
+  }
+  // Clear all persisted data
+  async clearAll() {
+    await this.storage.clear(), this.debounceTimeouts.clear();
+  }
+  // Private helper methods
+  isCacheExpired(e) {
+    return e ? Date.now() - e > this.config.maxCacheAge : !0;
+  }
+  debounce(e, t) {
+    const r = this.debounceTimeouts.get(e);
+    r && clearTimeout(r);
+    const a = setTimeout(async () => {
+      await t(), this.debounceTimeouts.delete(e);
+    }, this.config.debounceMs);
+    this.debounceTimeouts.set(e, a);
+  }
+}
+function Oe(o) {
+  const [e] = T.useState(() => new Pe(o));
+  return T.useEffect(() => () => {
+    e.clearAll();
+  }, [e]), e;
+}
+function Ae(o, e, t) {
+  const r = Oe(t), [a, n] = T.useState(!1);
+  return T.useEffect(() => {
+    let E = !0;
+    return (async () => {
+      try {
+        const [S, _] = await Promise.all([
+          r.getUserPreferences(),
+          r.getSessionState()
+        ]);
+        if (!E) return;
+        const p = {
+          ...S && {
+            volume: S.volume,
+            isMuted: S.isMuted,
+            playbackRate: S.playbackRate,
+            subtitlesShowing: S.subtitlesShowing
+          },
+          ..._ && e === _.mediaId && {
+            currentTime: _.currentTime
+          }
+        };
+        Object.keys(p).length > 0 && console.log("Rehydrated state:", p), n(!0);
+      } catch (S) {
+        console.warn("Failed to rehydrate state:", S), n(!0);
+      }
+    })(), () => {
+      E = !1;
+    };
+  }, [r, e]), T.useEffect(() => {
+    if (!a) return;
+    const E = r.extractUserPreferences(o);
+    if (r.saveUserPreferences(E), e) {
+      const c = r.extractSessionState(o, e);
+      r.saveSessionState(c), o.currentTime > 0 && o.duration > 0 && r.savePlaybackPosition(e, o.currentTime);
+    }
+  }, [r, o, e, a]), {
+    manager: r,
+    isRehydrated: a
+  };
+}
+function ve(o = Q) {
+  let e = { ...o };
+  const t = /* @__PURE__ */ new Set(), r = (c) => (t.add(c), () => t.delete(c)), a = () => e, n = (c) => {
+    const S = { ...e, ...c };
+    JSON.stringify(S) !== JSON.stringify(e) && (e = S, t.forEach((_) => _()));
+  };
+  return { subscribe: r, getState: a, setState: n, dispatch: (c) => {
+    switch (c.type) {
+      case i.PLAY:
+        n({ isPlaying: !0, error: null });
+        break;
+      case i.PAUSE:
+        n({ isPlaying: !1 });
+        break;
+      case i.SEEK:
+        n({ currentTime: c.detail });
+        break;
+      case i.SET_VOLUME:
+        n({ volume: Math.max(0, Math.min(1, c.detail)) });
+        break;
+      case i.MUTE:
+        n({ isMuted: !0 });
+        break;
+      case i.UNMUTE:
+        n({ isMuted: !1 });
+        break;
+      case i.TOGGLE_MUTE:
+        n({ isMuted: !e.isMuted });
+        break;
+      case i.SET_DURATION:
+        n({ duration: c.detail });
+        break;
+      case i.SET_CURRENT_TIME:
+        n({ currentTime: c.detail });
+        break;
+      case i.SET_BUFFERED:
+        n({ buffered: c.detail });
+        break;
+      case i.SET_LOADING:
+        n({ isLoading: c.detail });
+        break;
+      case i.SET_ERROR:
+        n({ error: c.detail, isLoading: !1 });
+        break;
+      case i.ENTER_FULLSCREEN:
+        n({ isFullscreen: !0 });
+        break;
+      case i.EXIT_FULLSCREEN:
+        n({ isFullscreen: !1 });
+        break;
+      case i.ENTER_PIP:
+        n({ isPictureInPicture: !0 });
+        break;
+      case i.EXIT_PIP:
+        n({ isPictureInPicture: !1 });
+        break;
+      case i.SET_PLAYBACK_RATE:
+        n({ playbackRate: c.detail });
+        break;
+      case i.SET_SUBTITLE_TRACK:
+        n({ selectedSubtitleTrack: c.detail });
+        break;
+      case i.SET_RENDITION:
+        n({ selectedRendition: c.detail });
+        break;
+      case i.TOGGLE_SUBTITLES:
+        n({ subtitlesShowing: !e.subtitlesShowing });
+        break;
+      case i.PREVIEW_TIME:
+        n({ previewTime: c.detail });
+        break;
+      case i.CLEAR_PREVIEW:
+        n({ previewTime: null, previewImage: null, previewCoords: null });
+        break;
+      default:
+        console.warn(`Unknown media action type: ${c.type}`);
+    }
+  } };
+}
+function Ce({
+  children: o,
+  mediaId: e = "media-player",
+  labelId: t = "media-player-label",
+  descriptionId: r = "media-player-description",
+  dir: a = "ltr",
+  portalContainer: n,
+  tooltipDelayDuration: E = 700,
+  tooltipSideOffset: c = 4,
+  disabled: S = !1,
+  isVideo: _ = !0,
+  withoutTooltip: p = !1,
+  initialState: F = {},
+  // React 19 enhancements
+  useEnhancedStore: g = !0,
+  persistenceConfig: A,
+  retryConfig: D,
+  enableOptimisticUpdates: L = !0,
+  enableErrorRecovery: U = !0,
+  onStateRehydrated: v
+}) {
+  const G = T.useRef(null), j = T.useRef(null), I = T.useMemo(() => {
+    const w = { ...Q, ...F };
+    return g ? he(w, A) : ve(w);
+  }, [g, A]), C = T.useMemo(() => U && g ? new ge(D) : null, [U, g, D]), h = Ae(I.getState(), e, A);
+  T.useEffect(() => {
+    if (h?.isRehydrated && v) {
+      const w = I.getState();
+      v(w);
+    }
+  }, [h?.isRehydrated, v, I]);
+  const B = T.useMemo(
+    () => ({
+      mediaId: e,
+      labelId: t,
+      descriptionId: r,
+      dir: a,
+      rootRef: G,
+      mediaRef: j,
+      portalContainer: n,
+      tooltipDelayDuration: E,
+      tooltipSideOffset: c,
+      disabled: S,
+      isVideo: _,
+      withoutTooltip: p,
+      // React 19 enhancements
+      errorHandler: C,
+      isEnhanced: g,
+      isRehydrated: h?.isRehydrated
+    }),
+    [
+      e,
+      t,
+      r,
+      a,
+      n,
+      E,
+      c,
+      S,
+      _,
+      p,
+      C,
+      g,
+      h?.isRehydrated
+    ]
+  );
+  return /* @__PURE__ */ ae.jsx(oe.Provider, { value: B, children: /* @__PURE__ */ ae.jsx(ie.Provider, { value: I, children: o }) });
+}
+export {
+  i as M,
+  Me as a,
+  ke as b,
+  H as c,
+  Ce as d,
+  Le as e,
+  he as f,
+  oe as g,
+  ie as h,
+  Ue as i,
+  ae as j,
+  Q as k,
+  Se as u
+};
+//# sourceMappingURL=context-BYwDoSRX.js.map