@hanifhan1f/vidstack 1.12.13 → 1.12.18

package/prod/chunks/vidstack-Fem0yF3c.js

@@ -0,0 +1,77 @@
+import { isArray, isUndefined } from './vidstack-BNpgCJJ1.js';
+
+class TimeRange {
+  #ranges;
+  get length() {
+    return this.#ranges.length;
+  }
+  constructor(start, end) {
+    if (isArray(start)) {
+      this.#ranges = start;
+    } else if (!isUndefined(start) && !isUndefined(end)) {
+      this.#ranges = [[start, end]];
+    } else {
+      this.#ranges = [];
+    }
+  }
+  start(index) {
+    return this.#ranges[index][0] ?? Infinity;
+  }
+  end(index) {
+    return this.#ranges[index][1] ?? Infinity;
+  }
+}
+function getTimeRangesStart(range) {
+  if (!range.length) return null;
+  let min = range.start(0);
+  for (let i = 1; i < range.length; i++) {
+    const value = range.start(i);
+    if (value < min) min = value;
+  }
+  return min;
+}
+function getTimeRangesEnd(range) {
+  if (!range.length) return null;
+  let max = range.end(0);
+  for (let i = 1; i < range.length; i++) {
+    const value = range.end(i);
+    if (value > max) max = value;
+  }
+  return max;
+}
+function normalizeTimeIntervals(intervals) {
+  if (intervals.length <= 1) {
+    return intervals;
+  }
+  intervals.sort((a, b) => a[0] - b[0]);
+  let normalized = [], current = intervals[0];
+  for (let i = 1; i < intervals.length; i++) {
+    const next = intervals[i];
+    if (current[1] >= next[0] - 1) {
+      current = [current[0], Math.max(current[1], next[1])];
+    } else {
+      normalized.push(current);
+      current = next;
+    }
+  }
+  normalized.push(current);
+  return normalized;
+}
+function updateTimeIntervals(intervals, interval, value) {
+  let start = interval[0], end = interval[1];
+  if (value < start) {
+    return [value, -1];
+  } else if (value === start) {
+    return interval;
+  } else if (start === -1) {
+    interval[0] = value;
+    return interval;
+  } else if (value > start) {
+    interval[1] = value;
+    if (end === -1) intervals.push(interval);
+  }
+  normalizeTimeIntervals(intervals);
+  return interval;
+}
+
+export { TimeRange, getTimeRangesEnd, getTimeRangesStart, normalizeTimeIntervals, updateTimeIntervals };

package/prod/chunks/vidstack-IDWYvfna.js

@@ -0,0 +1,58 @@
+import { signal, listenEvent, effect, peek, isString } from './vidstack-BNpgCJJ1.js';
+import { appendParamsToURL } from './vidstack-V1jwkH0s.js';
+
+class EmbedProvider {
+  #iframe;
+  src = signal("");
+  /**
+   * Defines which referrer is sent when fetching the resource.
+   *
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement/referrerPolicy}
+   */
+  referrerPolicy = null;
+  get iframe() {
+    return this.#iframe;
+  }
+  constructor(iframe) {
+    this.#iframe = iframe;
+    iframe.setAttribute("frameBorder", "0");
+    iframe.setAttribute("aria-hidden", "true");
+    iframe.setAttribute(
+      "allow",
+      "autoplay; fullscreen; encrypted-media; picture-in-picture; accelerometer; gyroscope"
+    );
+    if (this.referrerPolicy !== null) {
+      iframe.setAttribute("referrerpolicy", this.referrerPolicy);
+    }
+  }
+  setup() {
+    listenEvent(window, "message", this.#onWindowMessage.bind(this));
+    listenEvent(this.#iframe, "load", this.onLoad.bind(this));
+    effect(this.#watchSrc.bind(this));
+  }
+  #watchSrc() {
+    const src = this.src();
+    if (!src.length) {
+      this.#iframe.setAttribute("src", "");
+      return;
+    }
+    const params = peek(() => this.buildParams());
+    this.#iframe.setAttribute("src", appendParamsToURL(src, params));
+  }
+  postMessage(message, target) {
+    this.#iframe.contentWindow?.postMessage(JSON.stringify(message), target ?? "*");
+  }
+  #onWindowMessage(event) {
+    const origin = this.getOrigin(), isOriginMatch = (event.source === null || event.source === this.#iframe?.contentWindow) && (!isString(origin) || origin === event.origin);
+    if (!isOriginMatch) return;
+    try {
+      const message = JSON.parse(event.data);
+      if (message) this.onMessage(message, event);
+      return;
+    } catch (e) {
+    }
+    if (event.data) this.onMessage(event.data, event);
+  }
+}
+
+export { EmbedProvider };

package/prod/chunks/vidstack-MbEMbVfP.js

@@ -0,0 +1,109 @@
+import { IS_CHROME, IS_IOS, canGoogleCastSrc } from './vidstack-bdt7uOlN.js';
+import { loadScript } from './vidstack-V1jwkH0s.js';
+import { getCastContext, getCastSession, isCastConnected, hasLoadedCastFramework, getCastFrameworkURL, isCastAvailable, getCastErrorMessage, getDefaultCastOptions } from './vidstack-9_r3lWNO.js';
+import { peek } from './vidstack-BNpgCJJ1.js';
+
+class GoogleCastLoader {
+  name = "google-cast";
+  target;
+  #player;
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastContext}
+   */
+  get cast() {
+    return getCastContext();
+  }
+  mediaType() {
+    return "video";
+  }
+  canPlay(src) {
+    return IS_CHROME && !IS_IOS && canGoogleCastSrc(src);
+  }
+  async prompt(ctx) {
+    let loadEvent, openEvent, errorEvent;
+    try {
+      loadEvent = await this.#loadCastFramework(ctx);
+      if (!this.#player) {
+        this.#player = new cast.framework.RemotePlayer();
+        new cast.framework.RemotePlayerController(this.#player);
+      }
+      openEvent = ctx.player.createEvent("google-cast-prompt-open", {
+        trigger: loadEvent
+      });
+      ctx.player.dispatchEvent(openEvent);
+      this.#notifyRemoteStateChange(ctx, "connecting", openEvent);
+      await this.#showPrompt(peek(ctx.$props.googleCast));
+      ctx.$state.remotePlaybackInfo.set({
+        deviceName: getCastSession()?.getCastDevice().friendlyName
+      });
+      if (isCastConnected()) this.#notifyRemoteStateChange(ctx, "connected", openEvent);
+    } catch (code) {
+      const error = code instanceof Error ? code : this.#createError(
+        (code + "").toUpperCase(),
+        "Prompt failed."
+      );
+      errorEvent = ctx.player.createEvent("google-cast-prompt-error", {
+        detail: error,
+        trigger: openEvent ?? loadEvent,
+        cancelable: true
+      });
+      ctx.player.dispatch(errorEvent);
+      this.#notifyRemoteStateChange(
+        ctx,
+        isCastConnected() ? "connected" : "disconnected",
+        errorEvent
+      );
+      throw error;
+    } finally {
+      ctx.player.dispatch("google-cast-prompt-close", {
+        trigger: errorEvent ?? openEvent ?? loadEvent
+      });
+    }
+  }
+  async load(ctx) {
+    if (!this.#player) {
+      throw Error("[vidstack] google cast player was not initialized");
+    }
+    return new (await import('../providers/vidstack-google-cast.js')).GoogleCastProvider(this.#player, ctx);
+  }
+  async #loadCastFramework(ctx) {
+    if (hasLoadedCastFramework()) return;
+    const loadStartEvent = ctx.player.createEvent("google-cast-load-start");
+    ctx.player.dispatch(loadStartEvent);
+    await loadScript(getCastFrameworkURL());
+    await customElements.whenDefined("google-cast-launcher");
+    const loadedEvent = ctx.player.createEvent("google-cast-loaded", { trigger: loadStartEvent });
+    ctx.player.dispatch(loadedEvent);
+    if (!isCastAvailable()) {
+      throw this.#createError("CAST_NOT_AVAILABLE", "Google Cast not available on this platform.");
+    }
+    return loadedEvent;
+  }
+  async #showPrompt(options) {
+    this.#setOptions(options);
+    const errorCode = await this.cast.requestSession();
+    if (errorCode) {
+      throw this.#createError(
+        errorCode.toUpperCase(),
+        getCastErrorMessage(errorCode)
+      );
+    }
+  }
+  #setOptions(options) {
+    this.cast?.setOptions({
+      ...getDefaultCastOptions(),
+      ...options
+    });
+  }
+  #notifyRemoteStateChange(ctx, state, trigger) {
+    const detail = { type: "google-cast", state };
+    ctx.notify("remote-playback-change", detail, trigger);
+  }
+  #createError(code, message) {
+    const error = Error(message);
+    error.code = code;
+    return error;
+  }
+}
+
+export { GoogleCastLoader };

package/prod/chunks/vidstack-Oq65llxr.js

@@ -0,0 +1,29 @@
+import { Icon$24, effect } from './vidstack-BNpgCJJ1.js';
+import { cloneTemplateContent, createTemplate } from './vidstack-DB9WDRL5.js';
+import '@floating-ui/dom';
+
+const svgTemplate = /* @__PURE__ */ createTemplate(
+  `<svg viewBox="0 0 32 32" fill="none" aria-hidden="true" xmlns="http://www.w3.org/2000/svg"></svg>`
+);
+function insertContent(container, $state) {
+  const icon = cloneTemplateContent(svgTemplate);
+  icon.innerHTML = Icon$24;
+  container.append(icon);
+  const text = document.createElement("span");
+  text.classList.add("vds-google-cast-info");
+  container.append(text);
+  const deviceName = document.createElement("span");
+  deviceName.classList.add("vds-google-cast-device-name");
+  effect(() => {
+    const { remotePlaybackInfo } = $state, info = remotePlaybackInfo();
+    if (info?.deviceName) {
+      deviceName.textContent = info.deviceName;
+      text.append("Google Cast on ", deviceName);
+    }
+    return () => {
+      text.textContent = "";
+    };
+  });
+}
+
+export { insertContent };

package/prod/chunks/vidstack-SnIdjCkV.js

@@ -0,0 +1,58 @@
+import { signal, effect, listenEvent, EventsController } from './vidstack-BNpgCJJ1.js';
+import './vidstack-bdt7uOlN.js';
+
+class HTMLRemotePlaybackAdapter {
+  #media;
+  #ctx;
+  #state;
+  #supported = signal(false);
+  get supported() {
+    return this.#supported();
+  }
+  constructor(media, ctx) {
+    this.#media = media;
+    this.#ctx = ctx;
+    this.#setup();
+  }
+  #setup() {
+    if (!this.#media?.remote || !this.canPrompt) return;
+    this.#media.remote.watchAvailability((available) => {
+      this.#supported.set(available);
+    }).catch(() => {
+      this.#supported.set(false);
+    });
+    effect(this.#watchSupported.bind(this));
+  }
+  #watchSupported() {
+    if (!this.#supported()) return;
+    const events = ["connecting", "connect", "disconnect"], onStateChange = this.#onStateChange.bind(this);
+    onStateChange();
+    listenEvent(this.#media, "playing", onStateChange);
+    const remoteEvents = new EventsController(this.#media.remote);
+    for (const type of events) {
+      remoteEvents.add(type, onStateChange);
+    }
+  }
+  async prompt() {
+    if (!this.supported) throw Error("Not supported on this platform.");
+    if (this.type === "airplay" && this.#media.webkitShowPlaybackTargetPicker) {
+      return this.#media.webkitShowPlaybackTargetPicker();
+    }
+    return this.#media.remote.prompt();
+  }
+  #onStateChange(event) {
+    const state = this.#media.remote.state;
+    if (state === this.#state) return;
+    const detail = { type: this.type, state };
+    this.#ctx.notify("remote-playback-change", detail, event);
+    this.#state = state;
+  }
+}
+class HTMLAirPlayAdapter extends HTMLRemotePlaybackAdapter {
+  type = "airplay";
+  get canPrompt() {
+    return "WebKitPlaybackTargetAvailabilityEvent" in window;
+  }
+}
+
+export { HTMLAirPlayAdapter };

package/prod/chunks/vidstack-V1jwkH0s.js

@@ -0,0 +1,66 @@
+import { isNull, isString, deferredPromise, isBoolean } from './vidstack-BNpgCJJ1.js';
+import { isAudioSrc, isVideoSrc } from './vidstack-bdt7uOlN.js';
+
+function appendParamsToURL(baseUrl, params) {
+  const url = new URL(baseUrl);
+  for (const key of Object.keys(params)) {
+    url.searchParams.set(key, params[key] + "");
+  }
+  return url.toString();
+}
+function preconnect(url, rel = "preconnect") {
+  const exists = document.querySelector(`link[href="${url}"]`);
+  if (!isNull(exists)) return true;
+  const link = document.createElement("link");
+  link.rel = rel;
+  link.href = url;
+  link.crossOrigin = "true";
+  document.head.append(link);
+  return true;
+}
+const pendingRequests = {};
+function loadScript(src) {
+  if (pendingRequests[src]) return pendingRequests[src].promise;
+  const promise = deferredPromise(), exists = document.querySelector(`script[src="${src}"]`);
+  if (!isNull(exists)) {
+    promise.resolve();
+    return promise.promise;
+  }
+  pendingRequests[src] = promise;
+  const script = document.createElement("script");
+  script.src = src;
+  script.onload = () => {
+    promise.resolve();
+    delete pendingRequests[src];
+  };
+  script.onerror = () => {
+    promise.reject();
+    delete pendingRequests[src];
+  };
+  setTimeout(() => document.head.append(script), 0);
+  return promise.promise;
+}
+function getRequestCredentials(crossOrigin) {
+  return crossOrigin === "use-credentials" ? "include" : isString(crossOrigin) ? "same-origin" : void 0;
+}
+function getDownloadFile({
+  title,
+  src,
+  download
+}) {
+  const url = isBoolean(download) || download === "" ? src.src : isString(download) ? download : download?.url;
+  if (!isValidFileDownload({ url, src, download })) return null;
+  return {
+    url,
+    name: !isBoolean(download) && !isString(download) && download?.filename || title.toLowerCase() || "media"
+  };
+}
+function isValidFileDownload({
+  url,
+  src,
+  download
+}) {
+  return isString(url) && (download && download !== true || isAudioSrc(src) || isVideoSrc(src));
+}
+
+export { appendParamsToURL, getDownloadFile, getRequestCredentials, loadScript, preconnect };

package/prod/chunks/vidstack-bdt7uOlN.js

@@ -0,0 +1,114 @@
+import { isFunction, isUndefined, waitTimeout, isString } from './vidstack-BNpgCJJ1.js';
+
+const UA = navigator?.userAgent.toLowerCase() || "";
+const IS_IOS = /iphone|ipad|ipod|ios|crios|fxios/i.test(UA);
+const IS_IPHONE = /(iphone|ipod)/gi.test(navigator?.platform || "");
+const IS_CHROME = !!window.chrome;
+const IS_SAFARI = !!window.safari || IS_IOS;
+function canOrientScreen() {
+  return canRotateScreen() && isFunction(screen.orientation.unlock);
+}
+function canRotateScreen() {
+  return !isUndefined(window.screen.orientation) && !isUndefined(window.screen.orientation.lock);
+}
+function canPlayAudioType(audio, type) {
+  if (!audio) audio = document.createElement("audio");
+  return audio.canPlayType(type).length > 0;
+}
+function canPlayVideoType(video, type) {
+  if (!video) video = document.createElement("video");
+  return video.canPlayType(type).length > 0;
+}
+function canPlayHLSNatively(video) {
+  if (!video) video = document.createElement("video");
+  return video.canPlayType("application/vnd.apple.mpegurl").length > 0;
+}
+function canUsePictureInPicture(video) {
+  return !!document.pictureInPictureEnabled && !video?.disablePictureInPicture;
+}
+function canUseVideoPresentation(video) {
+  return isFunction(video?.webkitSupportsPresentationMode) && isFunction(video?.webkitSetPresentationMode);
+}
+async function canChangeVolume() {
+  const video = document.createElement("video");
+  video.volume = 0.5;
+  await waitTimeout(0);
+  return video.volume === 0.5;
+}
+function getMediaSource() {
+  return window?.ManagedMediaSource ?? window?.MediaSource ?? window?.WebKitMediaSource;
+}
+function getSourceBuffer() {
+  return window?.SourceBuffer ?? window?.WebKitSourceBuffer;
+}
+function isHLSSupported() {
+  const MediaSource = getMediaSource();
+  if (isUndefined(MediaSource)) return false;
+  const isTypeSupported = MediaSource && isFunction(MediaSource.isTypeSupported) && MediaSource.isTypeSupported('video/mp4; codecs="avc1.42E01E,mp4a.40.2"');
+  const SourceBuffer = getSourceBuffer();
+  const isSourceBufferValid = isUndefined(SourceBuffer) || !isUndefined(SourceBuffer.prototype) && isFunction(SourceBuffer.prototype.appendBuffer) && isFunction(SourceBuffer.prototype.remove);
+  return !!isTypeSupported && !!isSourceBufferValid;
+}
+function isDASHSupported() {
+  return isHLSSupported();
+}
+
+const AUDIO_EXTENSIONS = /\.(m4a|m4b|mp4a|mpga|mp2|mp2a|mp3|m2a|m3a|wav|weba|aac|oga|spx|flac)($|\?)/i;
+const AUDIO_TYPES = /* @__PURE__ */ new Set([
+  "audio/mpeg",
+  "audio/ogg",
+  "audio/3gp",
+  "audio/mp3",
+  "audio/webm",
+  "audio/flac",
+  "audio/m4a",
+  "audio/m4b",
+  "audio/mp4a",
+  "audio/mp4"
+]);
+const VIDEO_EXTENSIONS = /\.(mp4|og[gv]|webm|mov|m4v)(#t=[,\d+]+)?($|\?)/i;
+const VIDEO_TYPES = /* @__PURE__ */ new Set([
+  "video/mp4",
+  "video/webm",
+  "video/3gp",
+  "video/ogg",
+  "video/avi",
+  "video/mpeg"
+]);
+const HLS_VIDEO_EXTENSIONS = /\.(m3u8)($|\?)/i;
+const DASH_VIDEO_EXTENSIONS = /\.(mpd)($|\?)/i;
+const HLS_VIDEO_TYPES = /* @__PURE__ */ new Set([
+  // Apple sanctioned
+  "application/vnd.apple.mpegurl",
+  // Apple sanctioned for backwards compatibility
+  "audio/mpegurl",
+  // Very common
+  "audio/x-mpegurl",
+  // Very common
+  "application/x-mpegurl",
+  // Included for completeness
+  "video/x-mpegurl",
+  "video/mpegurl",
+  "application/mpegurl"
+]);
+const DASH_VIDEO_TYPES = /* @__PURE__ */ new Set(["application/dash+xml"]);
+function isAudioSrc({ src, type }) {
+  return isString(src) ? AUDIO_EXTENSIONS.test(src) || AUDIO_TYPES.has(type) || src.startsWith("blob:") && type === "audio/object" : type === "audio/object";
+}
+function isVideoSrc(src) {
+  return isString(src.src) ? VIDEO_EXTENSIONS.test(src.src) || VIDEO_TYPES.has(src.type) || src.src.startsWith("blob:") && src.type === "video/object" || isHLSSrc(src) && canPlayHLSNatively() : src.type === "video/object";
+}
+function isHLSSrc({ src, type }) {
+  return isString(src) && HLS_VIDEO_EXTENSIONS.test(src) || HLS_VIDEO_TYPES.has(type);
+}
+function isDASHSrc({ src, type }) {
+  return isString(src) && DASH_VIDEO_EXTENSIONS.test(src) || DASH_VIDEO_TYPES.has(type);
+}
+function canGoogleCastSrc(src) {
+  return isString(src.src) && (isAudioSrc(src) || isVideoSrc(src) || isHLSSrc(src));
+}
+function isMediaStream(src) {
+  return typeof window.MediaStream !== "undefined" && src instanceof window.MediaStream;
+}
+
+export { AUDIO_EXTENSIONS, AUDIO_TYPES, DASH_VIDEO_EXTENSIONS, DASH_VIDEO_TYPES, HLS_VIDEO_EXTENSIONS, HLS_VIDEO_TYPES, IS_CHROME, IS_IOS, IS_IPHONE, IS_SAFARI, VIDEO_EXTENSIONS, VIDEO_TYPES, canChangeVolume, canGoogleCastSrc, canOrientScreen, canPlayAudioType, canPlayHLSNatively, canPlayVideoType, canRotateScreen, canUsePictureInPicture, canUseVideoPresentation, isAudioSrc, isDASHSrc, isDASHSupported, isHLSSrc, isHLSSupported, isMediaStream, isVideoSrc };

package/prod/chunks/vidstack-krOAtKMi.js

@@ -0,0 +1,32 @@
+const videoIdRE = /(?:https:\/\/)?(?:player\.)?vimeo(?:\.com)?\/(?:video\/)?(\d+)(?:(?:\?hash=|\?h=|\/)(.*))?/;
+const infoCache = /* @__PURE__ */ new Map();
+const pendingFetch = /* @__PURE__ */ new Map();
+function resolveVimeoVideoId(src) {
+  const matches = src.match(videoIdRE);
+  return { videoId: matches?.[1], hash: matches?.[2] };
+}
+async function getVimeoVideoInfo(videoId, abort, videoHash) {
+  if (infoCache.has(videoId)) return infoCache.get(videoId);
+  if (pendingFetch.has(videoId)) return pendingFetch.get(videoId);
+  let oembedSrc = `https://vimeo.com/api/oembed.json?url=https://player.vimeo.com/video/${videoId}`;
+  if (videoHash) {
+    oembedSrc = oembedSrc.concat(`?h=${videoHash}`);
+  }
+  const promise = window.fetch(oembedSrc, {
+    mode: "cors",
+    signal: abort.signal
+  }).then((response) => response.json()).then((data) => {
+    const thumnailRegex = /vimeocdn.com\/video\/(.*)?_/, thumbnailId = data?.thumbnail_url?.match(thumnailRegex)?.[1], poster = thumbnailId ? `https://i.vimeocdn.com/video/${thumbnailId}_1920x1080.webp` : "", info = {
+      title: data?.title ?? "",
+      duration: data?.duration ?? 0,
+      poster,
+      pro: data.account_type !== "basic"
+    };
+    infoCache.set(videoId, info);
+    return info;
+  }).finally(() => pendingFetch.delete(videoId));
+  pendingFetch.set(videoId, promise);
+  return promise;
+}
+
+export { getVimeoVideoInfo, resolveVimeoVideoId };

package/prod/chunks/vidstack-mxJIo4Sg.js

@@ -0,0 +1,56 @@
+import { Icon$32, Icon$34, Icon$35, Icon$27, Icon$26, Icon$60, Icon$61, Icon$39, Icon$40, Icon$105, Icon$104, Icon$54, Icon$59, Icon$62, Icon$56, Icon$33, Icon$8, Icon$13, Icon$19, Icon$63, Icon$53, Icon$0, Icon$22, Icon$11, Icon$88, Icon$16, Icon$24, Icon$74, Icon$31, Icon$5 } from './vidstack-BNpgCJJ1.js';
+
+const icons = {
+  airplay: Icon$5,
+  download: Icon$31,
+  play: Icon$62,
+  pause: Icon$59,
+  replay: Icon$74,
+  mute: Icon$54,
+  "google-cast": Icon$24,
+  "volume-low": Icon$105,
+  "volume-high": Icon$104,
+  "cc-on": Icon$26,
+  "cc-off": Icon$27,
+  "pip-enter": Icon$61,
+  "pip-exit": Icon$60,
+  "fs-enter": Icon$40,
+  "fs-exit": Icon$39,
+  "seek-forward": Icon$35,
+  "seek-backward": Icon$34,
+  "menu-chapters": Icon$16,
+  "menu-settings": Icon$88,
+  "menu-arrow-left": Icon$11,
+  "menu-arrow-right": Icon$22,
+  "menu-accessibility": Icon$0,
+  "menu-audio": Icon$53,
+  "menu-audio-boost-up": Icon$104,
+  "menu-audio-boost-down": Icon$105,
+  "menu-playback": Icon$63,
+  "menu-speed-up": Icon$35,
+  "menu-speed-down": Icon$34,
+  "menu-captions": Icon$27,
+  "menu-quality-up": Icon$13,
+  "menu-quality-down": Icon$8,
+  "menu-radio-check": Icon$19,
+  "menu-font-size-up": Icon$13,
+  "menu-font-size-down": Icon$8,
+  "menu-opacity-up": Icon$33,
+  "menu-opacity-down": Icon$56,
+  "kb-play": Icon$62,
+  "kb-pause": Icon$59,
+  "kb-mute": Icon$54,
+  "kb-volume-up": Icon$104,
+  "kb-volume-down": Icon$105,
+  "kb-fs-enter": Icon$40,
+  "kb-fs-exit": Icon$39,
+  "kb-pip-enter": Icon$61,
+  "kb-pip-exit": Icon$60,
+  "kb-cc-on": Icon$26,
+  "kb-cc-off": Icon$27,
+  "kb-seek-forward": Icon$35,
+  "kb-seek-backward": Icon$34,
+  "menu-episodes": Icon$32
+};
+
+export { icons };

package/prod/chunks/vidstack-tt3O1zL6.js

@@ -0,0 +1,11 @@
+import { useContext, createContext } from './vidstack-BNpgCJJ1.js';
+
+const mediaContext = createContext();
+function useMediaContext() {
+  return useContext(mediaContext);
+}
+function useMediaState() {
+  return useMediaContext().$state;
+}
+
+export { mediaContext, useMediaContext, useMediaState };