@hanifhan1f/vidstack 1.12.25 → 1.12.27

package/server/chunks/vidstack-NpAD9hfP.js

@@ -0,0 +1,620 @@
+import { isString, deferredPromise, isNull, isBoolean, listenEvent, scoped, getScope, EventsTarget, DOMEvent, isArray, isNumber, useContext, createContext, EventsController, isKeyboardClick, isTouchEvent, effect, isFunction, setAttribute, setStyle, isDOMNode, onDispose, toggleClass, animationFrameThrottle, signal, computed } from './vidstack-B8LynzY5.js';
+import { autoUpdate, computePosition, flip, shift } from '@floating-ui/dom';
+
+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) && true : 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 false;
+}
+
+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") {
+  return false;
+}
+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));
+}
+
+const CROSS_ORIGIN = Symbol(0), READY_STATE = Symbol(0), UPDATE_ACTIVE_CUES = Symbol(0), CAN_LOAD = Symbol(0), ON_MODE_CHANGE = Symbol(0), NATIVE = Symbol(0), NATIVE_HLS = Symbol(0);
+const TextTrackSymbol = {
+  crossOrigin: CROSS_ORIGIN,
+  readyState: READY_STATE,
+  updateActiveCues: UPDATE_ACTIVE_CUES,
+  canLoad: CAN_LOAD,
+  onModeChange: ON_MODE_CHANGE,
+  native: NATIVE,
+  nativeHLS: NATIVE_HLS
+};
+
+function findActiveCue(cues, time) {
+  for (let i = 0, len = cues.length; i < len; i++) {
+    if (isCueActive(cues[i], time)) return cues[i];
+  }
+  return null;
+}
+function isCueActive(cue, time) {
+  return time >= cue.startTime && time < cue.endTime;
+}
+function watchActiveTextTrack(tracks, kind, onChange) {
+  let currentTrack = null, scope = getScope();
+  function onModeChange() {
+    const kinds = isString(kind) ? [kind] : kind, track = tracks.toArray().find((track2) => kinds.includes(track2.kind) && track2.mode === "showing");
+    if (track === currentTrack) return;
+    if (!track) {
+      onChange(null);
+      currentTrack = null;
+      return;
+    }
+    if (track.readyState == 2) {
+      onChange(track);
+    } else {
+      onChange(null);
+      scoped(() => {
+      }, scope);
+    }
+    currentTrack = track;
+  }
+  onModeChange();
+  return listenEvent();
+}
+function watchCueTextChange(tracks, kind, callback) {
+  watchActiveTextTrack(tracks, kind, (track) => {
+    if (!track) {
+      callback("");
+      return;
+    }
+    const onCueChange = () => {
+      const activeCue = track?.activeCues[0];
+      callback(activeCue?.text || "");
+    };
+    onCueChange();
+  });
+}
+
+class TextTrack extends EventsTarget {
+  static createId(track) {
+    return `vds-${track.type}-${track.kind}-${track.src ?? track.label ?? "?"}`;
+  }
+  src;
+  content;
+  type;
+  encoding;
+  id = "";
+  label = "";
+  language = "";
+  kind;
+  default = false;
+  #canLoad = false;
+  #currentTime = 0;
+  #mode = "disabled";
+  #metadata = {};
+  #regions = [];
+  #cues = [];
+  #activeCues = [];
+  #cueIds = /* @__PURE__ */ new Set();
+  /** @internal */
+  [TextTrackSymbol.readyState] = 0;
+  /** @internal */
+  [TextTrackSymbol.crossOrigin];
+  /** @internal */
+  [TextTrackSymbol.onModeChange] = null;
+  /** @internal */
+  [TextTrackSymbol.native] = null;
+  get metadata() {
+    return this.#metadata;
+  }
+  get regions() {
+    return this.#regions;
+  }
+  get cues() {
+    return this.#cues;
+  }
+  get activeCues() {
+    return this.#activeCues;
+  }
+  /**
+   * - 0: Not Loading
+   * - 1: Loading
+   * - 2: Ready
+   * - 3: Error
+   */
+  get readyState() {
+    return this[TextTrackSymbol.readyState];
+  }
+  get mode() {
+    return this.#mode;
+  }
+  set mode(mode) {
+    this.setMode(mode);
+  }
+  constructor(init) {
+    super();
+    for (const prop of Object.keys(init)) this[prop] = init[prop];
+    if (!this.type) this.type = "vtt";
+    if (!init.src) {
+      this[TextTrackSymbol.readyState] = 2;
+    }
+  }
+  addCue(cue, trigger) {
+    if (cue.id) {
+      if (this.#cueIds.has(cue.id)) return;
+      this.#cueIds.add(cue.id);
+    }
+    let i = 0, length = this.#cues.length;
+    for (i = 0; i < length; i++) if (cue.endTime <= this.#cues[i].startTime) break;
+    if (i === length) this.#cues.push(cue);
+    else this.#cues.splice(i, 0, cue);
+    if (!(cue instanceof TextTrackCue)) {
+      this[TextTrackSymbol.native]?.track.addCue(cue);
+    }
+    this.dispatchEvent(new DOMEvent("add-cue", { detail: cue, trigger }));
+    if (isCueActive(cue, this.#currentTime)) {
+      this[TextTrackSymbol.updateActiveCues](this.#currentTime, trigger);
+    }
+  }
+  removeCue(cue, trigger) {
+    const index = this.#cues.indexOf(cue);
+    if (index >= 0) {
+      const isActive = this.#activeCues.includes(cue);
+      if (cue.id) this.#cueIds.delete(cue.id);
+      this.#cues.splice(index, 1);
+      this[TextTrackSymbol.native]?.track.removeCue(cue);
+      this.dispatchEvent(new DOMEvent("remove-cue", { detail: cue, trigger }));
+      if (isActive) {
+        this[TextTrackSymbol.updateActiveCues](this.#currentTime, trigger);
+      }
+    }
+  }
+  setMode(mode, trigger) {
+    if (this.#mode === mode) return;
+    this.#mode = mode;
+    if (mode === "disabled") {
+      this.#activeCues = [];
+      this.#activeCuesChanged();
+    } else if (this.readyState === 2) {
+      this[TextTrackSymbol.updateActiveCues](this.#currentTime, trigger);
+    } else {
+      this.#load();
+    }
+    this.dispatchEvent(new DOMEvent("mode-change", { detail: this, trigger }));
+    this[TextTrackSymbol.onModeChange]?.();
+  }
+  /** @internal */
+  [TextTrackSymbol.updateActiveCues](currentTime, trigger) {
+    this.#currentTime = currentTime;
+    if (this.mode === "disabled" || !this.#cues.length) return;
+    const activeCues = [];
+    for (let i = 0, length = this.#cues.length; i < length; i++) {
+      const cue = this.#cues[i];
+      if (isCueActive(cue, currentTime)) activeCues.push(cue);
+    }
+    let changed = activeCues.length !== this.#activeCues.length;
+    if (!changed) {
+      for (let i = 0; i < activeCues.length; i++) {
+        if (!this.#activeCues.includes(activeCues[i])) {
+          changed = true;
+          break;
+        }
+      }
+    }
+    this.#activeCues = activeCues;
+    if (changed) this.#activeCuesChanged(trigger);
+  }
+  /** @internal */
+  [TextTrackSymbol.canLoad]() {
+    this.#canLoad = true;
+    if (this.#mode !== "disabled") this.#load();
+  }
+  #parseContent(init) {
+    import('media-captions').then(({ parseText, VTTCue, VTTRegion }) => {
+      if (!isString(init.content) || init.type === "json") {
+        this.#parseJSON(init.content, VTTCue, VTTRegion);
+        if (this.readyState !== 3) this.#ready();
+      } else {
+        const content = init.content.split("\n").map((line) => line.trim()).join("\n").trim();
+        parseText(content, { type: init.type }).then(({ cues, regions }) => {
+          this.#cues = cues;
+          this.#regions = regions;
+          this.#ready();
+        });
+      }
+    });
+  }
+  async #load() {
+    if (!this.#canLoad || this[TextTrackSymbol.readyState] > 0) return;
+    this[TextTrackSymbol.readyState] = 1;
+    this.dispatchEvent(new DOMEvent("load-start"));
+    if (!this.src) {
+      this.#ready();
+      return;
+    }
+    try {
+      const { parseResponse, VTTCue, VTTRegion } = await import('media-captions'), crossOrigin = this[TextTrackSymbol.crossOrigin]?.();
+      const response = fetch(this.src, {
+        headers: this.type === "json" ? { "Content-Type": "application/json" } : void 0,
+        credentials: getRequestCredentials(crossOrigin)
+      });
+      if (this.type === "json") {
+        this.#parseJSON(await (await response).text(), VTTCue, VTTRegion);
+      } else {
+        const { errors, metadata, regions, cues } = await parseResponse(response, {
+          type: this.type,
+          encoding: this.encoding
+        });
+        if (errors[0]?.code === 0) {
+          throw errors[0];
+        } else {
+          this.#metadata = metadata;
+          this.#regions = regions;
+          this.#cues = cues;
+        }
+      }
+      this.#ready();
+    } catch (error) {
+      this.#error(error);
+    }
+  }
+  #ready() {
+    this[TextTrackSymbol.readyState] = 2;
+    if (!this.src || this.type !== "vtt") {
+      const native = this[TextTrackSymbol.native];
+      if (native && !native.managed) {
+        for (const cue of this.#cues) native.track.addCue(cue);
+      }
+    }
+    const loadEvent = new DOMEvent("load");
+    this[TextTrackSymbol.updateActiveCues](this.#currentTime, loadEvent);
+    this.dispatchEvent(loadEvent);
+  }
+  #error(error) {
+    this[TextTrackSymbol.readyState] = 3;
+    this.dispatchEvent(new DOMEvent("error", { detail: error }));
+  }
+  #parseJSON(json, VTTCue, VTTRegion) {
+    try {
+      const { regions, cues } = parseJSONCaptionsFile(json, VTTCue, VTTRegion);
+      this.#regions = regions;
+      this.#cues = cues;
+    } catch (error) {
+      this.#error(error);
+    }
+  }
+  #activeCuesChanged(trigger) {
+    this.dispatchEvent(new DOMEvent("cue-change", { trigger }));
+  }
+}
+const captionRE = /captions|subtitles/;
+function isTrackCaptionKind(track) {
+  return captionRE.test(track.kind);
+}
+function parseJSONCaptionsFile(json, Cue, Region) {
+  const content = isString(json) ? JSON.parse(json) : json;
+  let regions = [], cues = [];
+  if (content.regions && Region) {
+    regions = content.regions.map((region) => Object.assign(new Region(), region));
+  }
+  if (content.cues || isArray(content)) {
+    cues = (isArray(content) ? content : content.cues).filter((content2) => isNumber(content2.startTime) && isNumber(content2.endTime)).map((cue) => Object.assign(new Cue(0, 0, ""), cue));
+  }
+  return { regions, cues };
+}
+
+const mediaContext = createContext();
+function useMediaContext() {
+  return useContext(mediaContext);
+}
+function useMediaState() {
+  return useMediaContext().$state;
+}
+
+function isEventInside(el, event) {
+  const target = event.composedPath()[0];
+  return isDOMNode(target) && el.contains(target);
+}
+const rafJobs = /* @__PURE__ */ new Set();
+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());
+  }
+  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) {
+  return callback();
+}
+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;
+  }
+  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());
+    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");
+  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");
+  }
+}
+
+export { AUDIO_EXTENSIONS, AUDIO_TYPES, DASH_VIDEO_EXTENSIONS, DASH_VIDEO_TYPES, HLS_VIDEO_EXTENSIONS, HLS_VIDEO_TYPES, TextTrack, TextTrackSymbol, VIDEO_EXTENSIONS, VIDEO_TYPES, appendParamsToURL, autoPlacement, canGoogleCastSrc, cloneTemplate, cloneTemplateContent, createSlot, createTemplate, findActiveCue, getDownloadFile, getRequestCredentials, hasAnimation, isAudioSrc, isCueActive, isDASHSrc, isElementParent, isEventInside, isHLSSrc, isHTMLElement, isMediaStream, isTouchPinchEvent, isTrackCaptionKind, isVideoSrc, loadScript, mediaContext, observeVisibility, onPress, parseJSONCaptionsFile, preconnect, requestScopedAnimationFrame, setARIALabel, setAttributeIfEmpty, useActive, useMediaContext, useMediaState, useResizeObserver, useTransitionActive, watchActiveTextTrack, watchColorScheme, watchCueTextChange };