@locpd/vidstack 1.12.14

package/dev/chunks/vidstack-C-ztJq-f.js

@@ -0,0 +1,109 @@
+import { IS_CHROME, IS_IOS, canGoogleCastSrc } from './vidstack-CjhKISI0.js';
+import { loadScript } from './vidstack-zG6PIeGg.js';
+import { getCastContext, getCastSession, isCastConnected, hasLoadedCastFramework, getCastFrameworkURL, isCastAvailable, getCastErrorMessage, getDefaultCastOptions } from './vidstack-DDwbYVHV.js';
+import { peek } from './vidstack-Bu2kfzUd.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/dev/chunks/vidstack-CFNlaVTR.js

@@ -0,0 +1,55 @@
+import { 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$77, Icon$81, Icon$24, Icon$74, Icon$31, Icon$5 } from './vidstack-Bu2kfzUd.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$81,
+  "seek-backward": Icon$77,
+  "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
+};
+
+export { icons };

package/dev/chunks/vidstack-C_l97D5j.js

@@ -0,0 +1,254 @@
+import { autoUpdate, computePosition, flip, shift } from '@floating-ui/dom';
+import { EventsController, isKeyboardClick, isTouchEvent, scoped, getScope, effect, toggleClass, signal, listenEvent, animationFrameThrottle, isFunction, setAttribute, setStyle, onDispose, isDOMNode, computed } from './vidstack-Bu2kfzUd.js';
+
+function isEventInside(el, event) {
+  const target = event.composedPath()[0];
+  return isDOMNode(target) && el.contains(target);
+}
+const rafJobs = /* @__PURE__ */ new Set();
+{
+  let processJobs = function() {
+    for (const job of rafJobs) {
+      try {
+        job();
+      } catch (e) {
+        console.error(`[vidstack] failed job:
+
+${e}`);
+      }
+    }
+    window.requestAnimationFrame(processJobs);
+  };
+  processJobs();
+}
+function scheduleRafJob(job) {
+  rafJobs.add(job);
+  return () => rafJobs.delete(job);
+}
+function setAttributeIfEmpty(target, name, value) {
+  if (!target.hasAttribute(name)) target.setAttribute(name, value);
+}
+function setARIALabel(target, $label) {
+  if (target.hasAttribute("aria-label") || target.hasAttribute("data-no-label")) return;
+  if (!isFunction($label)) {
+    setAttribute(target, "aria-label", $label);
+    return;
+  }
+  function updateAriaDescription() {
+    setAttribute(target, "aria-label", $label());
+  }
+  effect(updateAriaDescription);
+}
+function isElementVisible(el) {
+  const style = getComputedStyle(el);
+  return style.display !== "none" && parseInt(style.opacity) > 0;
+}
+function checkVisibility(el) {
+  return !!el && ("checkVisibility" in el ? el.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true }) : isElementVisible(el));
+}
+function observeVisibility(el, callback) {
+  return scheduleRafJob(() => callback(checkVisibility(el)));
+}
+function isElementParent(owner, node, test) {
+  while (node) {
+    if (node === owner) {
+      return true;
+    } else if (test?.(node)) {
+      break;
+    } else {
+      node = node.parentElement;
+    }
+  }
+  return false;
+}
+function onPress(target, handler) {
+  return new EventsController(target).add("pointerup", (event) => {
+    if (event.button === 0 && !event.defaultPrevented) handler(event);
+  }).add("keydown", (event) => {
+    if (isKeyboardClick(event)) handler(event);
+  });
+}
+function isTouchPinchEvent(event) {
+  return isTouchEvent(event) && (event.touches.length > 1 || event.changedTouches.length > 1);
+}
+function requestScopedAnimationFrame(callback) {
+  let scope = getScope(), id = window.requestAnimationFrame(() => {
+    scoped(callback, scope);
+    id = -1;
+  });
+  return () => void window.cancelAnimationFrame(id);
+}
+function cloneTemplate(template, length, onCreate) {
+  let current, prev = template, parent = template.parentElement, content = template.content.firstElementChild, elements = [];
+  if (!content && template.firstElementChild) {
+    template.innerHTML = template.firstElementChild.outerHTML;
+    template.firstElementChild.remove();
+    content = template.content.firstElementChild;
+  }
+  if (content?.nodeType !== 1) {
+    throw Error("[vidstack] template must contain root element");
+  }
+  for (let i = 0; i < length; i++) {
+    current = document.importNode(content, true);
+    onCreate?.(current, i);
+    parent.insertBefore(current, prev.nextSibling);
+    elements.push(current);
+    prev = current;
+  }
+  onDispose(() => {
+    for (let i = 0; i < elements.length; i++) elements[i].remove();
+  });
+  return elements;
+}
+function createTemplate(content) {
+  const template = document.createElement("template");
+  template.innerHTML = content;
+  return template.content;
+}
+function cloneTemplateContent(content) {
+  const fragment = content.cloneNode(true);
+  return fragment.firstElementChild;
+}
+function autoPlacement(el, trigger, placement, {
+  offsetVarName,
+  xOffset,
+  yOffset,
+  ...options
+}) {
+  if (!el) return;
+  const floatingPlacement = placement.replace(" ", "-").replace("-center", "");
+  setStyle(el, "visibility", !trigger ? "hidden" : null);
+  if (!trigger) return;
+  let isTop = placement.includes("top");
+  const negateX = (x) => placement.includes("left") ? `calc(-1 * ${x})` : x, negateY = (y) => isTop ? `calc(-1 * ${y})` : y;
+  return autoUpdate(trigger, el, () => {
+    computePosition(trigger, el, {
+      placement: floatingPlacement,
+      middleware: [
+        ...options.middleware ?? [],
+        flip({ fallbackAxisSideDirection: "start", crossAxis: false }),
+        shift()
+      ],
+      ...options
+    }).then(({ x, y, middlewareData }) => {
+      const hasFlipped = !!middlewareData.flip?.index;
+      isTop = placement.includes(hasFlipped ? "bottom" : "top");
+      el.setAttribute(
+        "data-placement",
+        hasFlipped ? placement.startsWith("top") ? placement.replace("top", "bottom") : placement.replace("bottom", "top") : placement
+      );
+      Object.assign(el.style, {
+        top: `calc(${y + "px"} + ${negateY(
+          yOffset ? yOffset + "px" : `var(--${offsetVarName}-y-offset, 0px)`
+        )})`,
+        left: `calc(${x + "px"} + ${negateX(
+          xOffset ? xOffset + "px" : `var(--${offsetVarName}-x-offset, 0px)`
+        )})`
+      });
+    });
+  });
+}
+function hasAnimation(el) {
+  const styles = getComputedStyle(el);
+  return styles.animationName !== "none";
+}
+function createSlot(name) {
+  const slot = document.createElement("slot");
+  slot.name = name;
+  return slot;
+}
+function useTransitionActive($el) {
+  const $active = signal(false);
+  effect(() => {
+    const el = $el();
+    if (!el) return;
+    new EventsController(el).add("transitionstart", () => $active.set(true)).add("transitionend", () => $active.set(false));
+  });
+  return $active;
+}
+function useResizeObserver($el, onResize) {
+  function onElementChange() {
+    const el = $el();
+    if (!el) return;
+    onResize();
+    const observer = new ResizeObserver(animationFrameThrottle(onResize));
+    observer.observe(el);
+    return () => observer.disconnect();
+  }
+  effect(onElementChange);
+}
+function useActive($el) {
+  const $isMouseEnter = useMouseEnter($el), $isFocusedIn = useFocusIn($el);
+  let prevMouseEnter = false;
+  return computed(() => {
+    const isMouseEnter = $isMouseEnter();
+    if (prevMouseEnter && !isMouseEnter) return false;
+    prevMouseEnter = isMouseEnter;
+    return isMouseEnter || $isFocusedIn();
+  });
+}
+function useMouseEnter($el) {
+  const $isMouseEnter = signal(false);
+  effect(() => {
+    const el = $el();
+    if (!el) {
+      $isMouseEnter.set(false);
+      return;
+    }
+    new EventsController(el).add("mouseenter", () => $isMouseEnter.set(true)).add("mouseleave", () => $isMouseEnter.set(false));
+  });
+  return $isMouseEnter;
+}
+function useFocusIn($el) {
+  const $isFocusIn = signal(false);
+  effect(() => {
+    const el = $el();
+    if (!el) {
+      $isFocusIn.set(false);
+      return;
+    }
+    new EventsController(el).add("focusin", () => $isFocusIn.set(true)).add("focusout", () => $isFocusIn.set(false));
+  });
+  return $isFocusIn;
+}
+function isHTMLElement(el) {
+  return el instanceof HTMLElement;
+}
+function useColorSchemePreference() {
+  const colorScheme = signal("dark");
+  const media = window.matchMedia("(prefers-color-scheme: light)");
+  function onChange() {
+    colorScheme.set(media.matches ? "light" : "dark");
+  }
+  onChange();
+  listenEvent(media, "change", onChange);
+  return colorScheme;
+}
+function watchColorScheme(el, colorScheme) {
+  effect(() => {
+    const scheme = colorScheme();
+    if (scheme === "system") {
+      const preference = useColorSchemePreference();
+      effect(() => updateColorScheme(preference()));
+      return;
+    }
+    updateColorScheme(scheme);
+  });
+  function updateColorScheme(scheme) {
+    toggleClass(el, "light", scheme === "light");
+    toggleClass(el, "dark", scheme === "dark");
+  }
+}
+
+function ariaBool(value) {
+  return value ? "true" : "false";
+}
+function $ariaBool(signal) {
+  return () => ariaBool(signal());
+}
+function prefersReducedMotion() {
+  if (typeof window === "undefined") return false;
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+
+export { $ariaBool, autoPlacement, cloneTemplate, cloneTemplateContent, createSlot, createTemplate, hasAnimation, isElementParent, isElementVisible, isEventInside, isHTMLElement, isTouchPinchEvent, observeVisibility, onPress, prefersReducedMotion, requestScopedAnimationFrame, setARIALabel, setAttributeIfEmpty, useActive, useResizeObserver, useTransitionActive, watchColorScheme };

package/dev/chunks/vidstack-CjhKISI0.js

@@ -0,0 +1,114 @@
+import { isFunction, isUndefined, waitTimeout, isString } from './vidstack-Bu2kfzUd.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/dev/chunks/vidstack-CofXIJAy.js

@@ -0,0 +1,57 @@
+import { signal, listenEvent, ViewController, effect, EventsController, setAttribute } from './vidstack-Bu2kfzUd.js';
+
+let $keyboard = signal(false);
+{
+  listenEvent(document, "pointerdown", () => {
+    $keyboard.set(false);
+  });
+  listenEvent(document, "keydown", (e) => {
+    if (e.metaKey || e.altKey || e.ctrlKey) return;
+    $keyboard.set(true);
+  });
+}
+class FocusVisibleController extends ViewController {
+  #focused = signal(false);
+  onConnect(el) {
+    effect(() => {
+      const events = new EventsController(el);
+      if (!$keyboard()) {
+        this.#focused.set(false);
+        updateFocusAttr(el, false);
+        events.add("pointerenter", this.#onPointerEnter.bind(this)).add("pointerleave", this.#onPointerLeave.bind(this));
+        return;
+      }
+      const active = document.activeElement === el;
+      this.#focused.set(active);
+      updateFocusAttr(el, active);
+      events.add("focus", this.#onFocus.bind(this)).add("blur", this.#onBlur.bind(this));
+    });
+  }
+  focused() {
+    return this.#focused();
+  }
+  #onFocus() {
+    this.#focused.set(true);
+    updateFocusAttr(this.el, true);
+  }
+  #onBlur() {
+    this.#focused.set(false);
+    updateFocusAttr(this.el, false);
+  }
+  #onPointerEnter() {
+    updateHoverAttr(this.el, true);
+  }
+  #onPointerLeave() {
+    updateHoverAttr(this.el, false);
+  }
+}
+function updateFocusAttr(el, isFocused) {
+  setAttribute(el, "data-focus", isFocused);
+  setAttribute(el, "data-hocus", isFocused);
+}
+function updateHoverAttr(el, isHovering) {
+  setAttribute(el, "data-hocus", isHovering);
+  setAttribute(el, "data-hover", isHovering);
+}
+
+export { $keyboard, FocusVisibleController };

package/dev/chunks/vidstack-CwTj4H1w.js

@@ -0,0 +1,18 @@
+import { render } from 'lit-html';
+
+class LitElement extends HTMLElement {
+  rootPart = null;
+  connectedCallback() {
+    this.rootPart = render(this.render(), this, {
+      renderBefore: this.firstChild
+    });
+    this.rootPart.setConnected(true);
+  }
+  disconnectedCallback() {
+    this.rootPart?.setConnected(false);
+    this.rootPart = null;
+    render(null, this);
+  }
+}
+
+export { LitElement };

package/dev/chunks/vidstack-DDwbYVHV.js

@@ -0,0 +1,66 @@
+import { listenEvent } from './vidstack-Bu2kfzUd.js';
+
+function getCastFrameworkURL() {
+  return "https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1";
+}
+function hasLoadedCastFramework() {
+  return !!window.cast?.framework;
+}
+function isCastAvailable() {
+  return !!window.chrome?.cast?.isAvailable;
+}
+function isCastConnected() {
+  return getCastContext().getCastState() === cast.framework.CastState.CONNECTED;
+}
+function getCastContext() {
+  return window.cast.framework.CastContext.getInstance();
+}
+function getCastSession() {
+  return getCastContext().getCurrentSession();
+}
+function getCastSessionMedia() {
+  return getCastSession()?.getSessionObj().media[0];
+}
+function hasActiveCastSession(src) {
+  const contentId = getCastSessionMedia()?.media.contentId;
+  return contentId === src?.src;
+}
+function getDefaultCastOptions() {
+  return {
+    language: "en-US",
+    autoJoinPolicy: chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED,
+    receiverApplicationId: chrome.cast.media.DEFAULT_MEDIA_RECEIVER_APP_ID,
+    resumeSavedSession: true,
+    androidReceiverCompatible: true
+  };
+}
+function getCastErrorMessage(code) {
+  const defaultMessage = `Google Cast Error Code: ${code}`;
+  {
+    switch (code) {
+      case chrome.cast.ErrorCode.API_NOT_INITIALIZED:
+        return "The API is not initialized.";
+      case chrome.cast.ErrorCode.CANCEL:
+        return "The operation was canceled by the user";
+      case chrome.cast.ErrorCode.CHANNEL_ERROR:
+        return "A channel to the receiver is not available.";
+      case chrome.cast.ErrorCode.EXTENSION_MISSING:
+        return "The Cast extension is not available.";
+      case chrome.cast.ErrorCode.INVALID_PARAMETER:
+        return "The parameters to the operation were not valid.";
+      case chrome.cast.ErrorCode.RECEIVER_UNAVAILABLE:
+        return "No receiver was compatible with the session request.";
+      case chrome.cast.ErrorCode.SESSION_ERROR:
+        return "A session could not be created, or a session was invalid.";
+      case chrome.cast.ErrorCode.TIMEOUT:
+        return "The operation timed out.";
+      default:
+        return defaultMessage;
+    }
+  }
+}
+function listenCastContextEvent(type, handler) {
+  return listenEvent(getCastContext(), type, handler);
+}
+
+export { getCastContext, getCastErrorMessage, getCastFrameworkURL, getCastSession, getCastSessionMedia, getDefaultCastOptions, hasActiveCastSession, hasLoadedCastFramework, isCastAvailable, isCastConnected, listenCastContextEvent };

package/dev/chunks/vidstack-DFImIcIL.js

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