@therealtinhtute/baroiplayer 1.0.0

package/dist/context-BMteAJDN.js

@@ -0,0 +1,1140 @@
+var le = Object.defineProperty;
+var ue = (i, e, t) => e in i ? le(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var M = (i, e, t) => ue(i, typeof e != "symbol" ? e + "" : e, t);
+import S from "react";
+var H = { 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 i = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function t(s, n, a) {
+    var d = null;
+    if (a !== void 0 && (d = "" + a), n.key !== void 0 && (d = "" + n.key), "key" in n) {
+      a = {};
+      for (var c in n)
+        c !== "key" && (a[c] = n[c]);
+    } else a = n;
+    return n = a.ref, {
+      $$typeof: i,
+      type: s,
+      key: d,
+      ref: n !== void 0 ? n : null,
+      props: a
+    };
+  }
+  return K.Fragment = e, K.jsx = t, K.jsxs = t, K;
+}
+var W = {};
+/**
+ * @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 i(r) {
+      if (r == null) return null;
+      if (typeof r == "function")
+        return r.$$typeof === l ? null : r.displayName || r.name || null;
+      if (typeof r == "string") return r;
+      switch (r) {
+        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 r == "object")
+        switch (typeof r.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), r.$$typeof) {
+          case D:
+            return "Portal";
+          case Y:
+            return (r.displayName || "Context") + ".Provider";
+          case G:
+            return (r._context.displayName || "Context") + ".Consumer";
+          case I:
+            var E = r.render;
+            return r = r.displayName, r || (r = E.displayName || E.name || "", r = r !== "" ? "ForwardRef(" + r + ")" : "ForwardRef"), r;
+          case B:
+            return E = r.displayName || null, E !== null ? E : i(r.type) || "Memo";
+          case w:
+            E = r._payload, r = r._init;
+            try {
+              return i(r(E));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(r) {
+      return "" + r;
+    }
+    function t(r) {
+      try {
+        var E = !1;
+      } catch {
+        E = !0;
+      }
+      if (E) {
+        E = console;
+        var f = E.error, R = typeof Symbol == "function" && Symbol.toStringTag && r[Symbol.toStringTag] || r.constructor.name || "Object";
+        return f.call(
+          E,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          R
+        ), e(r);
+      }
+    }
+    function s(r) {
+      if (r === L) return "<>";
+      if (typeof r == "object" && r !== null && r.$$typeof === w)
+        return "<...>";
+      try {
+        var E = i(r);
+        return E ? "<" + E + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function n() {
+      var r = u.A;
+      return r === null ? null : r.getOwner();
+    }
+    function a() {
+      return Error("react-stack-top-frame");
+    }
+    function d(r) {
+      if (y.call(r, "key")) {
+        var E = Object.getOwnPropertyDescriptor(r, "key").get;
+        if (E && E.isReactWarning) return !1;
+      }
+      return r.key !== void 0;
+    }
+    function c(r, E) {
+      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)",
+          E
+        ));
+      }
+      f.isReactWarning = !0, Object.defineProperty(r, "key", {
+        get: f,
+        configurable: !0
+      });
+    }
+    function T() {
+      var r = i(this.type);
+      return z[r] || (z[r] = !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."
+      )), r = this.props.ref, r !== void 0 ? r : null;
+    }
+    function g(r, E, f, R, k, P, $, X) {
+      return f = P.ref, r = {
+        $$typeof: A,
+        type: r,
+        key: E,
+        props: P,
+        _owner: k
+      }, (f !== void 0 ? f : null) !== null ? Object.defineProperty(r, "ref", {
+        enumerable: !1,
+        get: T
+      }) : Object.defineProperty(r, "ref", { enumerable: !1, value: null }), r._store = {}, Object.defineProperty(r._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(r, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(r, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: $
+      }), Object.defineProperty(r, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: X
+      }), Object.freeze && (Object.freeze(r.props), Object.freeze(r)), r;
+    }
+    function p(r, E, f, R, k, P, $, X) {
+      var m = E.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(E, "key")) {
+        m = i(r);
+        var j = Object.keys(E).filter(function(ce) {
+          return ce !== "key";
+        });
+        R = 0 < j.length ? "{key: someKey, " + j.join(": ..., ") + ": ...}" : "{key: someKey}", te[m + R] || (j = 0 < j.length ? "{" + j.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,
+          j,
+          m
+        ), te[m + R] = !0);
+      }
+      if (m = null, f !== void 0 && (t(f), m = "" + f), d(E) && (t(E.key), m = "" + E.key), "key" in E) {
+        f = {};
+        for (var q in E)
+          q !== "key" && (f[q] = E[q]);
+      } else f = E;
+      return m && c(
+        f,
+        typeof r == "function" ? r.displayName || r.name || "Unknown" : r
+      ), g(
+        r,
+        m,
+        P,
+        k,
+        n(),
+        f,
+        $,
+        X
+      );
+    }
+    function F(r) {
+      typeof r == "object" && r !== null && r.$$typeof === A && r._store && (r._store.validated = 1);
+    }
+    var _ = S, 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"), Y = 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 = _.__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;
+    };
+    _ = {
+      "react-stack-bottom-frame": function(r) {
+        return r();
+      }
+    };
+    var N, z = {}, Z = _["react-stack-bottom-frame"].bind(
+      _,
+      a
+    )(), ee = O(s(a)), te = {};
+    W.Fragment = L, W.jsx = function(r, E, f, R, k) {
+      var P = 1e4 > u.recentlyCreatedOwnerStacks++;
+      return p(
+        r,
+        E,
+        f,
+        !1,
+        R,
+        k,
+        P ? Error("react-stack-top-frame") : Z,
+        P ? O(s(r)) : ee
+      );
+    }, W.jsxs = function(r, E, f, R, k) {
+      var P = 1e4 > u.recentlyCreatedOwnerStacks++;
+      return p(
+        r,
+        E,
+        f,
+        !0,
+        R,
+        k,
+        P ? Error("react-stack-top-frame") : Z,
+        P ? O(s(r)) : ee
+      );
+    };
+  })()), W;
+}
+var ne;
+function fe() {
+  return ne || (ne = 1, process.env.NODE_ENV === "production" ? H.exports = /* @__PURE__ */ Ee() : H.exports = /* @__PURE__ */ de()), H.exports;
+}
+var ae = /* @__PURE__ */ fe();
+const o = {
+  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 = S.createContext(null);
+function Te() {
+  const i = S.useContext(oe);
+  if (!i)
+    throw new Error("useMediaContext must be used within a MediaPlayer");
+  return i;
+}
+const ie = S.createContext(null);
+function V() {
+  const i = S.useContext(ie);
+  if (!i)
+    throw new Error("useMediaStore must be used within a MediaPlayer");
+  return i;
+}
+function Ne(i) {
+  const e = V(), t = () => i(e.getState());
+  return S.useSyncExternalStore(e.subscribe, t, t);
+}
+function ke() {
+  return V().dispatch;
+}
+function Me(i) {
+  const e = V(), t = "getOptimisticState" in e, s = () => i(t ? e.getOptimisticState() : e.getState());
+  return S.useSyncExternalStore(e.subscribe, s, s);
+}
+function Le() {
+  const i = V(), e = Te(), t = "getOptimisticState" in i, s = "errorHandler" in e ? e.errorHandler : null, n = "isRehydrated" in e ? e.isRehydrated : !0;
+  return {
+    isEnhanced: t,
+    errorHandler: s,
+    isRehydrated: n,
+    actionsState: t ? i.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: []
+}, Se = {
+  enabled: !0,
+  key: "baroi-player-state",
+  persist: ["volume", "isMuted", "playbackRate", "subtitlesShowing"],
+  debounceMs: 500
+};
+function ye(i = Q, e = {}) {
+  let t = { ...i }, s = { ...i }, n = {
+    pending: !1,
+    error: null,
+    lastAction: null,
+    retryCount: 0
+  };
+  const a = { ...Se, ...e }, d = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
+  let T = null;
+  const g = (l) => (d.add(l), () => d.delete(l)), p = () => {
+    d.forEach((l) => l());
+  }, F = () => t, _ = () => s, A = () => n, D = async () => {
+    if (!a.enabled || typeof window > "u") return;
+    const l = a.persist.reduce((u, y) => (u[y] = t[y], u), {});
+    try {
+      localStorage.setItem(a.key, JSON.stringify({
+        ...l,
+        timestamp: Date.now()
+      }));
+    } catch (u) {
+      console.warn("Failed to persist media state:", u);
+    }
+  }, L = () => {
+    T && clearTimeout(T), T = setTimeout(D, a.debounceMs);
+  }, U = async () => {
+    if (!(!a.enabled || typeof window > "u"))
+      try {
+        const l = localStorage.getItem(a.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, s = { ...N }, p());
+      } catch (l) {
+        console.warn("Failed to rehydrate media state:", l);
+      }
+  }, v = () => {
+    if (!(typeof window > "u"))
+      try {
+        localStorage.removeItem(a.key);
+      } catch (l) {
+        console.warn("Failed to clear persisted state:", l);
+      }
+  }, G = (l) => {
+    Object.assign(a, l);
+  }, Y = (l) => {
+    const u = { ...t, ...l };
+    JSON.stringify(u) !== JSON.stringify(t) && (t = u, s = { ...u }, L(), p());
+  }, I = (l) => {
+    const u = `${l.type}-${Date.now()}-${Math.random()}`;
+    c.set(u, { ...l, timestamp: Date.now() });
+    const y = h(s, l);
+    return s = { ...s, ...y }, p(), u;
+  }, C = (l) => {
+    if (c.has(l)) {
+      c.delete(l), s = { ...t };
+      for (const [, u] of c) {
+        const y = h(s, u);
+        s = { ...s, ...y };
+      }
+      p();
+    }
+  }, h = (l, u) => {
+    switch (u.type) {
+      case o.PLAY:
+        return { isPlaying: !0, error: null };
+      case o.PAUSE:
+        return { isPlaying: !1 };
+      case o.SEEK:
+        return { currentTime: u.detail };
+      case o.SET_VOLUME:
+        return { volume: Math.max(0, Math.min(1, u.detail)) };
+      case o.MUTE:
+        return { isMuted: !0 };
+      case o.UNMUTE:
+        return { isMuted: !1 };
+      case o.TOGGLE_MUTE:
+        return { isMuted: !l.isMuted };
+      case o.SET_DURATION:
+        return { duration: u.detail };
+      case o.SET_CURRENT_TIME:
+        return { currentTime: u.detail };
+      case o.SET_BUFFERED:
+        return { buffered: u.detail };
+      case o.SET_LOADING:
+        return { isLoading: u.detail };
+      case o.SET_ERROR:
+        return { error: u.detail, isLoading: !1 };
+      case o.ENTER_FULLSCREEN:
+        return { isFullscreen: !0 };
+      case o.EXIT_FULLSCREEN:
+        return { isFullscreen: !1 };
+      case o.ENTER_PIP:
+        return { isPictureInPicture: !0 };
+      case o.EXIT_PIP:
+        return { isPictureInPicture: !1 };
+      case o.SET_PLAYBACK_RATE:
+        return { playbackRate: u.detail };
+      case o.SET_SUBTITLE_TRACK:
+        return { selectedSubtitleTrack: u.detail };
+      case o.SET_RENDITION:
+        return { selectedRendition: u.detail };
+      case o.TOGGLE_SUBTITLES:
+        return { subtitlesShowing: !l.subtitlesShowing };
+      case o.PREVIEW_TIME:
+        return { previewTime: u.detail };
+      case o.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);
+    Y(u);
+  }, w = async (l) => {
+    n = {
+      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), n = {
+        pending: !1,
+        error: null,
+        lastAction: l,
+        retryCount: 0
+      }, s = { ...t };
+      for (const [, O] of c) {
+        const N = h(s, O);
+        s = { ...s, ...N };
+      }
+    } catch (y) {
+      C(u), n = {
+        pending: !1,
+        error: y instanceof Error ? y.message : "Unknown error occurred",
+        lastAction: l,
+        retryCount: (l.retryCount || 0) + 1
+      }, n.retryCount < 3 && J(l.type) && setTimeout(() => {
+        w({
+          ...l,
+          retryCount: n.retryCount
+        });
+      }, Math.pow(2, n.retryCount) * 1e3);
+    }
+    p();
+  }, J = (l) => [
+    o.PLAY,
+    o.PAUSE,
+    o.SEEK,
+    o.SET_VOLUME,
+    o.MUTE,
+    o.UNMUTE,
+    o.TOGGLE_MUTE
+  ].includes(l);
+  return U(), {
+    subscribe: g,
+    getState: F,
+    setState: Y,
+    dispatch: B,
+    getOptimisticState: _,
+    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 Re {
+  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 (s) {
+        console.warn("Failed to write to localStorage:", s);
+      }
+  }
+  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 me = {
+  userPreferences: !0,
+  sessionState: !0,
+  playbackHistory: !0,
+  maxHistoryItems: 50,
+  maxCacheAge: 10080 * 60 * 1e3,
+  // 7 days
+  debounceMs: 1e3,
+  storage: new Re()
+};
+class pe {
+  constructor(e = {}) {
+    M(this, "config");
+    M(this, "storage");
+    M(this, "debounceTimeouts", /* @__PURE__ */ new Map());
+    this.config = { ...me, ...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 s = { ...await this.getUserPreferences() || {}, ...e };
+        await this.storage.setItem(b.USER_PREFERENCES, JSON.stringify({
+          preferences: s,
+          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 s = { ...await this.getSessionState() || {
+          currentTime: 0,
+          playbackPosition: {}
+        }, ...e };
+        await this.storage.setItem(b.SESSION_STATE, JSON.stringify({
+          state: s,
+          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(), s = {
+          ...e,
+          timestamp: Date.now()
+        }, n = t.filter((d) => d.mediaId !== e.mediaId), a = [s, ...n].slice(0, this.config.maxHistoryItems);
+        await this.storage.setItem(b.PLAYBACK_HISTORY, JSON.stringify({
+          history: a,
+          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 n = (await this.getSessionState())?.playbackPosition || {};
+    await this.saveSessionState({
+      playbackPosition: {
+        ...n,
+        [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 s = this.debounceTimeouts.get(e);
+    s && clearTimeout(s);
+    const n = setTimeout(async () => {
+      await t(), this.debounceTimeouts.delete(e);
+    }, this.config.debounceMs);
+    this.debounceTimeouts.set(e, n);
+  }
+}
+function _e(i) {
+  const [e] = S.useState(() => new pe(i));
+  return S.useEffect(() => () => {
+    e.clearAll();
+  }, [e]), e;
+}
+function ge(i, e, t) {
+  const s = _e(t), [n, a] = S.useState(!1);
+  return S.useEffect(() => {
+    let d = !0;
+    return (async () => {
+      try {
+        const [T, g] = await Promise.all([
+          s.getUserPreferences(),
+          s.getSessionState()
+        ]);
+        if (!d) return;
+        const p = {
+          ...T && {
+            volume: T.volume,
+            isMuted: T.isMuted,
+            playbackRate: T.playbackRate,
+            subtitlesShowing: T.subtitlesShowing
+          },
+          ...g && e === g.mediaId && {
+            currentTime: g.currentTime
+          }
+        };
+        Object.keys(p).length > 0 && console.log("Rehydrated state:", p), a(!0);
+      } catch (T) {
+        console.warn("Failed to rehydrate state:", T), a(!0);
+      }
+    })(), () => {
+      d = !1;
+    };
+  }, [s, e]), S.useEffect(() => {
+    if (!n) return;
+    const d = s.extractUserPreferences(i);
+    if (s.saveUserPreferences(d), e) {
+      const c = s.extractSessionState(i, e);
+      s.saveSessionState(c), i.currentTime > 0 && i.duration > 0 && s.savePlaybackPosition(e, i.currentTime);
+    }
+  }, [s, i, e, n]), {
+    manager: s,
+    isRehydrated: n
+  };
+}
+const he = {
+  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 be {
+  canRecover(e) {
+    return e.type === "NETWORK_ERROR" && e.retryCount < 3;
+  }
+  async recover(e) {
+    navigator.onLine === !1 && await new Promise((t) => {
+      const s = () => {
+        window.removeEventListener("online", s), t(void 0);
+      };
+      window.addEventListener("online", s);
+    }), await new Promise((t) => setTimeout(t, 2e3));
+  }
+}
+class we {
+  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((s) => {
+      const n = () => {
+        t.removeEventListener("canplay", n), s(void 0);
+      };
+      t.addEventListener("canplay", n);
+    }));
+  }
+}
+class Pe {
+  canRecover(e) {
+    return e.type === "PERMISSION_ERROR" && e.action?.type === "ENTER_FULLSCREEN";
+  }
+  async recover(e) {
+    console.warn("Fullscreen requires user interaction");
+  }
+}
+class Oe {
+  constructor(e = {}, t = []) {
+    M(this, "config");
+    M(this, "recoveryStrategies");
+    M(this, "errorQueue", /* @__PURE__ */ new Map());
+    M(this, "listeners", /* @__PURE__ */ new Set());
+    this.config = { ...he, ...e }, this.recoveryStrategies = [
+      new be(),
+      new we(),
+      new Pe(),
+      ...t
+    ];
+  }
+  // Create a media error from a generic error
+  createMediaError(e, t, s = 0) {
+    const n = Date.now();
+    if (e instanceof Error) {
+      const a = this.categorizeError(e, t);
+      return {
+        type: a,
+        message: e.message,
+        action: t,
+        timestamp: n,
+        retryable: this.isRetryable(a, t),
+        retryCount: s,
+        originalError: e
+      };
+    }
+    return {
+      type: "UNKNOWN_ERROR",
+      message: typeof e == "string" ? e : "Unknown error occurred",
+      action: t,
+      timestamp: n,
+      retryable: this.isRetryable("UNKNOWN_ERROR", t),
+      retryCount: s
+    };
+  }
+  // Categorize errors based on error properties and action context
+  categorizeError(e, t) {
+    const s = e.message.toLowerCase();
+    return s.includes("network") || s.includes("fetch") || s.includes("connection") || e.name === "NetworkError" ? "NETWORK_ERROR" : s.includes("permission") || s.includes("denied") || s.includes("fullscreen") || e.name === "NotAllowedError" ? "PERMISSION_ERROR" : s.includes("decode") || s.includes("format") || s.includes("codec") || t?.type === "PLAY" ? "PLAYBACK_ERROR" : s.includes("timeout") || e.name === "TimeoutError" ? "TIMEOUT_ERROR" : s.includes("not supported") || s.includes("unsupported") || e.name === "NotSupportedError" ? "NOT_SUPPORTED_ERROR" : "UNKNOWN_ERROR";
+  }
+  // Check if an error/action combination is retryable
+  isRetryable(e, t) {
+    const s = this.config.retryableErrors.includes(e), n = !t || this.config.retryableActions.includes(t.type);
+    return s && n;
+  }
+  // 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, s) {
+    const n = this.createMediaError(e, t, t?.retryCount || 0), a = `${t?.type}-${n.timestamp}`;
+    this.errorQueue.set(a, n), this.listeners.forEach((d) => d(n));
+    for (const d of this.recoveryStrategies)
+      if (d.canRecover(n))
+        try {
+          await d.recover(n);
+          break;
+        } catch (c) {
+          console.warn("Recovery strategy failed:", c);
+        }
+    if (n.retryable && n.retryCount < this.config.maxRetries && s && t) {
+      const d = this.calculateRetryDelay(n.retryCount);
+      console.log(`Retrying action ${t.type} in ${d}ms (attempt ${n.retryCount + 1}/${this.config.maxRetries})`), setTimeout(async () => {
+        try {
+          await s({
+            ...t,
+            retryCount: n.retryCount + 1
+          }), this.errorQueue.delete(a);
+        } catch (c) {
+          await this.handleError(c, {
+            ...t,
+            retryCount: n.retryCount + 1
+          }, s);
+        }
+      }, d);
+    }
+    return n;
+  }
+  // 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(), s = 300 * 1e3, n = e.reduce((c, T) => (c[T.type] = (c[T.type] || 0) + 1, c), {}), a = e.filter((c) => c.retryable).length, d = e.filter((c) => t - c.timestamp < s);
+    return {
+      totalErrors: e.length,
+      errorsByType: n,
+      retryableErrors: a,
+      recentErrors: d
+    };
+  }
+}
+function Ae(i = Q) {
+  let e = { ...i };
+  const t = /* @__PURE__ */ new Set(), s = (c) => (t.add(c), () => t.delete(c)), n = () => e, a = (c) => {
+    const T = { ...e, ...c };
+    JSON.stringify(T) !== JSON.stringify(e) && (e = T, t.forEach((g) => g()));
+  };
+  return { subscribe: s, getState: n, setState: a, dispatch: (c) => {
+    switch (c.type) {
+      case o.PLAY:
+        a({ isPlaying: !0, error: null });
+        break;
+      case o.PAUSE:
+        a({ isPlaying: !1 });
+        break;
+      case o.SEEK:
+        a({ currentTime: c.detail });
+        break;
+      case o.SET_VOLUME:
+        a({ volume: Math.max(0, Math.min(1, c.detail)) });
+        break;
+      case o.MUTE:
+        a({ isMuted: !0 });
+        break;
+      case o.UNMUTE:
+        a({ isMuted: !1 });
+        break;
+      case o.TOGGLE_MUTE:
+        a({ isMuted: !e.isMuted });
+        break;
+      case o.SET_DURATION:
+        a({ duration: c.detail });
+        break;
+      case o.SET_CURRENT_TIME:
+        a({ currentTime: c.detail });
+        break;
+      case o.SET_BUFFERED:
+        a({ buffered: c.detail });
+        break;
+      case o.SET_LOADING:
+        a({ isLoading: c.detail });
+        break;
+      case o.SET_ERROR:
+        a({ error: c.detail, isLoading: !1 });
+        break;
+      case o.ENTER_FULLSCREEN:
+        a({ isFullscreen: !0 });
+        break;
+      case o.EXIT_FULLSCREEN:
+        a({ isFullscreen: !1 });
+        break;
+      case o.ENTER_PIP:
+        a({ isPictureInPicture: !0 });
+        break;
+      case o.EXIT_PIP:
+        a({ isPictureInPicture: !1 });
+        break;
+      case o.SET_PLAYBACK_RATE:
+        a({ playbackRate: c.detail });
+        break;
+      case o.SET_SUBTITLE_TRACK:
+        a({ selectedSubtitleTrack: c.detail });
+        break;
+      case o.SET_RENDITION:
+        a({ selectedRendition: c.detail });
+        break;
+      case o.TOGGLE_SUBTITLES:
+        a({ subtitlesShowing: !e.subtitlesShowing });
+        break;
+      case o.PREVIEW_TIME:
+        a({ previewTime: c.detail });
+        break;
+      case o.CLEAR_PREVIEW:
+        a({ previewTime: null, previewImage: null, previewCoords: null });
+        break;
+      default:
+        console.warn(`Unknown media action type: ${c.type}`);
+    }
+  } };
+}
+function Ue({
+  children: i,
+  mediaId: e = "media-player",
+  labelId: t = "media-player-label",
+  descriptionId: s = "media-player-description",
+  dir: n = "ltr",
+  portalContainer: a,
+  tooltipDelayDuration: d = 700,
+  tooltipSideOffset: c = 4,
+  disabled: T = !1,
+  isVideo: g = !0,
+  withoutTooltip: p = !1,
+  initialState: F = {},
+  // React 19 enhancements
+  useEnhancedStore: _ = !0,
+  persistenceConfig: A,
+  retryConfig: D,
+  enableOptimisticUpdates: L = !0,
+  enableErrorRecovery: U = !0,
+  onStateRehydrated: v
+}) {
+  const G = S.useRef(null), Y = S.useRef(null), I = S.useMemo(() => {
+    const w = { ...Q, ...F };
+    return _ ? ye(w, A) : Ae(w);
+  }, [_, A]), C = S.useMemo(() => U && _ ? new Oe(D) : null, [U, _, D]), h = _ ? ge(
+    I.getState(),
+    e,
+    A
+  ) : null;
+  S.useEffect(() => {
+    if (h?.isRehydrated && v) {
+      const w = I.getState();
+      v(w);
+    }
+  }, [h?.isRehydrated, v, I]);
+  const B = S.useMemo(
+    () => ({
+      mediaId: e,
+      labelId: t,
+      descriptionId: s,
+      dir: n,
+      rootRef: G,
+      mediaRef: Y,
+      portalContainer: a,
+      tooltipDelayDuration: d,
+      tooltipSideOffset: c,
+      disabled: T,
+      isVideo: g,
+      withoutTooltip: p,
+      // React 19 enhancements
+      errorHandler: C,
+      isEnhanced: _,
+      isRehydrated: h?.isRehydrated
+    }),
+    [
+      e,
+      t,
+      s,
+      n,
+      a,
+      d,
+      c,
+      T,
+      g,
+      p,
+      C,
+      _,
+      h?.isRehydrated
+    ]
+  );
+  return /* @__PURE__ */ ae.jsx(oe.Provider, { value: B, children: /* @__PURE__ */ ae.jsx(ie.Provider, { value: I, children: i }) });
+}
+export {
+  o as M,
+  ke as a,
+  Ne as b,
+  V as c,
+  Ue as d,
+  Me as e,
+  ye as f,
+  oe as g,
+  ie as h,
+  Le as i,
+  ae as j,
+  Q as k,
+  Te as u
+};
+//# sourceMappingURL=context-BMteAJDN.js.map