@aigamo/nostalgic-diva 1.19.2 → 1.19.3

package/dist/index-D5CazY1_.js

@@ -0,0 +1,1848 @@
+import Je, { createContext as Mt, useContext as At, useRef as L, useCallback as T, useMemo as Ot, lazy as U, memo as Ke, Suspense as jt, useState as je, useEffect as ue } from "react";
+import Ut from "react-dom";
+var Z = { exports: {} }, H = {};
+var Ue;
+function Ft() {
+  if (Ue) return H;
+  Ue = 1;
+  var n = Je, e = /* @__PURE__ */ Symbol.for("react.element"), r = /* @__PURE__ */ Symbol.for("react.fragment"), o = Object.prototype.hasOwnProperty, c = n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, m = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function R(w, f, C) {
+    var b, P = {}, k = null, I = null;
+    C !== void 0 && (k = "" + C), f.key !== void 0 && (k = "" + f.key), f.ref !== void 0 && (I = f.ref);
+    for (b in f) o.call(f, b) && !m.hasOwnProperty(b) && (P[b] = f[b]);
+    if (w && w.defaultProps) for (b in f = w.defaultProps, f) P[b] === void 0 && (P[b] = f[b]);
+    return { $$typeof: e, type: w, key: k, ref: I, props: P, _owner: c.current };
+  }
+  return H.Fragment = r, H.jsx = R, H.jsxs = R, H;
+}
+var q = {};
+var Fe;
+function Yt() {
+  return Fe || (Fe = 1, process.env.NODE_ENV !== "production" && (function() {
+    var n = Je, e = /* @__PURE__ */ Symbol.for("react.element"), r = /* @__PURE__ */ Symbol.for("react.portal"), o = /* @__PURE__ */ Symbol.for("react.fragment"), c = /* @__PURE__ */ Symbol.for("react.strict_mode"), m = /* @__PURE__ */ Symbol.for("react.profiler"), R = /* @__PURE__ */ Symbol.for("react.provider"), w = /* @__PURE__ */ Symbol.for("react.context"), f = /* @__PURE__ */ Symbol.for("react.forward_ref"), C = /* @__PURE__ */ Symbol.for("react.suspense"), b = /* @__PURE__ */ Symbol.for("react.suspense_list"), P = /* @__PURE__ */ Symbol.for("react.memo"), k = /* @__PURE__ */ Symbol.for("react.lazy"), I = /* @__PURE__ */ Symbol.for("react.offscreen"), M = Symbol.iterator, x = "@@iterator";
+    function A(t) {
+      if (t === null || typeof t != "object")
+        return null;
+      var a = M && t[M] || t[x];
+      return typeof a == "function" ? a : null;
+    }
+    var E = n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function d(t) {
+      {
+        for (var a = arguments.length, i = new Array(a > 1 ? a - 1 : 0), s = 1; s < a; s++)
+          i[s - 1] = arguments[s];
+        Qe("error", t, i);
+      }
+    }
+    function Qe(t, a, i) {
+      {
+        var s = E.ReactDebugCurrentFrame, h = s.getStackAddendum();
+        h !== "" && (a += "%s", i = i.concat([h]));
+        var y = i.map(function(l) {
+          return String(l);
+        });
+        y.unshift("Warning: " + a), Function.prototype.apply.call(console[t], console, y);
+      }
+    }
+    var et = !1, tt = !1, rt = !1, at = !1, nt = !1, he;
+    he = /* @__PURE__ */ Symbol.for("react.module.reference");
+    function it(t) {
+      return !!(typeof t == "string" || typeof t == "function" || t === o || t === m || nt || t === c || t === C || t === b || at || t === I || et || tt || rt || typeof t == "object" && t !== null && (t.$$typeof === k || t.$$typeof === P || t.$$typeof === R || t.$$typeof === w || t.$$typeof === f || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      t.$$typeof === he || t.getModuleId !== void 0));
+    }
+    function st(t, a, i) {
+      var s = t.displayName;
+      if (s)
+        return s;
+      var h = a.displayName || a.name || "";
+      return h !== "" ? i + "(" + h + ")" : i;
+    }
+    function pe(t) {
+      return t.displayName || "Context";
+    }
+    function N(t) {
+      if (t == null)
+        return null;
+      if (typeof t.tag == "number" && d("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof t == "function")
+        return t.displayName || t.name || null;
+      if (typeof t == "string")
+        return t;
+      switch (t) {
+        case o:
+          return "Fragment";
+        case r:
+          return "Portal";
+        case m:
+          return "Profiler";
+        case c:
+          return "StrictMode";
+        case C:
+          return "Suspense";
+        case b:
+          return "SuspenseList";
+      }
+      if (typeof t == "object")
+        switch (t.$$typeof) {
+          case w:
+            var a = t;
+            return pe(a) + ".Consumer";
+          case R:
+            var i = t;
+            return pe(i._context) + ".Provider";
+          case f:
+            return st(t, t.render, "ForwardRef");
+          case P:
+            var s = t.displayName || null;
+            return s !== null ? s : N(t.type) || "Memo";
+          case k: {
+            var h = t, y = h._payload, l = h._init;
+            try {
+              return N(l(y));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var O = Object.assign, G = 0, ye, fe, me, ve, ge, be, Ee;
+    function we() {
+    }
+    we.__reactDisabledLog = !0;
+    function ot() {
+      {
+        if (G === 0) {
+          ye = console.log, fe = console.info, me = console.warn, ve = console.error, ge = console.group, be = console.groupCollapsed, Ee = console.groupEnd;
+          var t = {
+            configurable: !0,
+            enumerable: !0,
+            value: we,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: t,
+            log: t,
+            warn: t,
+            error: t,
+            group: t,
+            groupCollapsed: t,
+            groupEnd: t
+          });
+        }
+        G++;
+      }
+    }
+    function ut() {
+      {
+        if (G--, G === 0) {
+          var t = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: O({}, t, {
+              value: ye
+            }),
+            info: O({}, t, {
+              value: fe
+            }),
+            warn: O({}, t, {
+              value: me
+            }),
+            error: O({}, t, {
+              value: ve
+            }),
+            group: O({}, t, {
+              value: ge
+            }),
+            groupCollapsed: O({}, t, {
+              value: be
+            }),
+            groupEnd: O({}, t, {
+              value: Ee
+            })
+          });
+        }
+        G < 0 && d("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ee = E.ReactCurrentDispatcher, te;
+    function J(t, a, i) {
+      {
+        if (te === void 0)
+          try {
+            throw Error();
+          } catch (h) {
+            var s = h.stack.trim().match(/\n( *(at )?)/);
+            te = s && s[1] || "";
+          }
+        return `
+` + te + t;
+      }
+    }
+    var re = !1, K;
+    {
+      var lt = typeof WeakMap == "function" ? WeakMap : Map;
+      K = new lt();
+    }
+    function Ce(t, a) {
+      if (!t || re)
+        return "";
+      {
+        var i = K.get(t);
+        if (i !== void 0)
+          return i;
+      }
+      var s;
+      re = !0;
+      var h = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var y;
+      y = ee.current, ee.current = null, ot();
+      try {
+        if (a) {
+          var l = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(l.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(l, []);
+            } catch (_) {
+              s = _;
+            }
+            Reflect.construct(t, [], l);
+          } else {
+            try {
+              l.call();
+            } catch (_) {
+              s = _;
+            }
+            t.call(l.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (_) {
+            s = _;
+          }
+          t();
+        }
+      } catch (_) {
+        if (_ && s && typeof _.stack == "string") {
+          for (var u = _.stack.split(`
+`), D = s.stack.split(`
+`), v = u.length - 1, g = D.length - 1; v >= 1 && g >= 0 && u[v] !== D[g]; )
+            g--;
+          for (; v >= 1 && g >= 0; v--, g--)
+            if (u[v] !== D[g]) {
+              if (v !== 1 || g !== 1)
+                do
+                  if (v--, g--, g < 0 || u[v] !== D[g]) {
+                    var S = `
+` + u[v].replace(" at new ", " at ");
+                    return t.displayName && S.includes("<anonymous>") && (S = S.replace("<anonymous>", t.displayName)), typeof t == "function" && K.set(t, S), S;
+                  }
+                while (v >= 1 && g >= 0);
+              break;
+            }
+        }
+      } finally {
+        re = !1, ee.current = y, ut(), Error.prepareStackTrace = h;
+      }
+      var W = t ? t.displayName || t.name : "", j = W ? J(W) : "";
+      return typeof t == "function" && K.set(t, j), j;
+    }
+    function ct(t, a, i) {
+      return Ce(t, !1);
+    }
+    function dt(t) {
+      var a = t.prototype;
+      return !!(a && a.isReactComponent);
+    }
+    function z(t, a, i) {
+      if (t == null)
+        return "";
+      if (typeof t == "function")
+        return Ce(t, dt(t));
+      if (typeof t == "string")
+        return J(t);
+      switch (t) {
+        case C:
+          return J("Suspense");
+        case b:
+          return J("SuspenseList");
+      }
+      if (typeof t == "object")
+        switch (t.$$typeof) {
+          case f:
+            return ct(t.render);
+          case P:
+            return z(t.type, a, i);
+          case k: {
+            var s = t, h = s._payload, y = s._init;
+            try {
+              return z(y(h), a, i);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var B = Object.prototype.hasOwnProperty, Pe = {}, Te = E.ReactDebugCurrentFrame;
+    function X(t) {
+      if (t) {
+        var a = t._owner, i = z(t.type, t._source, a ? a.type : null);
+        Te.setExtraStackFrame(i);
+      } else
+        Te.setExtraStackFrame(null);
+    }
+    function ht(t, a, i, s, h) {
+      {
+        var y = Function.call.bind(B);
+        for (var l in t)
+          if (y(t, l)) {
+            var u = void 0;
+            try {
+              if (typeof t[l] != "function") {
+                var D = Error((s || "React class") + ": " + i + " type `" + l + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof t[l] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw D.name = "Invariant Violation", D;
+              }
+              u = t[l](a, l, s, i, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (v) {
+              u = v;
+            }
+            u && !(u instanceof Error) && (X(h), d("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", s || "React class", i, l, typeof u), X(null)), u instanceof Error && !(u.message in Pe) && (Pe[u.message] = !0, X(h), d("Failed %s type: %s", i, u.message), X(null));
+          }
+      }
+    }
+    var pt = Array.isArray;
+    function ae(t) {
+      return pt(t);
+    }
+    function yt(t) {
+      {
+        var a = typeof Symbol == "function" && Symbol.toStringTag, i = a && t[Symbol.toStringTag] || t.constructor.name || "Object";
+        return i;
+      }
+    }
+    function ft(t) {
+      try {
+        return Re(t), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Re(t) {
+      return "" + t;
+    }
+    function De(t) {
+      if (ft(t))
+        return d("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", yt(t)), Re(t);
+    }
+    var _e = E.ReactCurrentOwner, mt = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, ke, Se;
+    function vt(t) {
+      if (B.call(t, "ref")) {
+        var a = Object.getOwnPropertyDescriptor(t, "ref").get;
+        if (a && a.isReactWarning)
+          return !1;
+      }
+      return t.ref !== void 0;
+    }
+    function gt(t) {
+      if (B.call(t, "key")) {
+        var a = Object.getOwnPropertyDescriptor(t, "key").get;
+        if (a && a.isReactWarning)
+          return !1;
+      }
+      return t.key !== void 0;
+    }
+    function bt(t, a) {
+      typeof t.ref == "string" && _e.current;
+    }
+    function Et(t, a) {
+      {
+        var i = function() {
+          ke || (ke = !0, d("%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://reactjs.org/link/special-props)", a));
+        };
+        i.isReactWarning = !0, Object.defineProperty(t, "key", {
+          get: i,
+          configurable: !0
+        });
+      }
+    }
+    function wt(t, a) {
+      {
+        var i = function() {
+          Se || (Se = !0, d("%s: `ref` 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://reactjs.org/link/special-props)", a));
+        };
+        i.isReactWarning = !0, Object.defineProperty(t, "ref", {
+          get: i,
+          configurable: !0
+        });
+      }
+    }
+    var Ct = function(t, a, i, s, h, y, l) {
+      var u = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: e,
+        // Built-in properties that belong on the element
+        type: t,
+        key: a,
+        ref: i,
+        props: l,
+        // Record the component responsible for creating this element.
+        _owner: y
+      };
+      return u._store = {}, Object.defineProperty(u._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(u, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: s
+      }), Object.defineProperty(u, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: h
+      }), Object.freeze && (Object.freeze(u.props), Object.freeze(u)), u;
+    };
+    function Pt(t, a, i, s, h) {
+      {
+        var y, l = {}, u = null, D = null;
+        i !== void 0 && (De(i), u = "" + i), gt(a) && (De(a.key), u = "" + a.key), vt(a) && (D = a.ref, bt(a, h));
+        for (y in a)
+          B.call(a, y) && !mt.hasOwnProperty(y) && (l[y] = a[y]);
+        if (t && t.defaultProps) {
+          var v = t.defaultProps;
+          for (y in v)
+            l[y] === void 0 && (l[y] = v[y]);
+        }
+        if (u || D) {
+          var g = typeof t == "function" ? t.displayName || t.name || "Unknown" : t;
+          u && Et(l, g), D && wt(l, g);
+        }
+        return Ct(t, u, D, h, s, _e.current, l);
+      }
+    }
+    var ne = E.ReactCurrentOwner, Ve = E.ReactDebugCurrentFrame;
+    function $(t) {
+      if (t) {
+        var a = t._owner, i = z(t.type, t._source, a ? a.type : null);
+        Ve.setExtraStackFrame(i);
+      } else
+        Ve.setExtraStackFrame(null);
+    }
+    var ie;
+    ie = !1;
+    function se(t) {
+      return typeof t == "object" && t !== null && t.$$typeof === e;
+    }
+    function Ie() {
+      {
+        if (ne.current) {
+          var t = N(ne.current.type);
+          if (t)
+            return `
+
+Check the render method of \`` + t + "`.";
+        }
+        return "";
+      }
+    }
+    function Tt(t) {
+      return "";
+    }
+    var xe = {};
+    function Rt(t) {
+      {
+        var a = Ie();
+        if (!a) {
+          var i = typeof t == "string" ? t : t.displayName || t.name;
+          i && (a = `
+
+Check the top-level render call using <` + i + ">.");
+        }
+        return a;
+      }
+    }
+    function Ne(t, a) {
+      {
+        if (!t._store || t._store.validated || t.key != null)
+          return;
+        t._store.validated = !0;
+        var i = Rt(a);
+        if (xe[i])
+          return;
+        xe[i] = !0;
+        var s = "";
+        t && t._owner && t._owner !== ne.current && (s = " It was passed a child from " + N(t._owner.type) + "."), $(t), d('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', i, s), $(null);
+      }
+    }
+    function Me(t, a) {
+      {
+        if (typeof t != "object")
+          return;
+        if (ae(t))
+          for (var i = 0; i < t.length; i++) {
+            var s = t[i];
+            se(s) && Ne(s, a);
+          }
+        else if (se(t))
+          t._store && (t._store.validated = !0);
+        else if (t) {
+          var h = A(t);
+          if (typeof h == "function" && h !== t.entries)
+            for (var y = h.call(t), l; !(l = y.next()).done; )
+              se(l.value) && Ne(l.value, a);
+        }
+      }
+    }
+    function Dt(t) {
+      {
+        var a = t.type;
+        if (a == null || typeof a == "string")
+          return;
+        var i;
+        if (typeof a == "function")
+          i = a.propTypes;
+        else if (typeof a == "object" && (a.$$typeof === f || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        a.$$typeof === P))
+          i = a.propTypes;
+        else
+          return;
+        if (i) {
+          var s = N(a);
+          ht(i, t.props, "prop", s, t);
+        } else if (a.PropTypes !== void 0 && !ie) {
+          ie = !0;
+          var h = N(a);
+          d("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", h || "Unknown");
+        }
+        typeof a.getDefaultProps == "function" && !a.getDefaultProps.isReactClassApproved && d("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function _t(t) {
+      {
+        for (var a = Object.keys(t.props), i = 0; i < a.length; i++) {
+          var s = a[i];
+          if (s !== "children" && s !== "key") {
+            $(t), d("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", s), $(null);
+            break;
+          }
+        }
+        t.ref !== null && ($(t), d("Invalid attribute `ref` supplied to `React.Fragment`."), $(null));
+      }
+    }
+    var Ae = {};
+    function Oe(t, a, i, s, h, y) {
+      {
+        var l = it(t);
+        if (!l) {
+          var u = "";
+          (t === void 0 || typeof t == "object" && t !== null && Object.keys(t).length === 0) && (u += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var D = Tt();
+          D ? u += D : u += Ie();
+          var v;
+          t === null ? v = "null" : ae(t) ? v = "array" : t !== void 0 && t.$$typeof === e ? (v = "<" + (N(t.type) || "Unknown") + " />", u = " Did you accidentally export a JSX literal instead of a component?") : v = typeof t, d("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", v, u);
+        }
+        var g = Pt(t, a, i, h, y);
+        if (g == null)
+          return g;
+        if (l) {
+          var S = a.children;
+          if (S !== void 0)
+            if (s)
+              if (ae(S)) {
+                for (var W = 0; W < S.length; W++)
+                  Me(S[W], t);
+                Object.freeze && Object.freeze(S);
+              } else
+                d("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
+              Me(S, t);
+        }
+        if (B.call(a, "key")) {
+          var j = N(t), _ = Object.keys(a).filter(function(Nt) {
+            return Nt !== "key";
+          }), oe = _.length > 0 ? "{key: someKey, " + _.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Ae[j + oe]) {
+            var xt = _.length > 0 ? "{" + _.join(": ..., ") + ": ...}" : "{}";
+            d(`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} />`, oe, j, xt, j), Ae[j + oe] = !0;
+          }
+        }
+        return t === o ? _t(g) : Dt(g), g;
+      }
+    }
+    function kt(t, a, i) {
+      return Oe(t, a, i, !0);
+    }
+    function St(t, a, i) {
+      return Oe(t, a, i, !1);
+    }
+    var Vt = St, It = kt;
+    q.Fragment = o, q.jsx = Vt, q.jsxs = It;
+  })()), q;
+}
+var Ye;
+function $t() {
+  return Ye || (Ye = 1, process.env.NODE_ENV === "production" ? Z.exports = Ft() : Z.exports = Yt()), Z.exports;
+}
+var V = $t(), p = /* @__PURE__ */ ((n) => (n[n.Trace = 0] = "Trace", n[n.Debug = 1] = "Debug", n[n.Information = 2] = "Information", n[n.Warning = 3] = "Warning", n[n.Error = 4] = "Error", n[n.Critical = 5] = "Critical", n[n.None = 6] = "None", n))(p || {});
+class Wt {
+  title = "nostalgic-diva";
+  createMessage(e) {
+    return `[${this.title}] ${e}`;
+  }
+  debug(e, ...r) {
+    console.debug(this.createMessage(e), ...r);
+  }
+  error(e, ...r) {
+    console.error(this.createMessage(e), ...r);
+  }
+  warn(e, ...r) {
+    console.warn(this.createMessage(e), ...r);
+  }
+  isEnabled() {
+    return !0;
+  }
+  log(e, r, ...o) {
+    switch (e) {
+      case 1:
+        this.debug(r, ...o);
+        break;
+      case 3:
+        this.warn(r, ...o);
+        break;
+      case 4:
+        this.error(r, ...o);
+        break;
+    }
+  }
+}
+const Lt = new Wt();
+class Gt {
+  async attach() {
+  }
+  async detach() {
+  }
+  async loadVideo(e) {
+  }
+  async play() {
+  }
+  async pause() {
+  }
+  async setCurrentTime(e) {
+  }
+  async setVolume(e) {
+  }
+  async setMuted(e) {
+  }
+  async setPlaybackRate(e) {
+  }
+  async getDuration() {
+    return 0;
+  }
+  async getCurrentTime() {
+    return 0;
+  }
+  async getVolume() {
+    return 0;
+  }
+  async getMuted() {
+    return !1;
+  }
+  async getPlaybackRate() {
+    return 0;
+  }
+  supports(e) {
+    return !1;
+  }
+}
+const Q = new Gt(), ze = Mt(
+  void 0
+), Bt = ({
+  children: n,
+  logger: e = Lt
+}) => {
+  const r = L(Q), o = T(
+    (d) => {
+      e.log(
+        p.Debug,
+        "NostalgicDivaProvider.handleControllerChange",
+        r.current,
+        d
+      ), r.current = d;
+    },
+    [e]
+  ), c = T(
+    async (d) => {
+      e.log(
+        p.Debug,
+        "NostalgicDivaProvider.loadVideo",
+        r.current
+      ), await r.current.loadVideo(d);
+    },
+    [e]
+  ), m = T(async () => {
+    e.log(
+      p.Debug,
+      "NostalgicDivaProvider.play",
+      r.current
+    ), await r.current.play();
+  }, [e]), R = T(async () => {
+    e.log(
+      p.Debug,
+      "NostalgicDivaProvider.pause",
+      r.current
+    ), await r.current.pause();
+  }, [e]), w = T(
+    async (d) => {
+      e.log(
+        p.Debug,
+        "NostalgicDivaProvider.setCurrentTime",
+        r.current
+      ), await r.current.setCurrentTime(d), await r.current.play();
+    },
+    [e]
+  ), f = T(
+    async (d) => {
+      e.log(
+        p.Debug,
+        "NostalgicDivaProvider.setVolume",
+        r.current
+      ), await r.current.setVolume(d);
+    },
+    [e]
+  ), C = T(
+    async (d) => {
+      e.log(
+        p.Debug,
+        "NostalgicDivaProvider.setMuted",
+        r.current
+      ), await r.current.setMuted(d);
+    },
+    [e]
+  ), b = T(
+    async (d) => {
+      e.log(
+        p.Debug,
+        "NostalgicDivaProvider.setPlaybackRate",
+        r.current
+      ), await r.current.setPlaybackRate(d);
+    },
+    [e]
+  ), P = T(async () => (e.log(
+    p.Debug,
+    "NostalgicDivaProvider.getDuration",
+    r.current
+  ), await r.current.getDuration()), [e]), k = T(async () => (e.log(
+    p.Debug,
+    "NostalgicDivaProvider.getCurrentTime",
+    r.current
+  ), await r.current.getCurrentTime()), [e]), I = T(async () => (e.log(
+    p.Debug,
+    "NostalgicDivaProvider.getVolume",
+    r.current
+  ), await r.current.getVolume()), [e]), M = T(async () => (e.log(
+    p.Debug,
+    "NostalgicDivaProvider.getMuted",
+    r.current
+  ), await r.current.getMuted()), [e]), x = T(async () => (e.log(
+    p.Debug,
+    "NostalgicDivaProvider.getPlaybackRate",
+    r.current
+  ), await r.current.getPlaybackRate()), [e]), A = T(
+    (d) => r.current.supports(d),
+    []
+  ), E = Ot(
+    () => ({
+      logger: e,
+      handleControllerChange: o,
+      loadVideo: c,
+      play: m,
+      pause: R,
+      setCurrentTime: w,
+      setVolume: f,
+      setMuted: C,
+      setPlaybackRate: b,
+      getDuration: P,
+      getCurrentTime: k,
+      getVolume: I,
+      getMuted: M,
+      getPlaybackRate: x,
+      supports: A
+    }),
+    [
+      e,
+      o,
+      c,
+      m,
+      R,
+      w,
+      f,
+      C,
+      b,
+      P,
+      k,
+      I,
+      M,
+      x,
+      A
+    ]
+  );
+  return /* @__PURE__ */ V.jsx(ze.Provider, { value: E, children: n });
+}, Ht = () => At(ze);
+class F {
+  constructor(e) {
+    this.type = e;
+  }
+}
+const qt = /\.(m4a|m4b|mp4a|mpga|mp2|mp2a|mp3|m2a|m3a|wav|weba|aac|oga|spx)($|\?)/i, Jt = /\.(mp4|og[gv]|webm|mov|m4v)(#t=[,\d+]+)?($|\?)/i;
+class Kt extends F {
+  constructor() {
+    super("Audio");
+  }
+  canPlay(e) {
+    return qt.test(e) || Jt.test(e);
+  }
+  extractVideoId(e) {
+    return e;
+  }
+}
+const $e = /^(?:(?:https?):)?(?:\/\/)?(?:www\.)?(?:(?:dailymotion\.com(?:\/embed)?\/video)|dai\.ly)\/([a-zA-Z0-9]+)(?:_[\w_-]+)?(?:[\w.#_-]+)?/;
+class zt extends F {
+  constructor() {
+    super("Dailymotion");
+  }
+  canPlay(e) {
+    return $e.test(e);
+  }
+  extractVideoId(e) {
+    return $e.exec(e)?.[1];
+  }
+}
+const We = /(?:www\.|)?nicovideo\.jp\/watch\/(\w+)$/;
+class Xt extends F {
+  constructor() {
+    super("Niconico");
+  }
+  canPlay(e) {
+    return We.test(e);
+  }
+  extractVideoId(e) {
+    return We.exec(e)?.[1];
+  }
+}
+const Zt = /(?:soundcloud\.com|snd\.sc)\/[^.]+$/;
+class Qt extends F {
+  constructor() {
+    super("SoundCloud");
+  }
+  canPlay(e) {
+    return Zt.test(e);
+  }
+  extractVideoId(e) {
+    return e;
+  }
+}
+const Le = /(?:www\.|go\.)?twitch\.tv\/videos\/(\d+)($|\?)/;
+class er extends F {
+  constructor() {
+    super("Twitch");
+  }
+  canPlay(e) {
+    return Le.test(e);
+  }
+  extractVideoId(e) {
+    return Le.exec(e)?.[1];
+  }
+}
+const Ge = /vimeo\.com\/(\d+)$/;
+class tr extends F {
+  constructor() {
+    super("Vimeo");
+  }
+  canPlay(e) {
+    return Ge.test(e);
+  }
+  extractVideoId(e) {
+    return Ge.exec(e)?.[1];
+  }
+}
+const Be = /(?:youtu\.be\/|youtube(?:-nocookie|education)?\.com\/(?:embed\/|v\/|watch\/|watch\?v=|watch\?.+&v=|shorts\/|live\/))((\w|-){11})|youtube\.com\/playlist\?list=|youtube\.com\/user\//;
+class rr extends F {
+  constructor() {
+    super("YouTube");
+  }
+  canPlay(e) {
+    return Be.test(e);
+  }
+  extractVideoId(e) {
+    return Be.exec(e)?.[1];
+  }
+}
+const ar = [
+  new rr(),
+  new er(),
+  new tr(),
+  new zt(),
+  new Qt(),
+  new Kt(),
+  new Xt()
+];
+function nr(n) {
+  return ar.find((e) => e.canPlay(n));
+}
+const ir = new Map(
+  Object.entries({
+    Audio: U(() => import("./AudioPlayer-D3YsODf_.js")),
+    Dailymotion: U(() => import("./DailymotionPlayer-BbM7QPqY.js")),
+    Niconico: U(() => import("./NiconicoPlayer-BQO6a8Vb.js")),
+    SoundCloud: U(() => import("./SoundCloudPlayer-B8jkHu8t.js")),
+    Twitch: U(() => import("./TwitchPlayer-C9mAN-zs.js")),
+    Vimeo: U(() => import("./VimeoPlayer-Dj_TPJOD.js")),
+    YouTube: U(() => import("./YouTubePlayer-DnM2aTnC.js"))
+  })
+);
+function sr(n) {
+  const e = nr(n);
+  if (e === void 0)
+    return;
+  const { type: r, extractVideoId: o } = e, c = o(n);
+  if (c !== void 0)
+    return { type: r, videoId: c };
+}
+const He = Ke(() => /* @__PURE__ */ V.jsx("div", { style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ V.jsx(
+  "iframe",
+  {
+    src: "about:blank",
+    title: "about:blank",
+    style: {
+      width: "100%",
+      height: "100%",
+      border: 0
+    }
+  }
+) })), or = Ke(
+  ({
+    src: n,
+    options: e,
+    onControllerChange: r
+  }) => {
+    const o = Ht(), c = T(
+      (C) => {
+        o.handleControllerChange(C), r?.(C);
+      },
+      [o, r]
+    );
+    o.logger.log(p.Debug, "NostalgicDiva");
+    const m = sr(n);
+    if (m === void 0)
+      return o.logger.log(
+        p.Warning,
+        `Failed to extract type and videoId from src: "${n}". Returning EmptyPlayer.`
+      ), /* @__PURE__ */ V.jsx(He, {});
+    const { type: R, videoId: w } = m, f = ir.get(R);
+    return f === void 0 ? (o.logger.log(
+      p.Warning,
+      `No player found for type "${R}" (videoId: "${w}"). Returning EmptyPlayer.`
+    ), /* @__PURE__ */ V.jsx(He, {})) : /* @__PURE__ */ V.jsx(jt, { fallback: null, children: /* @__PURE__ */ V.jsx(
+      f,
+      {
+        logger: o.logger,
+        type: R,
+        onControllerChange: c,
+        videoId: w,
+        options: e
+      }
+    ) });
+  }
+);
+class ur extends HTMLElement {
+  static observedAttributes = ["src"];
+  container;
+  controller = Q;
+  constructor() {
+    super(), this.container = this.attachShadow({ mode: "closed" });
+  }
+  get src() {
+    return this.getAttribute("src") ?? "";
+  }
+  set src(e) {
+    this.setAttribute("src", e);
+  }
+  #t = {
+    onError: (e) => this.dispatchEvent(new CustomEvent("error", { detail: e })),
+    onLoaded: (e) => this.dispatchEvent(new CustomEvent("loaded", { detail: e })),
+    onPlay: () => this.dispatchEvent(new CustomEvent("play")),
+    onPause: () => this.dispatchEvent(new CustomEvent("pause")),
+    onEnded: () => this.dispatchEvent(new CustomEvent("ended")),
+    onTimeUpdate: (e) => this.dispatchEvent(new CustomEvent("timeupdate", { detail: e }))
+  };
+  #r = (e) => {
+    console.debug(
+      "[@nostalgic-diva/web-components] handleControllerChange"
+    ), this.controller = e;
+  };
+  #e() {
+    Ut.render(
+      /* @__PURE__ */ V.jsx(Bt, { children: /* @__PURE__ */ V.jsx(
+        or,
+        {
+          src: this.src,
+          options: this.#t,
+          onControllerChange: this.#r
+        }
+      ) }),
+      this.container
+    );
+  }
+  connectedCallback() {
+    console.debug("[@nostalgic-diva/web-components] connectedCallback"), this.#e();
+  }
+  disconnectedCallback() {
+    console.debug("[@nostalgic-diva/web-components] disconnectedCallback");
+  }
+  attributeChangedCallback() {
+    console.debug(
+      "[@nostalgic-diva/web-components] attributeChangedCallback"
+    ), this.#e();
+  }
+  async loadVideo(e) {
+    await this.controller.loadVideo(e);
+  }
+  async play() {
+    await this.controller.play();
+  }
+  async pause() {
+    await this.controller.pause();
+  }
+  async setCurrentTime(e) {
+    await this.controller.setCurrentTime(e);
+  }
+  async setVolume(e) {
+    await this.controller.setVolume(e);
+  }
+  async setMuted(e) {
+    await this.controller.setMuted(e);
+  }
+  async setPlaybackRate(e) {
+    await this.controller.setPlaybackRate(e);
+  }
+  async getDuration() {
+    return await this.controller.getDuration();
+  }
+  async getCurrentTime() {
+    return await this.controller.getCurrentTime();
+  }
+  async getVolume() {
+    return await this.controller.getVolume();
+  }
+  async getMuted() {
+    return await this.controller.getMuted();
+  }
+  async getPlaybackRate() {
+    return await this.controller.getPlaybackRate();
+  }
+  supports(e) {
+    return this.controller.supports(e);
+  }
+}
+function yr() {
+  customElements.define("nostalgic-diva", ur);
+}
+function lr() {
+  const n = L(!0);
+  return n.current ? (n.current = !1, !0) : n.current;
+}
+const cr = (n, e) => n === e;
+function dr(n, e = cr) {
+  const r = L(), o = L(n);
+  return !lr() && !e(o.current, n) && (r.current = o.current, o.current = n), r.current;
+}
+class Y {
+  constructor(e, r, o) {
+    this.logger = e, this.player = r, this.options = o, this.logger.log(p.Debug, "ctor");
+  }
+  supports(e) {
+    return this[e] !== void 0;
+  }
+}
+class de {
+  constructor(e, r, o, c, m) {
+    this.logger = e, this.type = r, this.player = o, this.options = c, this.controllerFactory = m, this.id = de.nextId++;
+  }
+  static nextId = 1;
+  id;
+  impl;
+  createMessage(e) {
+    return `${this.type}#${this.id} ${e}`;
+  }
+  debug(e, ...r) {
+    this.logger.log(
+      p.Debug,
+      this.createMessage(e),
+      ...r
+    );
+  }
+  error(e, ...r) {
+    this.logger.log(
+      p.Error,
+      this.createMessage(e),
+      ...r
+    );
+  }
+  async attach(e) {
+    if (this.debug("attach", e), this.impl) {
+      this.debug("player is already attached");
+      return;
+    }
+    this.debug("Attaching player..."), this.impl = new this.controllerFactory(
+      this.logger,
+      this.player,
+      this.options
+    ), await this.impl.attach(e), this.debug("player attached");
+  }
+  createPlayerNotAttachedError() {
+    return this.error("player is not attached"), new Error("player is not attached");
+  }
+  createCommandNotSupportedError(e) {
+    return new Error(`${e} is not supported`);
+  }
+  async detach() {
+    if (this.debug("detach"), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    await this.impl.detach(), this.impl = void 0;
+  }
+  async loadVideo(e) {
+    if (this.debug("loadVideo", e), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.loadVideo === void 0)
+      throw this.createCommandNotSupportedError("loadVideo");
+    this.debug("Loading video..."), await this.impl.loadVideo(e), this.debug("video loaded", e);
+  }
+  play() {
+    if (this.debug("play"), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.play === void 0)
+      throw this.createCommandNotSupportedError("play");
+    return this.impl.play();
+  }
+  pause() {
+    if (this.debug("pause"), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.pause === void 0)
+      throw this.createCommandNotSupportedError("pause");
+    return this.impl.pause();
+  }
+  setCurrentTime(e) {
+    if (this.debug("setCurrentTime", e), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.setCurrentTime === void 0)
+      throw this.createCommandNotSupportedError("setCurrentTime");
+    return this.impl.setCurrentTime(e);
+  }
+  setVolume(e) {
+    if (this.debug("setVolume", e), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.setVolume === void 0)
+      throw this.createCommandNotSupportedError("setVolume");
+    return this.impl.setVolume(e);
+  }
+  setMuted(e) {
+    if (this.debug("setMuted", e), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.setMuted === void 0)
+      throw this.createCommandNotSupportedError("setMuted");
+    return this.impl.setMuted(e);
+  }
+  setPlaybackRate(e) {
+    if (this.debug("setPlaybackRate", e), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.setPlaybackRate === void 0)
+      throw this.createCommandNotSupportedError("setPlaybackRate");
+    return this.impl.setPlaybackRate(e);
+  }
+  getDuration() {
+    if (this.debug("getDuration"), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.getDuration === void 0)
+      throw this.createCommandNotSupportedError("getDuration");
+    return this.impl.getDuration();
+  }
+  getCurrentTime() {
+    if (this.debug("getCurrentTime"), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.getCurrentTime === void 0)
+      throw this.createCommandNotSupportedError("getCurrentTime");
+    return this.impl.getCurrentTime();
+  }
+  getVolume() {
+    if (this.debug("getVolume"), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.getVolume === void 0)
+      throw this.createCommandNotSupportedError("getVolume");
+    return this.impl.getVolume();
+  }
+  getMuted() {
+    if (this.debug("getMuted"), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.getMuted === void 0)
+      throw this.createCommandNotSupportedError("getMuted");
+    return this.impl.getMuted();
+  }
+  getPlaybackRate() {
+    if (this.debug("getPlaybackRate"), this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    if (this.impl.getPlaybackRate === void 0)
+      throw this.createCommandNotSupportedError("getPlaybackRate");
+    return this.impl.getPlaybackRate();
+  }
+  supports(e) {
+    if (this.impl === void 0)
+      throw this.createPlayerNotAttachedError();
+    return this.impl.supports(e);
+  }
+}
+const fr = ({
+  logger: n,
+  type: e,
+  loadScript: r,
+  playerFactory: o,
+  onControllerChange: c,
+  videoId: m,
+  options: R,
+  controllerFactory: w,
+  children: f
+}) => {
+  n.log(p.Debug, "PlayerContainer");
+  const C = L(m), b = L(void 0), [P, k] = je(), [I, M] = je(Q), x = T(
+    (E) => {
+      M(E), c?.(E);
+    },
+    [c]
+  );
+  ue(() => {
+    (r?.() ?? Promise.resolve()).then(() => o(b.current, C.current)).then((E) => k(E));
+  }, [r, o]), ue(() => {
+    if (P === void 0)
+      return;
+    const E = new de(
+      n,
+      e,
+      P,
+      R,
+      w
+    );
+    return E.attach(C.current).then(() => x(E)), () => {
+      E.detach().finally(() => x(Q));
+    };
+  }, [
+    n,
+    e,
+    r,
+    P,
+    R,
+    w,
+    x
+  ]);
+  const A = dr(m);
+  return ue(() => {
+    A !== void 0 && I.loadVideo(m);
+  }, [A, m, I]), /* @__PURE__ */ V.jsx(V.Fragment, { children: f(b, C.current) });
+};
+class mr extends Y {
+  async attach() {
+    this.player.onerror = (e) => this.options?.onError?.(e), this.player.onloadeddata = () => this.options?.onLoaded?.({ id: this.player.src }), this.player.onplay = () => this.options?.onPlay?.(), this.player.onpause = () => this.options?.onPause?.(), this.player.onended = () => this.options?.onEnded?.(), this.player.ontimeupdate = () => {
+      this.options?.onTimeUpdate?.({
+        duration: this.player.duration,
+        percent: this.player.currentTime / this.player.duration,
+        seconds: this.player.currentTime
+      });
+    };
+  }
+  async detach() {
+    this.player.onerror = null, this.player.onloadeddata = null, this.player.onplay = null, this.player.onpause = null, this.player.onended = null, this.player.ontimeupdate = null;
+  }
+  async loadVideo(e) {
+    this.player.src = e;
+  }
+  async play() {
+    await this.player.play();
+  }
+  async pause() {
+    this.player.pause();
+  }
+  async setCurrentTime(e) {
+    this.player.currentTime = e;
+  }
+  async setVolume(e) {
+    this.player.volume = e;
+  }
+  async setMuted(e) {
+    this.player.muted = e;
+  }
+  async setPlaybackRate(e) {
+    this.player.playbackRate = e;
+  }
+  async getDuration() {
+    return this.player.duration;
+  }
+  async getCurrentTime() {
+    return this.player.currentTime;
+  }
+  async getVolume() {
+    return this.player.volume;
+  }
+  async getMuted() {
+    return this.player.muted;
+  }
+  async getPlaybackRate() {
+    return this.player.playbackRate;
+  }
+}
+const qe = [
+  "apiready",
+  "seeked",
+  "video_end",
+  "durationchange",
+  "pause",
+  "playing",
+  "error"
+];
+class vr extends Y {
+  handlePlayerEvents = (e) => {
+    switch (e.type) {
+      case "apiready":
+        this.options?.onLoaded?.({ id: this.player.video.videoId });
+        break;
+      case "seeked":
+        this.options?.onTimeUpdate?.({
+          duration: this.player.duration,
+          percent: this.player.currentTime / this.player.duration,
+          seconds: this.player.currentTime
+        });
+        break;
+      case "video_end":
+        this.options?.onEnded?.();
+        break;
+      case "durationchange":
+        break;
+      case "pause":
+        this.options?.onPause?.();
+        break;
+      case "playing":
+        this.options?.onPlay?.();
+        break;
+      case "error":
+        this.options?.onError?.(e);
+        break;
+    }
+  };
+  async attach(e) {
+    for (const r of qe)
+      this.player.addEventListener(r, this.handlePlayerEvents);
+  }
+  async detach() {
+    for (const e of qe)
+      this.player.removeEventListener(e, this.handlePlayerEvents);
+  }
+  async loadVideo(e) {
+    this.player.load(e);
+  }
+  async play() {
+    this.player.play();
+  }
+  async pause() {
+    this.player.pause();
+  }
+  async setCurrentTime(e) {
+    this.player.seek(e);
+  }
+  async setVolume(e) {
+    this.player.setVolume(e);
+  }
+  async setMuted(e) {
+    this.player.setMuted(e);
+  }
+  setPlaybackRate = void 0;
+  async getDuration() {
+    return this.player.duration;
+  }
+  async getCurrentTime() {
+    return this.player.currentTime;
+  }
+  async getVolume() {
+    return this.player.volume;
+  }
+  async getMuted() {
+    return this.player.muted;
+  }
+  getPlaybackRate = void 0;
+}
+var le = /* @__PURE__ */ ((n) => (n[n.Play = 2] = "Play", n[n.Pause = 3] = "Pause", n[n.End = 4] = "End", n))(le || {});
+class ce extends Y {
+  static origin = "https://embed.nicovideo.jp";
+  duration = 0;
+  currentTime = 0;
+  volume = 0;
+  muted = !1;
+  handleMessage = (e) => {
+    if (e.origin !== ce.origin) return;
+    const r = e.data;
+    switch (r.eventName) {
+      case "playerStatusChange":
+        this.logger.log(
+          p.Debug,
+          `player status changed: ${le[r.data.playerStatus] ?? r.data.playerStatus}`
+        );
+        break;
+      case "statusChange":
+        switch (this.logger.log(
+          p.Debug,
+          `status changed: ${le[r.data.playerStatus] ?? r.data.playerStatus}`
+        ), r.data.playerStatus) {
+          case 2:
+            this.options?.onPlay?.();
+            break;
+          case 3:
+            this.options?.onPause?.();
+            break;
+          case 4:
+            this.options?.onEnded?.();
+            break;
+        }
+        break;
+      case "playerMetadataChange":
+        r.data.duration !== void 0 && (this.duration = r.data.duration / 1e3), this.currentTime = r.data.currentTime === void 0 ? 0 : r.data.currentTime / 1e3, this.volume = r.data.volume, this.muted = r.data.muted, this.options?.onTimeUpdate?.({
+          duration: this.duration,
+          percent: this.currentTime !== 0 && this.duration !== 0 ? this.currentTime / this.duration : 0,
+          seconds: this.currentTime
+        });
+        break;
+      case "loadComplete":
+        this.logger.log(p.Debug, "load completed"), this.duration = r.data.videoInfo.lengthInSeconds, this.options?.onLoaded?.({ id: r.data.videoInfo.watchId });
+        break;
+      case "error":
+        this.options?.onError?.(r);
+        break;
+      case "player-error:video:play":
+      case "player-error:video:seek":
+        this.options?.onError?.(r);
+        break;
+      default:
+        this.logger.log(
+          p.Debug,
+          "message",
+          r.eventName,
+          r.data
+        );
+        break;
+    }
+  };
+  async attach() {
+    window.addEventListener("message", this.handleMessage);
+  }
+  async detach() {
+    window.removeEventListener("message", this.handleMessage);
+  }
+  async loadVideo(e) {
+    return new Promise((r, o) => {
+      this.duration = 0, this.currentTime = 0, this.volume = 0, this.muted = !1, this.player.onload = () => {
+        this.player.onload = null, r();
+      }, this.player.src = `https://embed.nicovideo.jp/watch/${e}?jsapi=1&playerId=1`;
+    });
+  }
+  // https://blog.hayu.io/web/create/nicovideo-embed-player-api/.
+  postMessage(e) {
+    this.player.contentWindow?.postMessage(
+      {
+        ...e,
+        playerId: "1",
+        sourceConnectorType: 1
+      },
+      ce.origin
+    );
+  }
+  async play() {
+    this.postMessage({ eventName: "play" });
+  }
+  async pause() {
+    this.postMessage({ eventName: "pause" });
+  }
+  async setCurrentTime(e) {
+    this.postMessage({ eventName: "seek", data: { time: e * 1e3 } });
+  }
+  async setVolume(e) {
+    this.postMessage({
+      eventName: "volumeChange",
+      data: { volume: e }
+    });
+  }
+  async setMuted(e) {
+    this.postMessage({
+      eventName: "mute",
+      data: { mute: e }
+    });
+  }
+  setPlaybackRate = void 0;
+  async getDuration() {
+    return this.duration;
+  }
+  async getCurrentTime() {
+    return this.currentTime;
+  }
+  async getVolume() {
+    return this.volume;
+  }
+  async getMuted() {
+    return this.muted;
+  }
+  getPlaybackRate = void 0;
+}
+class Xe extends Y {
+  getDurationCore() {
+    return new Promise((e, r) => {
+      this.player.getDuration(e);
+    });
+  }
+  attach(e) {
+    return new Promise((r, o) => {
+      this.player.bind(SC.Widget.Events.READY, () => {
+        this.player.bind(
+          SC.Widget.Events.PLAY_PROGRESS,
+          async (c) => {
+            const m = await this.getDurationCore();
+            this.options?.onTimeUpdate?.({
+              duration: m / 1e3,
+              percent: c.currentPosition / m,
+              seconds: c.currentPosition / 1e3
+            });
+          }
+        ), this.player.bind(
+          SC.Widget.Events.ERROR,
+          (c) => this.options?.onError?.(c)
+        ), this.player.bind(
+          SC.Widget.Events.PLAY,
+          () => this.options?.onPlay?.()
+        ), this.player.bind(
+          SC.Widget.Events.PAUSE,
+          () => this.options?.onPause?.()
+        ), this.player.bind(
+          SC.Widget.Events.FINISH,
+          () => this.options?.onEnded?.()
+        ), this.options?.onLoaded?.({ id: e }), r();
+      });
+    });
+  }
+  async detach() {
+    this.player.unbind(SC.Widget.Events.READY), this.player.unbind(SC.Widget.Events.PLAY_PROGRESS), this.player.unbind(SC.Widget.Events.ERROR), this.player.unbind(SC.Widget.Events.PLAY), this.player.unbind(SC.Widget.Events.PAUSE), this.player.unbind(SC.Widget.Events.FINISH);
+  }
+  static playerLoadAsync(e, r, o) {
+    return new Promise((c, m) => {
+      e.load(r, { ...o, callback: c });
+    });
+  }
+  async loadVideo(e) {
+    await Xe.playerLoadAsync(this.player, e, {
+      auto_play: !0
+    }), this.options?.onLoaded?.({ id: e });
+  }
+  async play() {
+    this.player.play();
+  }
+  async pause() {
+    this.player.pause();
+  }
+  async setCurrentTime(e) {
+    this.player.seekTo(e * 1e3);
+  }
+  async setVolume(e) {
+    this.player.setVolume(e * 100);
+  }
+  setMuted = void 0;
+  setPlaybackRate = void 0;
+  async getDuration() {
+    return await this.getDurationCore() / 1e3;
+  }
+  getCurrentTimeCore() {
+    return new Promise((e, r) => {
+      this.player.getPosition(e);
+    });
+  }
+  async getCurrentTime() {
+    return await this.getCurrentTimeCore() / 1e3;
+  }
+  getVolumeCore() {
+    return new Promise((e, r) => {
+      this.player.getVolume(e);
+    });
+  }
+  async getVolume() {
+    return await this.getVolumeCore() / 100;
+  }
+  getMuted = void 0;
+  getPlaybackRate = void 0;
+}
+class gr extends Y {
+  handleReady = () => {
+    this.options?.onLoaded?.({ id: this.player.getVideo() });
+  };
+  handlePlay = () => {
+    this.options?.onPlay?.();
+  };
+  handlePause = () => {
+    this.options?.onPause?.();
+  };
+  handleEnded = () => {
+    this.options?.onEnded?.();
+  };
+  handleSeek = () => {
+    this.options?.onTimeUpdate?.({
+      duration: 0,
+      percent: 0,
+      seconds: 0
+    });
+  };
+  async attach(e) {
+    this.player.addEventListener(Twitch.Player.READY, this.handleReady), this.player.addEventListener(Twitch.Player.PLAYING, this.handlePlay), this.player.addEventListener(Twitch.Player.PAUSE, this.handlePause), this.player.addEventListener(Twitch.Player.ENDED, this.handleEnded), this.player.addEventListener(Twitch.Player.SEEK, this.handleSeek);
+  }
+  async detach() {
+  }
+  async loadVideo(e) {
+    this.player.setVideo(e, 0);
+  }
+  async play() {
+    this.player.play();
+  }
+  async pause() {
+    this.player.pause();
+  }
+  async setCurrentTime(e) {
+    this.player.seek(e);
+  }
+  async setVolume(e) {
+    this.player.setVolume(e);
+  }
+  async setMuted(e) {
+    this.player.setMuted(e);
+  }
+  setPlaybackRate = void 0;
+  async getDuration() {
+    return this.player.getDuration();
+  }
+  async getCurrentTime() {
+    return this.player.getCurrentTime();
+  }
+  async getVolume() {
+    return this.player.getVolume();
+  }
+  async getMuted() {
+    return this.player.getMuted();
+  }
+  getPlaybackRate = void 0;
+}
+class br extends Y {
+  async attach() {
+    await this.player.ready(), this.player.on("error", (e) => this.options?.onError?.(e)), this.player.on(
+      "loaded",
+      (e) => this.options?.onLoaded?.({ id: e.id.toString() })
+    ), this.player.on("play", () => this.options?.onPlay?.()), this.player.on("pause", () => this.options?.onPause?.()), this.player.on("ended", () => this.options?.onEnded?.()), this.player.on("timeupdate", (e) => {
+      this.options?.onTimeUpdate?.({
+        duration: e.duration,
+        percent: e.percent,
+        seconds: e.seconds
+      });
+    });
+  }
+  async detach() {
+    this.player.off("error"), this.player.off("loaded"), this.player.off("play"), this.player.off("pause"), this.player.off("ended"), this.player.off("timeupdate");
+  }
+  async loadVideo(e) {
+    await this.player.loadVideo(e);
+  }
+  async play() {
+    await this.player.play();
+  }
+  async pause() {
+    await this.player.pause();
+  }
+  async setCurrentTime(e) {
+    await this.player.setCurrentTime(e);
+  }
+  async setVolume(e) {
+    await this.player.setVolume(e);
+  }
+  async setMuted(e) {
+    await this.player.setMuted(e);
+  }
+  async setPlaybackRate(e) {
+    await this.player.setPlaybackRate(e);
+  }
+  async getDuration() {
+    return this.player.getDuration();
+  }
+  async getCurrentTime() {
+    return this.player.getCurrentTime();
+  }
+  async getVolume() {
+    return this.player.getVolume();
+  }
+  async getMuted() {
+    return await this.player.getMuted();
+  }
+  async getPlaybackRate() {
+    return this.player.getPlaybackRate();
+  }
+}
+var Ze = /* @__PURE__ */ ((n) => (n[n.UNSTARTED = -1] = "UNSTARTED", n[n.ENDED = 0] = "ENDED", n[n.PLAYING = 1] = "PLAYING", n[n.PAUSED = 2] = "PAUSED", n[n.BUFFERING = 3] = "BUFFERING", n[n.CUED = 5] = "CUED", n))(Ze || {});
+class Er extends Y {
+  previousTime;
+  timeUpdateIntervalId;
+  clearTimeUpdateInterval() {
+    this.logger.log(
+      p.Debug,
+      "clearTimeUpdateInterval",
+      this.timeUpdateIntervalId
+    ), window.clearInterval(this.timeUpdateIntervalId), this.timeUpdateIntervalId = void 0;
+  }
+  invokeTimeUpdate(e) {
+    const r = e.getCurrentTime();
+    if (r === this.previousTime) return;
+    const o = e.getDuration();
+    this.options?.onTimeUpdate?.({
+      duration: o,
+      percent: r / o,
+      seconds: r
+    }), this.previousTime = r;
+  }
+  setTimeUpdateInterval() {
+    this.logger.log(p.Debug, "setTimeUpdateInterval"), this.clearTimeUpdateInterval(), this.timeUpdateIntervalId = window.setInterval(
+      () => this.invokeTimeUpdate(this.player),
+      250
+    ), this.logger.log(
+      p.Debug,
+      "timeUpdateIntervalId",
+      this.timeUpdateIntervalId
+    ), this.invokeTimeUpdate(this.player);
+  }
+  attach(e) {
+    return new Promise((r, o) => {
+      this.player.addEventListener("onReady", async () => {
+        this.player.addEventListener(
+          "onError",
+          (c) => this.options?.onError?.(c.data)
+        ), this.player.addEventListener(
+          "onStateChange",
+          (c) => {
+            switch (this.logger.log(
+              p.Debug,
+              `state changed: ${Ze[c.data]}`
+            ), c.data) {
+              case YT.PlayerState.CUED:
+                this.options?.onLoaded?.({ id: e });
+                break;
+              case YT.PlayerState.PLAYING:
+                this.options?.onPlay?.(), this.setTimeUpdateInterval();
+                break;
+              case YT.PlayerState.PAUSED:
+                this.options?.onPause?.(), this.clearTimeUpdateInterval();
+                break;
+              case YT.PlayerState.ENDED:
+                this.options?.onEnded?.(), this.clearTimeUpdateInterval();
+                break;
+            }
+          }
+        ), await this.loadVideo(e), r();
+      });
+    });
+  }
+  async detach() {
+    this.clearTimeUpdateInterval();
+  }
+  async loadVideo(e) {
+    this.previousTime = void 0, this.player.cueVideoById(e);
+  }
+  async play() {
+    this.player.playVideo();
+  }
+  async pause() {
+    this.player.pauseVideo();
+  }
+  async setCurrentTime(e) {
+    this.player.seekTo(e), this.invokeTimeUpdate(this.player);
+  }
+  async setVolume(e) {
+    this.player.setVolume(e * 100);
+  }
+  async setMuted(e) {
+    e ? this.player.mute() : this.player.unMute();
+  }
+  async setPlaybackRate(e) {
+    this.player.setPlaybackRate(e);
+  }
+  async getDuration() {
+    return this.player.getDuration();
+  }
+  async getCurrentTime() {
+    return this.player.getCurrentTime();
+  }
+  async getVolume() {
+    return this.player.getVolume() / 100;
+  }
+  async getMuted() {
+    return this.player.isMuted();
+  }
+  async getPlaybackRate() {
+    return this.player.getPlaybackRate();
+  }
+}
+export {
+  mr as A,
+  vr as D,
+  p as L,
+  ce as N,
+  fr as P,
+  Xe as S,
+  gr as T,
+  br as V,
+  Er as Y,
+  or as a,
+  Bt as b,
+  ur as c,
+  yr as d,
+  Lt as e,
+  de as f,
+  Y as g,
+  nr as h,
+  F as i,
+  V as j,
+  Q as n,
+  ir as p,
+  Ht as u,
+  ar as v
+};
+//# sourceMappingURL=index-D5CazY1_.js.map