@webitel/ui-sdk 26.2.70 → 26.2.72

package/dist/vidstack-google-cast-C0U2wzqB.js

@@ -0,0 +1,382 @@
+import { b as g, K as n, U as l, o as k, D as u, p as h, l as m, e as y, V as p, L as C } from "./wt-vidstack-player-CA18U-L9.js";
+import { R as E } from "./vidstack-DqAw8m9J-R8izgrMK.js";
+import { g as v, a as L, b as f, h as T, l as S, c as A } from "./vidstack-D2pY00kU-DiDeMWBZ.js";
+class I {
+  #t;
+  constructor(t) {
+    this.#t = new chrome.cast.media.MediaInfo(t.src, t.type);
+  }
+  build() {
+    return this.#t;
+  }
+  setStreamType(t) {
+    return t.includes("live") ? this.#t.streamType = chrome.cast.media.StreamType.LIVE : this.#t.streamType = chrome.cast.media.StreamType.BUFFERED, this;
+  }
+  setTracks(t) {
+    return this.#t.tracks = t.map(this.#e), this;
+  }
+  setMetadata(t, e) {
+    return this.#t.metadata = new chrome.cast.media.GenericMediaMetadata(), this.#t.metadata.title = t, this.#t.metadata.images = [{ url: e }], this;
+  }
+  #e(t, e) {
+    const s = new chrome.cast.media.Track(e, chrome.cast.media.TrackType.TEXT);
+    return s.name = t.label, s.trackContentId = t.src, s.trackContentType = "text/vtt", s.language = t.language, s.subtype = t.kind.toUpperCase(), s;
+  }
+}
+class b {
+  #t;
+  #e;
+  #i;
+  constructor(t, e, s) {
+    this.#t = t, this.#e = e, this.#i = s;
+  }
+  setup() {
+    const t = this.syncRemoteActiveIds.bind(this);
+    m(this.#e.audioTracks, "change", t), m(this.#e.textTracks, "mode-change", t), y(this.#o.bind(this));
+  }
+  getLocalTextTracks() {
+    return this.#e.$state.textTracks().filter((t) => t.src && t.type === "vtt");
+  }
+  #a() {
+    return this.#e.$state.audioTracks();
+  }
+  #r(t) {
+    const e = this.#t.mediaInfo?.tracks ?? [];
+    return t ? e.filter((s) => s.type === t) : e;
+  }
+  #l() {
+    const t = [], e = this.#a().find((i) => i.selected), s = this.getLocalTextTracks().filter((i) => i.mode === "showing");
+    if (e) {
+      const i = this.#r(chrome.cast.media.TrackType.AUDIO), r = this.#d(i, e);
+      r && t.push(r.trackId);
+    }
+    if (s?.length) {
+      const i = this.#r(chrome.cast.media.TrackType.TEXT);
+      if (i.length)
+        for (const r of s) {
+          const a = this.#d(i, r);
+          a && t.push(a.trackId);
+        }
+    }
+    return t;
+  }
+  #o() {
+    const t = this.getLocalTextTracks();
+    if (!this.#t.isMediaLoaded) return;
+    const e = this.#r(chrome.cast.media.TrackType.TEXT);
+    for (const s of t)
+      if (!this.#d(e, s)) {
+        p(() => this.#i?.());
+        break;
+      }
+  }
+  syncRemoteTracks(t) {
+    if (!this.#t.isMediaLoaded) return;
+    const e = this.#a(), s = this.getLocalTextTracks(), i = this.#r(chrome.cast.media.TrackType.AUDIO), r = this.#r(chrome.cast.media.TrackType.TEXT);
+    for (const a of i) {
+      if (this.#h(e, a)) continue;
+      const o = {
+        id: a.trackId.toString(),
+        label: a.name,
+        language: a.language,
+        kind: a.subtype ?? "main",
+        selected: !1
+      };
+      this.#e.audioTracks[C.add](o, t);
+    }
+    for (const a of r) {
+      if (this.#h(s, a)) continue;
+      const o = {
+        id: a.trackId.toString(),
+        src: a.trackContentId,
+        label: a.name,
+        language: a.language,
+        kind: a.subtype.toLowerCase()
+      };
+      this.#e.textTracks.add(o, t);
+    }
+  }
+  syncRemoteActiveIds(t) {
+    if (!this.#t.isMediaLoaded) return;
+    const e = this.#l(), s = new chrome.cast.media.EditTracksInfoRequest(e);
+    this.#c(s).catch((i) => {
+    });
+  }
+  #c(t) {
+    const e = f();
+    return new Promise((s, i) => e?.editTracksInfo(t, s, i));
+  }
+  #h(t, e) {
+    return t.find((s) => this.#s(s, e));
+  }
+  #d(t, e) {
+    return t.find((s) => this.#s(e, s));
+  }
+  // Note: we can't rely on id matching because they will differ between local/remote. A local
+  // track id might not even exist.
+  #s(t, e) {
+    return e.name === t.label && e.language === t.language && e.subtype.toLowerCase() === t.kind.toLowerCase();
+  }
+}
+class D {
+  $$PROVIDER_TYPE = "GOOGLE_CAST";
+  scope = g();
+  #t;
+  #e;
+  #i;
+  #a = null;
+  #r = "disconnected";
+  #l = 0;
+  #o = 0;
+  #c = new n(0, 0);
+  #h = new E(this.#b.bind(this));
+  #d;
+  #s = null;
+  #u = !1;
+  constructor(t, e) {
+    this.#t = t, this.#e = e, this.#i = new b(t, e, this.#G.bind(this));
+  }
+  get type() {
+    return "google-cast";
+  }
+  get currentSrc() {
+    return this.#a;
+  }
+  /**
+   * The Google Cast remote player.
+   *
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.RemotePlayer}
+   */
+  get player() {
+    return this.#t;
+  }
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastContext}
+   */
+  get cast() {
+    return v();
+  }
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastSession}
+   */
+  get session() {
+    return L();
+  }
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/chrome.cast.media.Media}
+   */
+  get media() {
+    return f();
+  }
+  /**
+   * Whether the current Google Cast session belongs to this provider.
+   */
+  get hasActiveSession() {
+    return T(this.#a);
+  }
+  setup() {
+    this.#L(), this.#S(), this.#i.setup(), this.#e.notify("provider-setup", this);
+  }
+  #L() {
+    S(
+      cast.framework.CastContextEventType.CAST_STATE_CHANGED,
+      this.#f.bind(this)
+    );
+  }
+  #S() {
+    const t = cast.framework.RemotePlayerEventType, e = {
+      [t.IS_CONNECTED_CHANGED]: this.#f,
+      [t.IS_MEDIA_LOADED_CHANGED]: this.#g,
+      [t.CAN_CONTROL_VOLUME_CHANGED]: this.#k,
+      [t.CAN_SEEK_CHANGED]: this.#y,
+      [t.DURATION_CHANGED]: this.#D,
+      [t.IS_MUTED_CHANGED]: this.#p,
+      [t.VOLUME_LEVEL_CHANGED]: this.#p,
+      [t.IS_PAUSED_CHANGED]: this.#N,
+      [t.LIVE_SEEKABLE_RANGE_CHANGED]: this.#C,
+      [t.PLAYER_STATE_CHANGED]: this.#P
+    };
+    this.#d = e;
+    const s = this.#R.bind(this);
+    for (const i of l(e))
+      this.#t.controller.addEventListener(i, s);
+    k(() => {
+      for (const i of l(e))
+        this.#t.controller.removeEventListener(i, s);
+    });
+  }
+  async play() {
+    if (!(!this.#t.isPaused && !this.#u)) {
+      if (this.#u) {
+        await this.#v(!1, 0);
+        return;
+      }
+      this.#t.controller?.playOrPause();
+    }
+  }
+  async pause() {
+    this.#t.isPaused || this.#t.controller?.playOrPause();
+  }
+  getMediaStatus(t) {
+    return new Promise((e, s) => {
+      this.media?.getStatus(t, e, s);
+    });
+  }
+  setMuted(t) {
+    (t && !this.#t.isMuted || !t && this.#t.isMuted) && this.#t.controller?.muteOrUnmute();
+  }
+  setCurrentTime(t) {
+    this.#t.currentTime = t, this.#e.notify("seeking", t), this.#t.controller?.seek();
+  }
+  setVolume(t) {
+    this.#t.volumeLevel = t, this.#t.controller?.setVolumeLevel();
+  }
+  async loadSource(t) {
+    if (this.#s?.src !== t && (this.#s = null), T(t)) {
+      this.#A(), this.#a = t;
+      return;
+    }
+    this.#e.notify("load-start");
+    const e = this.#x(t), s = await this.session.loadMedia(e);
+    if (s) {
+      this.#a = null, this.#e.notify("error", Error(A(s)));
+      return;
+    }
+    this.#a = t;
+  }
+  destroy() {
+    this.#m(), this.#T();
+  }
+  #m() {
+    this.#s || (this.#o = 0, this.#c = new n(0, 0)), this.#h.stop(), this.#l = 0, this.#s = null;
+  }
+  #A() {
+    const t = new u("resume-session", { detail: this.session });
+    this.#g(t);
+    const { muted: e, volume: s, savedState: i } = this.#e.$state, r = i();
+    this.setCurrentTime(Math.max(this.#t.currentTime, r?.currentTime ?? 0)), this.setMuted(e()), this.setVolume(s()), r?.paused === !1 && this.play();
+  }
+  #T() {
+    this.cast.endCurrentSession(!0);
+    const { remotePlaybackLoader: t } = this.#e.$state;
+    t.set(null);
+  }
+  #I() {
+    const { savedState: t } = this.#e.$state;
+    t.set({
+      paused: this.#t.isPaused,
+      currentTime: this.#t.currentTime
+    }), this.#T();
+  }
+  #b() {
+    this.#M();
+  }
+  #R(t) {
+    this.#d[t.type].call(this, t);
+  }
+  #f(t) {
+    const e = this.cast.getCastState(), s = e === cast.framework.CastState.CONNECTED ? "connected" : e === cast.framework.CastState.CONNECTING ? "connecting" : "disconnected";
+    if (this.#r === s) return;
+    const i = { type: "google-cast", state: s }, r = this.#n(t);
+    this.#r = s, this.#e.notify("remote-playback-change", i, r), s === "disconnected" && this.#I();
+  }
+  #g(t) {
+    if (!!!this.#t.isMediaLoaded) return;
+    const s = h(this.#e.$state.source);
+    Promise.resolve().then(() => {
+      if (s !== h(this.#e.$state.source) || !this.#t.isMediaLoaded) return;
+      this.#m();
+      const i = this.#t.duration;
+      this.#c = new n(0, i);
+      const r = {
+        provider: this,
+        duration: i,
+        buffered: new n(0, 0),
+        seekable: this.#E()
+      }, a = this.#n(t);
+      this.#e.notify("loaded-metadata", void 0, a), this.#e.notify("loaded-data", void 0, a), this.#e.notify("can-play", r, a), this.#k(), this.#y(t);
+      const { volume: c, muted: o } = this.#e.$state;
+      this.setVolume(c()), this.setMuted(o()), this.#h.start(), this.#i.syncRemoteTracks(a), this.#i.syncRemoteActiveIds(a);
+    });
+  }
+  #k() {
+    this.#e.$state.canSetVolume.set(this.#t.canControlVolume);
+  }
+  #y(t) {
+    const e = this.#n(t);
+    this.#e.notify("stream-type-change", this.#w(), e);
+  }
+  #w() {
+    return this.#t.mediaInfo?.streamType === chrome.cast.media.StreamType.LIVE ? this.#t.canSeek ? "live:dvr" : "live" : "on-demand";
+  }
+  #M() {
+    if (this.#s) return;
+    const t = this.#t.currentTime;
+    t !== this.#l && (this.#e.notify("time-change", t), t > this.#o && (this.#o = t, this.#C()), this.#e.$state.seeking() && this.#e.notify("seeked", t), this.#l = t);
+  }
+  #D(t) {
+    if (!this.#t.isMediaLoaded || this.#s) return;
+    const e = this.#t.duration, s = this.#n(t);
+    this.#c = new n(0, e), this.#e.notify("duration-change", e, s);
+  }
+  #p(t) {
+    if (!this.#t.isMediaLoaded) return;
+    const e = {
+      muted: this.#t.isMuted,
+      volume: this.#t.volumeLevel
+    }, s = this.#n(t);
+    this.#e.notify("volume-change", e, s);
+  }
+  #N(t) {
+    const e = this.#n(t);
+    this.#t.isPaused ? this.#e.notify("pause", void 0, e) : this.#e.notify("play", void 0, e);
+  }
+  #C(t) {
+    const e = {
+      seekable: this.#E(),
+      buffered: new n(0, this.#o)
+    }, s = t ? this.#n(t) : void 0;
+    this.#e.notify("progress", e, s);
+  }
+  #P(t) {
+    const e = this.#t.playerState, s = chrome.cast.media.PlayerState;
+    if (this.#u = e === s.IDLE, e === s.PAUSED) return;
+    const i = this.#n(t);
+    switch (e) {
+      case s.PLAYING:
+        this.#e.notify("playing", void 0, i);
+        break;
+      case s.BUFFERING:
+        this.#e.notify("waiting", void 0, i);
+        break;
+      case s.IDLE:
+        this.#h.stop(), this.#e.notify("pause"), this.#e.notify("end");
+        break;
+    }
+  }
+  #E() {
+    return this.#t.liveSeekableRange ? new n(this.#t.liveSeekableRange.start, this.#t.liveSeekableRange.end) : this.#c;
+  }
+  #n(t) {
+    return t instanceof Event ? t : new u(t.type, { detail: t });
+  }
+  #_(t) {
+    const { streamType: e, title: s, poster: i } = this.#e.$state;
+    return new I(t).setMetadata(s(), i()).setStreamType(e()).setTracks(this.#i.getLocalTextTracks()).build();
+  }
+  #x(t) {
+    const e = this.#_(t), s = new chrome.cast.media.LoadRequest(e), i = this.#e.$state.savedState();
+    return s.autoplay = (this.#s?.paused ?? i?.paused) === !1, s.currentTime = this.#s?.time ?? i?.currentTime ?? 0, s;
+  }
+  async #v(t, e) {
+    const s = h(this.#e.$state.source);
+    this.#s = { src: s, paused: t, time: e }, await this.loadSource(s);
+  }
+  #G() {
+    this.#v(this.#t.isPaused, this.#t.currentTime).catch((t) => {
+    });
+  }
+}
+export {
+  D as GoogleCastProvider
+};

package/dist/vidstack-hls-BZgfDsGk.js

@@ -0,0 +1,309 @@
+import { x as S, f as l, y as E, p as f, Q as v, l as y, e as T, D as d, z as b, T as m, w as g, L as u, A as k, q as L, B as w, C as x, F as D } from "./wt-vidstack-player-CA18U-L9.js";
+import { VideoProvider as C } from "./vidstack-video-CI2rq89j.js";
+import { R as A } from "./vidstack-DqAw8m9J-R8izgrMK.js";
+const I = (r) => b(r);
+class H {
+  #e;
+  #t;
+  #i = null;
+  #n = null;
+  config = {};
+  #r = /* @__PURE__ */ new Set();
+  get instance() {
+    return this.#i;
+  }
+  constructor(t, i) {
+    this.#e = t, this.#t = i;
+  }
+  setup(t) {
+    const { streamType: i } = this.#t.$state, e = f(i).includes("live"), s = f(i).includes("ll-");
+    this.#i = new t({
+      lowLatencyMode: s,
+      backBufferLength: s ? 4 : e ? 8 : void 0,
+      renderTextTracksNatively: !1,
+      ...this.config
+    });
+    const o = this.#h.bind(this);
+    for (const n of Object.values(t.Events)) this.#i.on(n, o);
+    this.#i.on(t.Events.ERROR, this.#v.bind(this));
+    for (const n of this.#r) n(this.#i);
+    this.#t.player.dispatch("hls-instance", {
+      detail: this.#i
+    }), this.#i.attachMedia(this.#e), this.#i.on(t.Events.AUDIO_TRACK_SWITCHED, this.#l.bind(this)), this.#i.on(t.Events.LEVEL_SWITCHED, this.#u.bind(this)), this.#i.on(t.Events.LEVEL_LOADED, this.#f.bind(this)), this.#i.on(t.Events.LEVEL_UPDATED, this.#p.bind(this)), this.#i.on(t.Events.NON_NATIVE_TEXT_TRACKS_FOUND, this.#c.bind(this)), this.#i.on(t.Events.CUES_PARSED, this.#d.bind(this)), this.#t.qualities[v.enableAuto] = this.#g.bind(this), y(this.#t.qualities, "change", this.#L.bind(this)), y(this.#t.audioTracks, "change", this.#S.bind(this)), this.#n = T(this.#o.bind(this));
+  }
+  #s(t, i) {
+    return new d(I(t), { detail: i });
+  }
+  #o() {
+    if (!this.#t.$state.live()) return;
+    const t = new A(this.#a.bind(this));
+    return t.start(), t.stop.bind(t);
+  }
+  #a() {
+    this.#t.$state.liveSyncPosition.set(this.#i?.liveSyncPosition ?? 1 / 0);
+  }
+  #h(t, i) {
+    this.#t.player?.dispatch(this.#s(t, i));
+  }
+  #c(t, i) {
+    const e = this.#s(t, i);
+    let s = -1;
+    for (let o = 0; o < i.tracks.length; o++) {
+      const n = i.tracks[o], h = n.subtitleTrack ?? n.closedCaptions, c = new m({
+        id: `hls-${n.kind}-${o}`,
+        src: h?.url,
+        label: n.label,
+        language: h?.lang,
+        kind: n.kind,
+        default: n.default
+      });
+      c[g.readyState] = 2, c[g.onModeChange] = () => {
+        c.mode === "showing" ? (this.#i.subtitleTrack = o, s = o) : s === o && (this.#i.subtitleTrack = -1, s = -1);
+      }, this.#t.textTracks.add(c, e);
+    }
+  }
+  #d(t, i) {
+    const e = this.#i?.subtitleTrack, s = this.#t.textTracks.getById(`hls-${i.type}-${e}`);
+    if (!s) return;
+    const o = this.#s(t, i);
+    for (const n of i.cues)
+      n.positionAlign = "auto", s.addCue(n, o);
+  }
+  #l(t, i) {
+    const e = this.#t.audioTracks[i.id];
+    if (e) {
+      const s = this.#s(t, i);
+      this.#t.audioTracks[u.select](e, !0, s);
+    }
+  }
+  #u(t, i) {
+    const e = this.#t.qualities[i.level];
+    if (e) {
+      const s = this.#s(t, i);
+      this.#t.qualities[u.select](e, !0, s);
+    }
+  }
+  #p(t, i) {
+    i.details.totalduration > 0 && this.#t.$state.inferredLiveDVRWindow.set(i.details.totalduration);
+  }
+  #f(t, i) {
+    if (this.#t.$state.canPlay()) return;
+    const { type: e, live: s, totalduration: o, targetduration: n } = i.details, h = this.#s(t, i);
+    this.#t.notify(
+      "stream-type-change",
+      s ? e === "EVENT" && Number.isFinite(o) && n >= 10 ? "live:dvr" : "live" : "on-demand",
+      h
+    ), this.#t.notify("duration-change", o, h);
+    const c = this.#i.media;
+    this.#i.currentLevel === -1 && this.#t.qualities[v.setAuto](!0, h);
+    for (const a of this.#i.audioTracks) {
+      const p = {
+        id: a.id.toString(),
+        label: a.name,
+        language: a.lang || "",
+        kind: "main"
+      };
+      this.#t.audioTracks[u.add](p, h);
+    }
+    for (const a of this.#i.levels) {
+      const p = {
+        id: a.id?.toString() ?? a.height + "p",
+        width: a.width,
+        height: a.height,
+        codec: a.codecSet,
+        bitrate: a.bitrate
+      };
+      this.#t.qualities[u.add](p, h);
+    }
+    c.dispatchEvent(new d("canplay", { trigger: h }));
+  }
+  #v(t, i) {
+    i.fatal && (i.type === "mediaError" ? this.#i?.recoverMediaError() : this.#y(i.error));
+  }
+  #y(t) {
+    this.#t.notify("error", {
+      message: t.message,
+      code: 1,
+      error: t
+    });
+  }
+  #g() {
+    this.#i && (this.#i.currentLevel = -1);
+  }
+  #L() {
+    const { qualities: t } = this.#t;
+    !this.#i || t.auto || (this.#i[t.switch + "Level"] = t.selectedIndex, k && (this.#e.currentTime = this.#e.currentTime));
+  }
+  #S() {
+    const { audioTracks: t } = this.#t;
+    this.#i && this.#i.audioTrack !== t.selectedIndex && (this.#i.audioTrack = t.selectedIndex);
+  }
+  onInstance(t) {
+    return this.#r.add(t), () => this.#r.delete(t);
+  }
+  loadSource(t) {
+    l(t.src) && this.#i?.loadSource(t.src);
+  }
+  destroy() {
+    this.#i?.destroy(), this.#i = null, this.#n?.(), this.#n = null;
+  }
+}
+class _ {
+  #e;
+  #t;
+  #i;
+  constructor(t, i, e) {
+    this.#e = t, this.#t = i, this.#i = e, this.#n();
+  }
+  async #n() {
+    const t = {
+      onLoadStart: this.#r.bind(this),
+      onLoaded: this.#s.bind(this),
+      onLoadError: this.#o.bind(this)
+    };
+    let i = await R(this.#e, t);
+    if (L(i) && !l(this.#e) && (i = await $(this.#e, t)), !i) return null;
+    if (!i.isSupported()) {
+      const e = "[vidstack] `hls.js` is not supported in this environment";
+      return this.#t.player.dispatch(new d("hls-unsupported")), this.#t.notify("error", { message: e, code: 4 }), null;
+    }
+    return i;
+  }
+  #r() {
+    this.#t.player.dispatch(new d("hls-lib-load-start"));
+  }
+  #s(t) {
+    this.#t.player.dispatch(
+      new d("hls-lib-loaded", {
+        detail: t
+      })
+    ), this.#i(t);
+  }
+  #o(t) {
+    const i = w(t);
+    this.#t.player.dispatch(
+      new d("hls-lib-load-error", {
+        detail: i
+      })
+    ), this.#t.notify("error", {
+      message: i.message,
+      code: 4,
+      error: i
+    });
+  }
+}
+async function $(r, t = {}) {
+  if (!L(r)) {
+    if (t.onLoadStart?.(), r.prototype && r.prototype !== Function)
+      return t.onLoaded?.(r), r;
+    try {
+      const i = (await r())?.default;
+      if (i && i.isSupported)
+        t.onLoaded?.(i);
+      else
+        throw Error(
+          ""
+        );
+      return i;
+    } catch (i) {
+      t.onLoadError?.(i);
+    }
+  }
+}
+async function R(r, t = {}) {
+  if (l(r)) {
+    t.onLoadStart?.();
+    try {
+      if (await x(r), !D(window.Hls))
+        throw Error(
+          ""
+        );
+      const i = window.Hls;
+      return t.onLoaded?.(i), i;
+    } catch (i) {
+      t.onLoadError?.(i);
+    }
+  }
+}
+const O = "https://cdn.jsdelivr.net";
+class V extends C {
+  $$PROVIDER_TYPE = "HLS";
+  #e = null;
+  #t = new H(this.video, this.ctx);
+  /**
+   * The `hls.js` constructor.
+   */
+  get ctor() {
+    return this.#e;
+  }
+  /**
+   * The current `hls.js` instance.
+   */
+  get instance() {
+    return this.#t.instance;
+  }
+  /**
+   * Whether `hls.js` is supported in this environment.
+   */
+  static supported = S();
+  get type() {
+    return "hls";
+  }
+  get canLiveSync() {
+    return !0;
+  }
+  #i = `${O}/npm/hls.js@^1.5.0/dist/hls.min.js`;
+  /**
+   * The `hls.js` configuration object.
+   *
+   * @see {@link https://github.com/video-dev/hls.js/blob/master/docs/API.md#fine-tuning}
+   */
+  get config() {
+    return this.#t.config;
+  }
+  set config(t) {
+    this.#t.config = t;
+  }
+  /**
+   * The `hls.js` constructor (supports dynamic imports) or a URL of where it can be found.
+   *
+   * @defaultValue `https://cdn.jsdelivr.net/npm/hls.js@^1.0.0/dist/hls.min.js`
+   */
+  get library() {
+    return this.#i;
+  }
+  set library(t) {
+    this.#i = t;
+  }
+  preconnect() {
+    l(this.#i) && E(this.#i);
+  }
+  setup() {
+    super.setup(), new _(this.#i, this.ctx, (t) => {
+      this.#e = t, this.#t.setup(t), this.ctx.notify("provider-setup", this);
+      const i = f(this.ctx.$state.source);
+      i && this.loadSource(i);
+    });
+  }
+  async loadSource(t, i) {
+    if (!l(t.src)) {
+      this.removeSource();
+      return;
+    }
+    this.media.preload = i || "", this.appendSource(t, "application/x-mpegurl"), this.#t.loadSource(t), this.currentSrc = t;
+  }
+  /**
+   * The given callback is invoked when a new `hls.js` instance is created and right before it's
+   * attached to media.
+   */
+  onInstance(t) {
+    const i = this.#t.instance;
+    return i && t(i), this.#t.onInstance(t);
+  }
+  destroy() {
+    this.#t.destroy();
+  }
+}
+export {
+  V as HLSProvider
+};

package/dist/vidstack-krOAtKMi-C50BTxmn.js

@@ -0,0 +1,28 @@
+const p = /(?:https:\/\/)?(?:player\.)?vimeo(?:\.com)?\/(?:video\/)?(\d+)(?:(?:\?hash=|\?h=|\/)(.*))?/, c = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+function u(e) {
+  const n = e.match(p);
+  return { videoId: n?.[1], hash: n?.[2] };
+}
+async function f(e, n, s) {
+  if (c.has(e)) return c.get(e);
+  if (o.has(e)) return o.get(e);
+  let i = `https://vimeo.com/api/oembed.json?url=https://player.vimeo.com/video/${e}`;
+  s && (i = i.concat(`?h=${s}`));
+  const r = window.fetch(i, {
+    mode: "cors",
+    signal: n.signal
+  }).then((t) => t.json()).then((t) => {
+    const a = /vimeocdn.com\/video\/(.*)?_/, h = t?.thumbnail_url?.match(a)?.[1], l = h ? `https://i.vimeocdn.com/video/${h}_1920x1080.webp` : "", m = {
+      title: t?.title ?? "",
+      duration: t?.duration ?? 0,
+      poster: l,
+      pro: t.account_type !== "basic"
+    };
+    return c.set(e, m), m;
+  }).finally(() => o.delete(e));
+  return o.set(e, r), r;
+}
+export {
+  f as getVimeoVideoInfo,
+  u as resolveVimeoVideoId
+};