@aigamo/nostalgic-diva 1.19.2 → 1.19.4

package/dist/index.es.js

@@ -1,773 +1,1238 @@
-import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./PlayerContainer-CxyDj9x4.js";
-import { Suspense as s, createContext as c, lazy as l, memo as u, useCallback as d, useContext as f, useMemo as p, useRef as m } from "react";
-import h from "react-dom";
-//#region src/components/NostalgicDivaProvider.tsx
-var g = t(), _ = c(void 0), v = ({ children: t, logger: n = a }) => {
-	let i = m(e), o = d((e) => {
-		n.log(r.Debug, "NostalgicDivaProvider.handleControllerChange", i.current, e), i.current = e;
-	}, [n]), s = d(async (e) => {
-		n.log(r.Debug, "NostalgicDivaProvider.loadVideo", i.current), await i.current.loadVideo(e);
-	}, [n]), c = d(async () => {
-		n.log(r.Debug, "NostalgicDivaProvider.play", i.current), await i.current.play();
-	}, [n]), l = d(async () => {
-		n.log(r.Debug, "NostalgicDivaProvider.pause", i.current), await i.current.pause();
-	}, [n]), u = d(async (e) => {
-		n.log(r.Debug, "NostalgicDivaProvider.setCurrentTime", i.current), await i.current.setCurrentTime(e), await i.current.play();
-	}, [n]), f = d(async (e) => {
-		n.log(r.Debug, "NostalgicDivaProvider.setVolume", i.current), await i.current.setVolume(e);
-	}, [n]), h = d(async (e) => {
-		n.log(r.Debug, "NostalgicDivaProvider.setMuted", i.current), await i.current.setMuted(e);
-	}, [n]), v = d(async (e) => {
-		n.log(r.Debug, "NostalgicDivaProvider.setPlaybackRate", i.current), await i.current.setPlaybackRate(e);
-	}, [n]), y = d(async () => (n.log(r.Debug, "NostalgicDivaProvider.getDuration", i.current), await i.current.getDuration()), [n]), b = d(async () => (n.log(r.Debug, "NostalgicDivaProvider.getCurrentTime", i.current), await i.current.getCurrentTime()), [n]), x = d(async () => (n.log(r.Debug, "NostalgicDivaProvider.getVolume", i.current), await i.current.getVolume()), [n]), S = d(async () => (n.log(r.Debug, "NostalgicDivaProvider.getMuted", i.current), await i.current.getMuted()), [n]), C = d(async () => (n.log(r.Debug, "NostalgicDivaProvider.getPlaybackRate", i.current), await i.current.getPlaybackRate()), [n]), w = d((e) => i.current.supports(e), []), T = p(() => ({
-		logger: n,
-		handleControllerChange: o,
-		loadVideo: s,
-		play: c,
-		pause: l,
-		setCurrentTime: u,
-		setVolume: f,
-		setMuted: h,
-		setPlaybackRate: v,
-		getDuration: y,
-		getCurrentTime: b,
-		getVolume: x,
-		getMuted: S,
-		getPlaybackRate: C,
-		supports: w
-	}), [
-		n,
-		o,
-		s,
-		c,
-		l,
-		u,
-		f,
-		h,
-		v,
-		y,
-		b,
-		x,
-		S,
-		C,
-		w
-	]);
-	return /* @__PURE__ */ (0, g.jsx)(_.Provider, {
-		value: T,
-		children: t
-	});
-}, y = () => f(_), b = class {
-	constructor(e) {
-		this.type = e;
-	}
-}, x = /\.(m4a|m4b|mp4a|mpga|mp2|mp2a|mp3|m2a|m3a|wav|weba|aac|oga|spx)($|\?)/i, S = /\.(mp4|og[gv]|webm|mov|m4v)(#t=[,\d+]+)?($|\?)/i, C = class extends b {
-	constructor() {
-		super("Audio");
-	}
-	canPlay(e) {
-		return x.test(e) || S.test(e);
-	}
-	extractVideoId(e) {
-		return e;
-	}
-}, w = /^(?:(?:https?):)?(?:\/\/)?(?:www\.)?(?:(?:dailymotion\.com(?:\/embed)?\/video)|dai\.ly)\/([a-zA-Z0-9]+)(?:_[\w_-]+)?(?:[\w.#_-]+)?/, T = class extends b {
-	constructor() {
-		super("Dailymotion");
-	}
-	canPlay(e) {
-		return w.test(e);
-	}
-	extractVideoId(e) {
-		return w.exec(e)?.[1];
-	}
-}, E = /(?:www\.|)?nicovideo\.jp\/watch\/(\w+)$/, D = class extends b {
-	constructor() {
-		super("Niconico");
-	}
-	canPlay(e) {
-		return E.test(e);
-	}
-	extractVideoId(e) {
-		return E.exec(e)?.[1];
-	}
-}, O = /(?:soundcloud\.com|snd\.sc)\/[^.]+$/, k = class extends b {
-	constructor() {
-		super("SoundCloud");
-	}
-	canPlay(e) {
-		return O.test(e);
-	}
-	extractVideoId(e) {
-		return e;
-	}
-}, A = /(?:www\.|go\.)?twitch\.tv\/videos\/(\d+)($|\?)/, j = class extends b {
-	constructor() {
-		super("Twitch");
-	}
-	canPlay(e) {
-		return A.test(e);
-	}
-	extractVideoId(e) {
-		return A.exec(e)?.[1];
-	}
-}, M = /vimeo\.com\/(\d+)$/, N = class extends b {
-	constructor() {
-		super("Vimeo");
-	}
-	canPlay(e) {
-		return M.test(e);
-	}
-	extractVideoId(e) {
-		return M.exec(e)?.[1];
-	}
-}, P = /(?:youtu\.be\/|youtube(?:-nocookie|education)?\.com\/(?:embed\/|v\/|watch\/|watch\?v=|watch\?.+&v=|shorts\/|live\/))((\w|-){11})|youtube\.com\/playlist\?list=|youtube\.com\/user\//, F = [
-	new class extends b {
-		constructor() {
-			super("YouTube");
-		}
-		canPlay(e) {
-			return P.test(e);
-		}
-		extractVideoId(e) {
-			return P.exec(e)?.[1];
-		}
-	}(),
-	new j(),
-	new N(),
-	new T(),
-	new k(),
-	new C(),
-	new D()
+import { jsx as d, Fragment as F } from "react/jsx-runtime";
+import { createContext as H, useContext as G, useRef as C, useCallback as o, useMemo as B, lazy as m, memo as $, Suspense as z, useState as I, useEffect as k } from "react";
+import X from "react-dom";
+var s = /* @__PURE__ */ ((a) => (a[a.Trace = 0] = "Trace", a[a.Debug = 1] = "Debug", a[a.Information = 2] = "Information", a[a.Warning = 3] = "Warning", a[a.Error = 4] = "Error", a[a.Critical = 5] = "Critical", a[a.None = 6] = "None", a))(s || {});
+class q {
+  title = "nostalgic-diva";
+  createMessage(e) {
+    return `[${this.title}] ${e}`;
+  }
+  debug(e, ...t) {
+    console.debug(this.createMessage(e), ...t);
+  }
+  error(e, ...t) {
+    console.error(this.createMessage(e), ...t);
+  }
+  warn(e, ...t) {
+    console.warn(this.createMessage(e), ...t);
+  }
+  isEnabled() {
+    return !0;
+  }
+  log(e, t, ...r) {
+    switch (e) {
+      case 1:
+        this.debug(t, ...r);
+        break;
+      case 3:
+        this.warn(t, ...r);
+        break;
+      case 4:
+        this.error(t, ...r);
+        break;
+    }
+  }
+}
+const K = new q();
+class Z {
+  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 f = new Z(), W = H(
+  void 0
+), J = ({
+  children: a,
+  logger: e = K
+}) => {
+  const t = C(f), r = o(
+    (c) => {
+      e.log(
+        s.Debug,
+        "NostalgicDivaProvider.handleControllerChange",
+        t.current,
+        c
+      ), t.current = c;
+    },
+    [e]
+  ), i = o(
+    async (c) => {
+      e.log(
+        s.Debug,
+        "NostalgicDivaProvider.loadVideo",
+        t.current
+      ), await t.current.loadVideo(c);
+    },
+    [e]
+  ), n = o(async () => {
+    e.log(
+      s.Debug,
+      "NostalgicDivaProvider.play",
+      t.current
+    ), await t.current.play();
+  }, [e]), u = o(async () => {
+    e.log(
+      s.Debug,
+      "NostalgicDivaProvider.pause",
+      t.current
+    ), await t.current.pause();
+  }, [e]), p = o(
+    async (c) => {
+      e.log(
+        s.Debug,
+        "NostalgicDivaProvider.setCurrentTime",
+        t.current
+      ), await t.current.setCurrentTime(c), await t.current.play();
+    },
+    [e]
+  ), y = o(
+    async (c) => {
+      e.log(
+        s.Debug,
+        "NostalgicDivaProvider.setVolume",
+        t.current
+      ), await t.current.setVolume(c);
+    },
+    [e]
+  ), h = o(
+    async (c) => {
+      e.log(
+        s.Debug,
+        "NostalgicDivaProvider.setMuted",
+        t.current
+      ), await t.current.setMuted(c);
+    },
+    [e]
+  ), E = o(
+    async (c) => {
+      e.log(
+        s.Debug,
+        "NostalgicDivaProvider.setPlaybackRate",
+        t.current
+      ), await t.current.setPlaybackRate(c);
+    },
+    [e]
+  ), b = o(async () => (e.log(
+    s.Debug,
+    "NostalgicDivaProvider.getDuration",
+    t.current
+  ), await t.current.getDuration()), [e]), D = o(async () => (e.log(
+    s.Debug,
+    "NostalgicDivaProvider.getCurrentTime",
+    t.current
+  ), await t.current.getCurrentTime()), [e]), P = o(async () => (e.log(
+    s.Debug,
+    "NostalgicDivaProvider.getVolume",
+    t.current
+  ), await t.current.getVolume()), [e]), V = o(async () => (e.log(
+    s.Debug,
+    "NostalgicDivaProvider.getMuted",
+    t.current
+  ), await t.current.getMuted()), [e]), w = o(async () => (e.log(
+    s.Debug,
+    "NostalgicDivaProvider.getPlaybackRate",
+    t.current
+  ), await t.current.getPlaybackRate()), [e]), T = o(
+    (c) => t.current.supports(c),
+    []
+  ), l = B(
+    () => ({
+      logger: e,
+      handleControllerChange: r,
+      loadVideo: i,
+      play: n,
+      pause: u,
+      setCurrentTime: p,
+      setVolume: y,
+      setMuted: h,
+      setPlaybackRate: E,
+      getDuration: b,
+      getCurrentTime: D,
+      getVolume: P,
+      getMuted: V,
+      getPlaybackRate: w,
+      supports: T
+    }),
+    [
+      e,
+      r,
+      i,
+      n,
+      u,
+      p,
+      y,
+      h,
+      E,
+      b,
+      D,
+      P,
+      V,
+      w,
+      T
+    ]
+  );
+  return /* @__PURE__ */ d(W.Provider, { value: l, children: a });
+}, Q = () => G(W);
+class g {
+  constructor(e) {
+    this.type = e;
+  }
+}
+const ee = /\.(m4a|m4b|mp4a|mpga|mp2|mp2a|mp3|m2a|m3a|wav|weba|aac|oga|spx)($|\?)/i, te = /\.(mp4|og[gv]|webm|mov|m4v)(#t=[,\d+]+)?($|\?)/i;
+class ae extends g {
+  constructor() {
+    super("Audio");
+  }
+  canPlay(e) {
+    return ee.test(e) || te.test(e);
+  }
+  extractVideoId(e) {
+    return e;
+  }
+}
+const S = /^(?:(?:https?):)?(?:\/\/)?(?:www\.)?(?:(?:dailymotion\.com(?:\/embed)?\/video)|dai\.ly)\/([a-zA-Z0-9]+)(?:_[\w_-]+)?(?:[\w.#_-]+)?/;
+class re extends g {
+  constructor() {
+    super("Dailymotion");
+  }
+  canPlay(e) {
+    return S.test(e);
+  }
+  extractVideoId(e) {
+    return S.exec(e)?.[1];
+  }
+}
+const A = /(?:www\.|)?nicovideo\.jp\/watch\/(\w+)$/;
+class se extends g {
+  constructor() {
+    super("Niconico");
+  }
+  canPlay(e) {
+    return A.test(e);
+  }
+  extractVideoId(e) {
+    return A.exec(e)?.[1];
+  }
+}
+const ie = /(?:soundcloud\.com|snd\.sc)\/[^.]+$/;
+class ne extends g {
+  constructor() {
+    super("SoundCloud");
+  }
+  canPlay(e) {
+    return ie.test(e);
+  }
+  extractVideoId(e) {
+    return e;
+  }
+}
+const U = /(?:www\.|go\.)?twitch\.tv\/videos\/(\d+)($|\?)/;
+class oe extends g {
+  constructor() {
+    super("Twitch");
+  }
+  canPlay(e) {
+    return U.test(e);
+  }
+  extractVideoId(e) {
+    return U.exec(e)?.[1];
+  }
+}
+const x = /vimeo\.com\/(\d+)$/;
+class ce extends g {
+  constructor() {
+    super("Vimeo");
+  }
+  canPlay(e) {
+    return x.test(e);
+  }
+  extractVideoId(e) {
+    return x.exec(e)?.[1];
+  }
+}
+const _ = /(?: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 le extends g {
+  constructor() {
+    super("YouTube");
+  }
+  canPlay(e) {
+    return _.test(e);
+  }
+  extractVideoId(e) {
+    return _.exec(e)?.[1];
+  }
+}
+const de = [
+  new le(),
+  new oe(),
+  new ce(),
+  new re(),
+  new ne(),
+  new ae(),
+  new se()
 ];
-function I(e) {
-	return F.find((t) => t.canPlay(e));
+function ue(a) {
+  return de.find((e) => e.canPlay(a));
+}
+const he = new Map(
+  Object.entries({
+    Audio: m(() => import("./AudioPlayer-BMxdg9dp.js")),
+    Dailymotion: m(() => import("./DailymotionPlayer-B4M9j0Lx.js")),
+    Niconico: m(() => import("./NiconicoPlayer-Cx3hGYsw.js")),
+    SoundCloud: m(() => import("./SoundCloudPlayer-C8QVPCXH.js")),
+    Twitch: m(() => import("./TwitchPlayer-C9D_eEaj.js")),
+    Vimeo: m(() => import("./VimeoPlayer-UnKk2VAq.js")),
+    YouTube: m(() => import("./YouTubePlayer-bNmEJD02.js"))
+  })
+);
+function pe(a) {
+  const e = ue(a);
+  if (e === void 0)
+    return;
+  const { type: t, extractVideoId: r } = e, i = r(a);
+  if (i !== void 0)
+    return { type: t, videoId: i };
+}
+const Y = $(() => /* @__PURE__ */ d("div", { style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ d(
+  "iframe",
+  {
+    src: "about:blank",
+    title: "about:blank",
+    style: {
+      width: "100%",
+      height: "100%",
+      border: 0
+    }
+  }
+) })), ye = $(
+  ({
+    src: a,
+    options: e,
+    onControllerChange: t
+  }) => {
+    const r = Q(), i = o(
+      (h) => {
+        r.handleControllerChange(h), t?.(h);
+      },
+      [r, t]
+    );
+    r.logger.log(s.Debug, "NostalgicDiva");
+    const n = pe(a);
+    if (n === void 0)
+      return r.logger.log(
+        s.Warning,
+        `Failed to extract type and videoId from src: "${a}". Returning EmptyPlayer.`
+      ), /* @__PURE__ */ d(Y, {});
+    const { type: u, videoId: p } = n, y = he.get(u);
+    return y === void 0 ? (r.logger.log(
+      s.Warning,
+      `No player found for type "${u}" (videoId: "${p}"). Returning EmptyPlayer.`
+    ), /* @__PURE__ */ d(Y, {})) : /* @__PURE__ */ d(z, { fallback: null, children: /* @__PURE__ */ d(
+      y,
+      {
+        logger: r.logger,
+        type: u,
+        onControllerChange: i,
+        videoId: p,
+        options: e
+      }
+    ) });
+  }
+);
+class me extends HTMLElement {
+  static observedAttributes = ["src"];
+  container;
+  controller = f;
+  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 }))
+  };
+  #a = (e) => {
+    console.debug(
+      "[@nostalgic-diva/web-components] handleControllerChange"
+    ), this.controller = e;
+  };
+  #e() {
+    X.render(
+      /* @__PURE__ */ d(J, { children: /* @__PURE__ */ d(
+        ye,
+        {
+          src: this.src,
+          options: this.#t,
+          onControllerChange: this.#a
+        }
+      ) }),
+      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);
+  }
 }
-//#endregion
-//#region src/components/NostalgicDiva.tsx
-var L = new Map(Object.entries({
-	Audio: l(() => import("./AudioPlayer-Rgj403rr.js")),
-	Dailymotion: l(() => import("./DailymotionPlayer-DKnJvBrE.js")),
-	Niconico: l(() => import("./NiconicoPlayer-BWepjJRp.js")),
-	SoundCloud: l(() => import("./SoundCloudPlayer-CIo1SPsW.js")),
-	Twitch: l(() => import("./TwitchPlayer-CipxSXDX.js")),
-	Vimeo: l(() => import("./VimeoPlayer-C-0MryDy.js")),
-	YouTube: l(() => import("./YouTubePlayer-DXq_8Mrm.js"))
-}));
-function R(e) {
-	let t = I(e);
-	if (t === void 0) return;
-	let { type: n, extractVideoId: r } = t, i = r(e);
-	if (i !== void 0) return {
-		type: n,
-		videoId: i
-	};
+function Pe() {
+  customElements.define("nostalgic-diva", me);
 }
-var z = u(() => /* @__PURE__ */ (0, g.jsx)("div", {
-	style: {
-		width: "100%",
-		height: "100%"
-	},
-	children: /* @__PURE__ */ (0, g.jsx)("iframe", {
-		src: "about:blank",
-		title: "about:blank",
-		style: {
-			width: "100%",
-			height: "100%",
-			border: 0
-		}
-	})
-})), B = u(({ src: e, options: t, onControllerChange: n }) => {
-	let i = y(), a = d((e) => {
-		i.handleControllerChange(e), n?.(e);
-	}, [i, n]);
-	i.logger.log(r.Debug, "NostalgicDiva");
-	let o = R(e);
-	if (o === void 0) return i.logger.log(r.Warning, `Failed to extract type and videoId from src: "${e}". Returning EmptyPlayer.`), /* @__PURE__ */ (0, g.jsx)(z, {});
-	let { type: c, videoId: l } = o, u = L.get(c);
-	return u === void 0 ? (i.logger.log(r.Warning, `No player found for type "${c}" (videoId: "${l}"). Returning EmptyPlayer.`), /* @__PURE__ */ (0, g.jsx)(z, {})) : /* @__PURE__ */ (0, g.jsx)(s, {
-		fallback: null,
-		children: /* @__PURE__ */ (0, g.jsx)(u, {
-			logger: i.logger,
-			type: c,
-			onControllerChange: a,
-			videoId: l,
-			options: t
-		})
-	});
-}), V = class extends HTMLElement {
-	static observedAttributes = ["src"];
-	container;
-	controller = e;
-	constructor() {
-		super(), this.container = this.attachShadow({ mode: "closed" });
-	}
-	get src() {
-		return this.getAttribute("src") ?? "";
-	}
-	set src(e) {
-		this.setAttribute("src", e);
-	}
-	#e = {
-		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 }))
-	};
-	#t = (e) => {
-		console.debug("[@nostalgic-diva/web-components] handleControllerChange"), this.controller = e;
-	};
-	#n() {
-		h.render(/* @__PURE__ */ (0, g.jsx)(v, { children: /* @__PURE__ */ (0, g.jsx)(B, {
-			src: this.src,
-			options: this.#e,
-			onControllerChange: this.#t
-		}) }), this.container);
-	}
-	connectedCallback() {
-		console.debug("[@nostalgic-diva/web-components] connectedCallback"), this.#n();
-	}
-	disconnectedCallback() {
-		console.debug("[@nostalgic-diva/web-components] disconnectedCallback");
-	}
-	attributeChangedCallback() {
-		console.debug("[@nostalgic-diva/web-components] attributeChangedCallback"), this.#n();
-	}
-	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 ge() {
+  const a = C(!0);
+  return a.current ? (a.current = !1, !0) : a.current;
+}
+const ve = (a, e) => a === e;
+function be(a, e = ve) {
+  const t = C(), r = C(a);
+  return !ge() && !e(r.current, a) && (t.current = r.current, r.current = a), t.current;
+}
+class v {
+  constructor(e, t, r) {
+    this.logger = e, this.player = t, this.options = r, this.logger.log(s.Debug, "ctor");
+  }
+  supports(e) {
+    return this[e] !== void 0;
+  }
+}
+class M {
+  constructor(e, t, r, i, n) {
+    this.logger = e, this.type = t, this.player = r, this.options = i, this.controllerFactory = n, this.id = M.nextId++;
+  }
+  static nextId = 1;
+  id;
+  impl;
+  createMessage(e) {
+    return `${this.type}#${this.id} ${e}`;
+  }
+  debug(e, ...t) {
+    this.logger.log(
+      s.Debug,
+      this.createMessage(e),
+      ...t
+    );
+  }
+  error(e, ...t) {
+    this.logger.log(
+      s.Error,
+      this.createMessage(e),
+      ...t
+    );
+  }
+  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 Te = ({
+  logger: a,
+  type: e,
+  loadScript: t,
+  playerFactory: r,
+  onControllerChange: i,
+  videoId: n,
+  options: u,
+  controllerFactory: p,
+  children: y
+}) => {
+  a.log(s.Debug, "PlayerContainer");
+  const h = C(n), E = C(void 0), [b, D] = I(), [P, V] = I(f), w = o(
+    (l) => {
+      V(l), i?.(l);
+    },
+    [i]
+  );
+  k(() => {
+    (t?.() ?? Promise.resolve()).then(() => r(E.current, h.current)).then((l) => D(l));
+  }, [t, r]), k(() => {
+    if (b === void 0)
+      return;
+    const l = new M(
+      a,
+      e,
+      b,
+      u,
+      p
+    );
+    return l.attach(h.current).then(() => w(l)), () => {
+      l.detach().finally(() => w(f));
+    };
+  }, [
+    a,
+    e,
+    t,
+    b,
+    u,
+    p,
+    w
+  ]);
+  const T = be(n);
+  return k(() => {
+    T !== void 0 && P.loadVideo(n);
+  }, [T, n, P]), /* @__PURE__ */ d(F, { children: y(E, h.current) });
 };
-function H() {
-	customElements.define("nostalgic-diva", V);
+class De extends v {
+  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 O = [
+  "apiready",
+  "seeked",
+  "video_end",
+  "durationchange",
+  "pause",
+  "playing",
+  "error"
+];
+class Ve extends v {
+  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 t of O)
+      this.player.addEventListener(t, this.handlePlayerEvents);
+  }
+  async detach() {
+    for (const e of O)
+      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 N = /* @__PURE__ */ ((a) => (a[a.Play = 2] = "Play", a[a.Pause = 3] = "Pause", a[a.End = 4] = "End", a))(N || {});
+class R extends v {
+  static origin = "https://embed.nicovideo.jp";
+  duration = 0;
+  currentTime = 0;
+  volume = 0;
+  muted = !1;
+  handleMessage = (e) => {
+    if (e.origin !== R.origin) return;
+    const t = e.data;
+    switch (t.eventName) {
+      case "playerStatusChange":
+        this.logger.log(
+          s.Debug,
+          `player status changed: ${N[t.data.playerStatus] ?? t.data.playerStatus}`
+        );
+        break;
+      case "statusChange":
+        switch (this.logger.log(
+          s.Debug,
+          `status changed: ${N[t.data.playerStatus] ?? t.data.playerStatus}`
+        ), t.data.playerStatus) {
+          case 2:
+            this.options?.onPlay?.();
+            break;
+          case 3:
+            this.options?.onPause?.();
+            break;
+          case 4:
+            this.options?.onEnded?.();
+            break;
+        }
+        break;
+      case "playerMetadataChange":
+        t.data.duration !== void 0 && (this.duration = t.data.duration / 1e3), this.currentTime = t.data.currentTime === void 0 ? 0 : t.data.currentTime / 1e3, this.volume = t.data.volume, this.muted = t.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(s.Debug, "load completed"), this.duration = t.data.videoInfo.lengthInSeconds, this.options?.onLoaded?.({ id: t.data.videoInfo.watchId });
+        break;
+      case "error":
+        this.options?.onError?.(t);
+        break;
+      case "player-error:video:play":
+      case "player-error:video:seek":
+        this.options?.onError?.(t);
+        break;
+      default:
+        this.logger.log(
+          s.Debug,
+          "message",
+          t.eventName,
+          t.data
+        );
+        break;
+    }
+  };
+  async attach() {
+    window.addEventListener("message", this.handleMessage);
+  }
+  async detach() {
+    window.removeEventListener("message", this.handleMessage);
+  }
+  async loadVideo(e) {
+    return new Promise((t, r) => {
+      this.duration = 0, this.currentTime = 0, this.volume = 0, this.muted = !1, this.player.onload = () => {
+        this.player.onload = null, t();
+      }, 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
+      },
+      R.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 L extends v {
+  getDurationCore() {
+    return new Promise((e, t) => {
+      this.player.getDuration(e);
+    });
+  }
+  attach(e) {
+    return new Promise((t, r) => {
+      this.player.bind(SC.Widget.Events.READY, () => {
+        this.player.bind(
+          SC.Widget.Events.PLAY_PROGRESS,
+          async (i) => {
+            const n = await this.getDurationCore();
+            this.options?.onTimeUpdate?.({
+              duration: n / 1e3,
+              percent: i.currentPosition / n,
+              seconds: i.currentPosition / 1e3
+            });
+          }
+        ), this.player.bind(
+          SC.Widget.Events.ERROR,
+          (i) => this.options?.onError?.(i)
+        ), 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 }), t();
+      });
+    });
+  }
+  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, t, r) {
+    return new Promise((i, n) => {
+      e.load(t, { ...r, callback: i });
+    });
+  }
+  async loadVideo(e) {
+    await L.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, t) => {
+      this.player.getPosition(e);
+    });
+  }
+  async getCurrentTime() {
+    return await this.getCurrentTimeCore() / 1e3;
+  }
+  getVolumeCore() {
+    return new Promise((e, t) => {
+      this.player.getVolume(e);
+    });
+  }
+  async getVolume() {
+    return await this.getVolumeCore() / 100;
+  }
+  getMuted = void 0;
+  getPlaybackRate = void 0;
+}
+class fe extends v {
+  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 ke extends v {
+  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 j = /* @__PURE__ */ ((a) => (a[a.UNSTARTED = -1] = "UNSTARTED", a[a.ENDED = 0] = "ENDED", a[a.PLAYING = 1] = "PLAYING", a[a.PAUSED = 2] = "PAUSED", a[a.BUFFERING = 3] = "BUFFERING", a[a.CUED = 5] = "CUED", a))(j || {});
+class Ne extends v {
+  previousTime;
+  timeUpdateIntervalId;
+  clearTimeUpdateInterval() {
+    this.logger.log(
+      s.Debug,
+      "clearTimeUpdateInterval",
+      this.timeUpdateIntervalId
+    ), window.clearInterval(this.timeUpdateIntervalId), this.timeUpdateIntervalId = void 0;
+  }
+  invokeTimeUpdate(e) {
+    const t = e.getCurrentTime();
+    if (t === this.previousTime) return;
+    const r = e.getDuration();
+    this.options?.onTimeUpdate?.({
+      duration: r,
+      percent: t / r,
+      seconds: t
+    }), this.previousTime = t;
+  }
+  setTimeUpdateInterval() {
+    this.logger.log(s.Debug, "setTimeUpdateInterval"), this.clearTimeUpdateInterval(), this.timeUpdateIntervalId = window.setInterval(
+      () => this.invokeTimeUpdate(this.player),
+      250
+    ), this.logger.log(
+      s.Debug,
+      "timeUpdateIntervalId",
+      this.timeUpdateIntervalId
+    ), this.invokeTimeUpdate(this.player);
+  }
+  attach(e) {
+    return new Promise((t, r) => {
+      this.player.addEventListener("onReady", async () => {
+        this.player.addEventListener(
+          "onError",
+          (i) => this.options?.onError?.(i.data)
+        ), this.player.addEventListener(
+          "onStateChange",
+          (i) => {
+            switch (this.logger.log(
+              s.Debug,
+              `state changed: ${j[i.data]}`
+            ), i.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), t();
+      });
+    });
+  }
+  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();
+  }
 }
-//#endregion
-//#region src/controllers/AudioPlayerController.ts
-var U = class extends i {
-	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;
-	}
-}, W = [
-	"apiready",
-	"seeked",
-	"video_end",
-	"durationchange",
-	"pause",
-	"playing",
-	"error"
-], G = class extends i {
-	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 (let e of W) this.player.addEventListener(e, this.handlePlayerEvents);
-	}
-	async detach() {
-		for (let e of W) 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;
-}, K = /* @__PURE__ */ function(e) {
-	return e[e.Play = 2] = "Play", e[e.Pause = 3] = "Pause", e[e.End = 4] = "End", e;
-}(K || {}), q = class e extends i {
-	static origin = "https://embed.nicovideo.jp";
-	duration = 0;
-	currentTime = 0;
-	volume = 0;
-	muted = !1;
-	handleMessage = (t) => {
-		if (t.origin !== e.origin) return;
-		let n = t.data;
-		switch (n.eventName) {
-			case "playerStatusChange":
-				this.logger.log(r.Debug, `player status changed: ${K[n.data.playerStatus] ?? n.data.playerStatus}`);
-				break;
-			case "statusChange":
-				switch (this.logger.log(r.Debug, `status changed: ${K[n.data.playerStatus] ?? n.data.playerStatus}`), n.data.playerStatus) {
-					case K.Play:
-						this.options?.onPlay?.();
-						break;
-					case K.Pause:
-						this.options?.onPause?.();
-						break;
-					case K.End:
-						this.options?.onEnded?.();
-						break;
-				}
-				break;
-			case "playerMetadataChange":
-				n.data.duration !== void 0 && (this.duration = n.data.duration / 1e3), this.currentTime = n.data.currentTime === void 0 ? 0 : n.data.currentTime / 1e3, this.volume = n.data.volume, this.muted = n.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(r.Debug, "load completed"), this.duration = n.data.videoInfo.lengthInSeconds, this.options?.onLoaded?.({ id: n.data.videoInfo.watchId });
-				break;
-			case "error":
-				this.options?.onError?.(n);
-				break;
-			case "player-error:video:play":
-			case "player-error:video:seek":
-				this.options?.onError?.(n);
-				break;
-			default:
-				this.logger.log(r.Debug, "message", n.eventName, n.data);
-				break;
-		}
-	};
-	async attach() {
-		window.addEventListener("message", this.handleMessage);
-	}
-	async detach() {
-		window.removeEventListener("message", this.handleMessage);
-	}
-	async loadVideo(e) {
-		return new Promise((t, n) => {
-			this.duration = 0, this.currentTime = 0, this.volume = 0, this.muted = !1, this.player.onload = () => {
-				this.player.onload = null, t();
-			}, this.player.src = `https://embed.nicovideo.jp/watch/${e}?jsapi=1&playerId=1`;
-		});
-	}
-	postMessage(t) {
-		this.player.contentWindow?.postMessage({
-			...t,
-			playerId: "1",
-			sourceConnectorType: 1
-		}, e.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;
-}, J = class e extends i {
-	getDurationCore() {
-		return new Promise((e, t) => {
-			this.player.getDuration(e);
-		});
-	}
-	attach(e) {
-		return new Promise((t, n) => {
-			this.player.bind(SC.Widget.Events.READY, () => {
-				this.player.bind(SC.Widget.Events.PLAY_PROGRESS, async (e) => {
-					let t = await this.getDurationCore();
-					this.options?.onTimeUpdate?.({
-						duration: t / 1e3,
-						percent: e.currentPosition / t,
-						seconds: e.currentPosition / 1e3
-					});
-				}), this.player.bind(SC.Widget.Events.ERROR, (e) => this.options?.onError?.(e)), 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 }), t();
-			});
-		});
-	}
-	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, t, n) {
-		return new Promise((r, i) => {
-			e.load(t, {
-				...n,
-				callback: r
-			});
-		});
-	}
-	async loadVideo(t) {
-		await e.playerLoadAsync(this.player, t, { auto_play: !0 }), this.options?.onLoaded?.({ id: t });
-	}
-	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, t) => {
-			this.player.getPosition(e);
-		});
-	}
-	async getCurrentTime() {
-		return await this.getCurrentTimeCore() / 1e3;
-	}
-	getVolumeCore() {
-		return new Promise((e, t) => {
-			this.player.getVolume(e);
-		});
-	}
-	async getVolume() {
-		return await this.getVolumeCore() / 100;
-	}
-	getMuted = void 0;
-	getPlaybackRate = void 0;
-}, Y = class extends i {
-	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;
-}, X = class extends i {
-	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();
-	}
-}, Z = /* @__PURE__ */ function(e) {
-	return e[e.UNSTARTED = -1] = "UNSTARTED", e[e.ENDED = 0] = "ENDED", e[e.PLAYING = 1] = "PLAYING", e[e.PAUSED = 2] = "PAUSED", e[e.BUFFERING = 3] = "BUFFERING", e[e.CUED = 5] = "CUED", e;
-}(Z || {}), Q = class extends i {
-	previousTime;
-	timeUpdateIntervalId;
-	clearTimeUpdateInterval() {
-		this.logger.log(r.Debug, "clearTimeUpdateInterval", this.timeUpdateIntervalId), window.clearInterval(this.timeUpdateIntervalId), this.timeUpdateIntervalId = void 0;
-	}
-	invokeTimeUpdate(e) {
-		let t = e.getCurrentTime();
-		if (t === this.previousTime) return;
-		let n = e.getDuration();
-		this.options?.onTimeUpdate?.({
-			duration: n,
-			percent: t / n,
-			seconds: t
-		}), this.previousTime = t;
-	}
-	setTimeUpdateInterval() {
-		this.logger.log(r.Debug, "setTimeUpdateInterval"), this.clearTimeUpdateInterval(), this.timeUpdateIntervalId = window.setInterval(() => this.invokeTimeUpdate(this.player), 250), this.logger.log(r.Debug, "timeUpdateIntervalId", this.timeUpdateIntervalId), this.invokeTimeUpdate(this.player);
-	}
-	attach(e) {
-		return new Promise((t, n) => {
-			this.player.addEventListener("onReady", async () => {
-				this.player.addEventListener("onError", (e) => this.options?.onError?.(e.data)), this.player.addEventListener("onStateChange", (t) => {
-					switch (this.logger.log(r.Debug, `state changed: ${Z[t.data]}`), t.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), t();
-			});
-		});
-	}
-	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 {
+  De as AudioPlayerController,
+  Ve as DailymotionPlayerController,
+  s as LogLevel,
+  R as NiconicoPlayerController,
+  ye as NostalgicDiva,
+  me as NostalgicDivaElement,
+  J as NostalgicDivaProvider,
+  Te as PlayerContainer,
+  M as PlayerController,
+  v as PlayerControllerImpl,
+  L as SoundCloudPlayerController,
+  fe as TwitchPlayerController,
+  g as VideoService,
+  ke as VimeoPlayerController,
+  Ne as YouTubePlayerController,
+  K as defaultLogger,
+  Pe as defineNostalgicDiva,
+  ue as findVideoService,
+  f as nullPlayerController,
+  he as players,
+  Q as useNostalgicDiva,
+  de as videoServices
 };
-//#endregion
-export { U as AudioPlayerController, G as DailymotionPlayerController, r as LogLevel, q as NiconicoPlayerController, B as NostalgicDiva, V as NostalgicDivaElement, v as NostalgicDivaProvider, o as PlayerContainer, n as PlayerController, i as PlayerControllerImpl, J as SoundCloudPlayerController, Y as TwitchPlayerController, b as VideoService, X as VimeoPlayerController, Q as YouTubePlayerController, a as defaultLogger, H as defineNostalgicDiva, I as findVideoService, e as nullPlayerController, L as players, y as useNostalgicDiva, F as videoServices };
-
-//# sourceMappingURL=index.es.js.map
+//# sourceMappingURL=index.es.js.map