ts-video-player 0.1.0

package/dist/chunk-36x4yhjn.js

@@ -0,0 +1,765 @@
+// src/core/state.ts
+function shallowEqual(a, b) {
+  if (a === b)
+    return true;
+  if (!a || !b)
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (a[key] !== b[key])
+      return false;
+  }
+  return true;
+}
+function createSignal(initial) {
+  let value = initial;
+  const listeners = new Set;
+  const get = () => value;
+  const set = (newValue) => {
+    const prev = value;
+    value = typeof newValue === "function" ? newValue(prev) : newValue;
+    if (value !== prev) {
+      listeners.forEach((listener) => listener(value, prev));
+    }
+  };
+  get.subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  return [get, set];
+}
+function computed(fn, deps) {
+  let value;
+  let dirty = true;
+  deps.forEach((dep) => {
+    if (dep.subscribe) {
+      dep.subscribe(() => {
+        dirty = true;
+      });
+    }
+  });
+  return () => {
+    if (dirty) {
+      value = fn();
+      dirty = false;
+    }
+    return value;
+  };
+}
+function createDefaultState() {
+  return {
+    src: null,
+    sources: [],
+    currentSourceIndex: 0,
+    mediaType: "unknown",
+    streamType: "unknown",
+    providerType: "unknown",
+    loadingState: "idle",
+    preload: "metadata",
+    canPlay: false,
+    canPlayThrough: false,
+    error: null,
+    playbackState: "idle",
+    paused: true,
+    playing: false,
+    started: false,
+    ended: false,
+    seeking: false,
+    waiting: false,
+    currentTime: 0,
+    duration: 0,
+    playbackRate: 1,
+    loop: false,
+    autoplay: false,
+    playsinline: true,
+    muted: false,
+    volume: 1,
+    buffered: [],
+    bufferedAmount: 0,
+    seekable: [],
+    videoWidth: 0,
+    videoHeight: 0,
+    aspectRatio: 16 / 9,
+    qualities: [],
+    autoQuality: true,
+    audioTracks: [],
+    textTracks: [],
+    fullscreen: false,
+    pictureInPicture: false,
+    canFullscreen: false,
+    canPictureInPicture: false,
+    volumeAvailability: "unavailable",
+    fullscreenAvailability: "unavailable",
+    pipAvailability: "unavailable",
+    controlsVisible: true,
+    userActive: true,
+    pointerOver: false,
+    title: "",
+    poster: ""
+  };
+}
+
+class StateStore {
+  state;
+  listeners = new Map;
+  _pendingKeys = null;
+  _flushScheduled = false;
+  constructor(initial) {
+    this.state = { ...createDefaultState(), ...initial };
+  }
+  getState() {
+    return this.state;
+  }
+  get(key) {
+    return this.state[key];
+  }
+  set(key, value) {
+    if (this.state[key] === value)
+      return;
+    this.state = { ...this.state, [key]: value };
+    this.scheduleNotify(key);
+  }
+  batch(updates) {
+    for (const [key, value] of Object.entries(updates)) {
+      if (this.state[key] !== value) {
+        this.state[key] = value;
+        this.scheduleNotify(key);
+      }
+    }
+  }
+  subscribe(keyOrListener, listener) {
+    if (typeof keyOrListener === "function") {
+      const key2 = "*";
+      if (!this.listeners.has(key2)) {
+        this.listeners.set(key2, new Set);
+      }
+      this.listeners.get(key2).add(keyOrListener);
+      return () => this.listeners.get(key2)?.delete(keyOrListener);
+    }
+    const key = keyOrListener;
+    if (!listener)
+      return () => {};
+    if (!this.listeners.has(key)) {
+      this.listeners.set(key, new Set);
+    }
+    this.listeners.get(key).add(listener);
+    return () => this.listeners.get(key)?.delete(listener);
+  }
+  reset() {
+    this.state = createDefaultState();
+    this._pendingKeys = null;
+    this._flushScheduled = false;
+    this.notifyAll();
+  }
+  flush() {
+    if (this._pendingKeys) {
+      const keys = this._pendingKeys;
+      this._pendingKeys = null;
+      this._flushScheduled = false;
+      for (const key of keys) {
+        this.notifyKey(key);
+      }
+      this.notifyAll();
+    }
+  }
+  scheduleNotify(key) {
+    if (!this._pendingKeys) {
+      this._pendingKeys = new Set;
+    }
+    this._pendingKeys.add(key);
+    if (!this._flushScheduled) {
+      this._flushScheduled = true;
+      queueMicrotask(() => this.flush());
+    }
+  }
+  notifyKey(key) {
+    this.listeners.get(key)?.forEach((listener) => listener(this.state, key));
+  }
+  notifyAll() {
+    this.listeners.get("*")?.forEach((listener) => listener(this.state));
+  }
+}
+function selectBufferedAmount(state) {
+  if (state.duration === 0 || state.buffered.length === 0)
+    return 0;
+  let buffered = 0;
+  for (const range of state.buffered) {
+    buffered += range.end - range.start;
+  }
+  return Math.min(buffered / state.duration, 1);
+}
+function selectProgress(state) {
+  if (state.duration === 0)
+    return 0;
+  return Math.min(state.currentTime / state.duration, 1);
+}
+function selectRemainingTime(state) {
+  return Math.max(state.duration - state.currentTime, 0);
+}
+function selectIsIdle(state) {
+  return state.loadingState === "idle" && state.playbackState === "idle";
+}
+function selectIsLoading(state) {
+  return state.loadingState === "loading" || state.waiting;
+}
+function selectIsLive(state) {
+  return state.streamType.includes("live");
+}
+function selectIsDVR(state) {
+  return state.streamType === "live:dvr";
+}
+function selectCurrentQuality(state) {
+  const selected = state.qualities.find((q) => q.selected);
+  if (!selected)
+    return state.autoQuality ? "auto" : null;
+  return `${selected.height}p`;
+}
+function selectCurrentTextTrack(state) {
+  const showing = state.textTracks.find((t) => t.mode === "showing");
+  return showing?.label || null;
+}
+function selectCurrentAudioTrack(state) {
+  const selected = state.audioTracks.find((t) => t.selected);
+  return selected?.label || null;
+}
+var STORAGE_KEY = "ts-video-player";
+function loadPersistedState(storage = localStorage) {
+  try {
+    const data = storage.getItem(STORAGE_KEY);
+    if (data) {
+      return JSON.parse(data);
+    }
+  } catch {}
+  return {};
+}
+function savePersistedState(state, storage = localStorage) {
+  try {
+    const existing = loadPersistedState(storage);
+    storage.setItem(STORAGE_KEY, JSON.stringify({ ...existing, ...state }));
+  } catch {}
+}
+function createStorageSync(store, keys = ["volume", "muted", "playbackRate"], storage = localStorage) {
+  const persisted = loadPersistedState(storage);
+  if (persisted.volume !== undefined)
+    store.set("volume", persisted.volume);
+  if (persisted.muted !== undefined)
+    store.set("muted", persisted.muted);
+  if (persisted.playbackRate !== undefined)
+    store.set("playbackRate", persisted.playbackRate);
+  const unsubscribes = keys.map((key) => store.subscribe(key, (state) => {
+    const value = state[key];
+    savePersistedState({ [key]: value }, storage);
+  }));
+  return () => unsubscribes.forEach((unsub) => unsub());
+}
+
+// src/core/events.ts
+class EventEmitter {
+  listeners = new Map;
+  onceListeners = new Map;
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set);
+    }
+    this.listeners.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  once(event, handler) {
+    if (!this.onceListeners.has(event)) {
+      this.onceListeners.set(event, new Set);
+    }
+    this.onceListeners.get(event).add(handler);
+    return () => this.onceListeners.get(event)?.delete(handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+    this.onceListeners.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    this.listeners.get(event)?.forEach((handler) => {
+      try {
+        handler(...args);
+      } catch (error) {
+        console.error(`[ts-video-player] Error in event handler for "${String(event)}":`, error);
+      }
+    });
+    const onceHandlers = this.onceListeners.get(event);
+    if (onceHandlers) {
+      onceHandlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error(`[ts-video-player] Error in once handler for "${String(event)}":`, error);
+        }
+      });
+      onceHandlers.clear();
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+      this.onceListeners.delete(event);
+    } else {
+      this.listeners.clear();
+      this.onceListeners.clear();
+    }
+  }
+  listenerCount(event) {
+    return (this.listeners.get(event)?.size || 0) + (this.onceListeners.get(event)?.size || 0);
+  }
+}
+
+class MediaEventsNormalizer {
+  media;
+  emitter;
+  listeners = [];
+  constructor(media, emitter) {
+    this.media = media;
+    this.emitter = emitter;
+    this.attachListeners();
+  }
+  attachListeners() {
+    const on = (event, handler) => {
+      this.media.addEventListener(event, handler);
+      this.listeners.push(() => this.media.removeEventListener(event, handler));
+    };
+    on("loadstart", () => this.emitter.emit("loadstart"));
+    on("loadedmetadata", () => this.emitter.emit("loadedmetadata"));
+    on("loadeddata", () => this.emitter.emit("loadeddata"));
+    on("canplay", () => this.emitter.emit("canplay"));
+    on("canplaythrough", () => this.emitter.emit("canplaythrough"));
+    on("play", () => this.emitter.emit("play"));
+    on("pause", () => this.emitter.emit("pause"));
+    on("playing", () => this.emitter.emit("playing"));
+    on("waiting", () => this.emitter.emit("waiting"));
+    on("ended", () => this.emitter.emit("ended"));
+    on("seeking", () => this.emitter.emit("seeking"));
+    on("seeked", () => this.emitter.emit("seeked"));
+    on("timeupdate", () => this.emitter.emit("timeupdate", this.media.currentTime));
+    on("durationchange", () => this.emitter.emit("durationchange", this.media.duration));
+    on("volumechange", () => this.emitter.emit("volumechange", this.media.volume, this.media.muted));
+    on("ratechange", () => this.emitter.emit("ratechange", this.media.playbackRate));
+    on("progress", () => {
+      const buffered = this.getTimeRanges(this.media.buffered);
+      this.emitter.emit("progress", buffered);
+    });
+    on("error", () => {
+      const error = this.normalizeError(this.media.error);
+      this.emitter.emit("error", error);
+    });
+  }
+  getTimeRanges(ranges) {
+    const result = [];
+    for (let i = 0;i < ranges.length; i++) {
+      result.push({
+        start: ranges.start(i),
+        end: ranges.end(i)
+      });
+    }
+    return result;
+  }
+  normalizeError(error) {
+    if (!error) {
+      return { code: 0, message: "Unknown error" };
+    }
+    const messages = {
+      1: "The fetching of the media resource was aborted by the user agent.",
+      2: "A network error occurred while fetching the media resource.",
+      3: "An error occurred while decoding the media resource.",
+      4: "The media resource is not supported."
+    };
+    return {
+      code: error.code,
+      message: messages[error.code] || error.message || "Unknown error"
+    };
+  }
+  destroy() {
+    this.listeners.forEach((remove) => remove());
+    this.listeners = [];
+  }
+}
+function onFullscreenChange(handler) {
+  const events = ["fullscreenchange", "webkitfullscreenchange", "mozfullscreenchange", "MSFullscreenChange"];
+  const listener = () => {
+    const fullscreen = !!(document.fullscreenElement || document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement);
+    handler(fullscreen);
+  };
+  events.forEach((event) => document.addEventListener(event, listener));
+  return () => {
+    events.forEach((event) => document.removeEventListener(event, listener));
+  };
+}
+function onPiPChange(video, handler) {
+  const enterHandler = () => handler(true);
+  const leaveHandler = () => handler(false);
+  video.addEventListener("enterpictureinpicture", enterHandler);
+  video.addEventListener("leavepictureinpicture", leaveHandler);
+  return () => {
+    video.removeEventListener("enterpictureinpicture", enterHandler);
+    video.removeEventListener("leavepictureinpicture", leaveHandler);
+  };
+}
+var DEFAULT_KEYBOARD_SHORTCUTS = {
+  " ": "togglePlay",
+  k: "togglePlay",
+  m: "toggleMute",
+  f: "toggleFullscreen",
+  i: "togglePiP",
+  c: "toggleCaptions",
+  ArrowLeft: "seekBackward",
+  ArrowRight: "seekForward",
+  j: "seekBackward",
+  l: "seekForward",
+  ArrowUp: "volumeUp",
+  ArrowDown: "volumeDown",
+  ">": "speedUp",
+  "<": "speedDown",
+  Home: "seekStart",
+  End: "seekEnd",
+  "0": "seek0",
+  "1": "seek10",
+  "2": "seek20",
+  "3": "seek30",
+  "4": "seek40",
+  "5": "seek50",
+  "6": "seek60",
+  "7": "seek70",
+  "8": "seek80",
+  "9": "seek90"
+};
+function createKeyboardHandler(actions, options = {}) {
+  const { seekStep: _seekStep = 5, volumeStep: _volumeStep = 0.1, speedStep: _speedStep = 0.25 } = options;
+  return (event) => {
+    if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement || event.target instanceof HTMLSelectElement || event.target?.isContentEditable) {
+      return;
+    }
+    const key = event.key;
+    const action = DEFAULT_KEYBOARD_SHORTCUTS[key];
+    if (!action)
+      return;
+    event.preventDefault();
+    switch (action) {
+      case "togglePlay":
+        actions.togglePlay();
+        break;
+      case "toggleMute":
+        actions.toggleMute();
+        break;
+      case "toggleFullscreen":
+        actions.toggleFullscreen();
+        break;
+      case "togglePiP":
+        actions.togglePiP();
+        break;
+      case "toggleCaptions":
+        actions.toggleCaptions();
+        break;
+      case "seekBackward":
+        actions.seekBackward();
+        break;
+      case "seekForward":
+        actions.seekForward();
+        break;
+      case "volumeUp":
+        actions.volumeUp();
+        break;
+      case "volumeDown":
+        actions.volumeDown();
+        break;
+      case "speedUp":
+        actions.speedUp();
+        break;
+      case "speedDown":
+        actions.speedDown();
+        break;
+      case "seekStart":
+        actions.seekStart();
+        break;
+      case "seekEnd":
+        actions.seekEnd();
+        break;
+      default:
+        if (action.startsWith("seek")) {
+          const percent = parseInt(action.replace("seek", ""), 10);
+          if (!isNaN(percent)) {
+            actions.seekPercent(percent);
+          }
+        }
+    }
+  };
+}
+function createActivityDetector(element, options = {}) {
+  const { timeout = 3000, onActive, onInactive } = options;
+  let timer = null;
+  let active = true;
+  const setActive = () => {
+    if (!active) {
+      active = true;
+      onActive?.();
+    }
+    resetTimer();
+  };
+  const setInactive = () => {
+    if (active) {
+      active = false;
+      onInactive?.();
+    }
+  };
+  const resetTimer = () => {
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(setInactive, timeout);
+  };
+  const events = ["mousemove", "mouseenter", "mouseleave", "mousedown", "keydown", "touchstart", "touchmove"];
+  events.forEach((event) => element.addEventListener(event, setActive));
+  resetTimer();
+  return () => {
+    if (timer)
+      clearTimeout(timer);
+    events.forEach((event) => element.removeEventListener(event, setActive));
+  };
+}
+function createGestureDetector(element, handlers) {
+  let startX = 0;
+  let startY = 0;
+  let startTime = 0;
+  let lastTap = 0;
+  let isScrubbing = false;
+  let cachedRect = null;
+  const SWIPE_THRESHOLD = 50;
+  const TAP_THRESHOLD = 200;
+  const DOUBLE_TAP_THRESHOLD = 300;
+  const onTouchStart = (e) => {
+    const touch = e.touches[0];
+    startX = touch.clientX;
+    startY = touch.clientY;
+    startTime = Date.now();
+    isScrubbing = false;
+    cachedRect = element.getBoundingClientRect();
+  };
+  const onTouchMove = (e) => {
+    if (!startTime)
+      return;
+    const touch = e.touches[0];
+    const deltaX = touch.clientX - startX;
+    const deltaY = touch.clientY - startY;
+    if (Math.abs(deltaX) > Math.abs(deltaY) && Math.abs(deltaX) > 20) {
+      isScrubbing = true;
+      const rect = cachedRect || element.getBoundingClientRect();
+      const progress = Math.max(0, Math.min(1, (touch.clientX - rect.left) / rect.width));
+      handlers.onScrub?.(progress);
+    }
+  };
+  const onTouchEnd = (e) => {
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+    if (isScrubbing) {
+      handlers.onScrubEnd?.();
+      isScrubbing = false;
+      startTime = 0;
+      return;
+    }
+    const touch = e.changedTouches[0];
+    const deltaX = touch.clientX - startX;
+    const deltaY = touch.clientY - startY;
+    if (duration < 500) {
+      if (Math.abs(deltaX) > SWIPE_THRESHOLD && Math.abs(deltaX) > Math.abs(deltaY)) {
+        if (deltaX > 0) {
+          handlers.onSwipeRight?.();
+        } else {
+          handlers.onSwipeLeft?.();
+        }
+        startTime = 0;
+        return;
+      }
+      if (Math.abs(deltaY) > SWIPE_THRESHOLD && Math.abs(deltaY) > Math.abs(deltaX)) {
+        if (deltaY > 0) {
+          handlers.onSwipeDown?.();
+        } else {
+          handlers.onSwipeUp?.();
+        }
+        startTime = 0;
+        return;
+      }
+    }
+    if (duration < TAP_THRESHOLD && Math.abs(deltaX) < 10 && Math.abs(deltaY) < 10) {
+      const now = Date.now();
+      if (now - lastTap < DOUBLE_TAP_THRESHOLD) {
+        handlers.onDoubleTap?.(touch.clientX, touch.clientY);
+        lastTap = 0;
+      } else {
+        handlers.onTap?.(touch.clientX, touch.clientY);
+        lastTap = now;
+      }
+    }
+    startTime = 0;
+  };
+  element.addEventListener("touchstart", onTouchStart, { passive: true });
+  element.addEventListener("touchmove", onTouchMove, { passive: true });
+  element.addEventListener("touchend", onTouchEnd, { passive: true });
+  return () => {
+    element.removeEventListener("touchstart", onTouchStart);
+    element.removeEventListener("touchmove", onTouchMove);
+    element.removeEventListener("touchend", onTouchEnd);
+  };
+}
+
+// src/core/features.ts
+function isIOSSafari() {
+  if (typeof navigator === "undefined")
+    return false;
+  const ua = navigator.userAgent;
+  if (/iPad|iPhone|iPod/.test(ua) && !window.MSStream)
+    return true;
+  if (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1)
+    return true;
+  return false;
+}
+function isSafari() {
+  if (typeof navigator === "undefined")
+    return false;
+  return /^(?:(?!chrome|android).)*safari/i.test(navigator.userAgent);
+}
+function isStandalonePWA() {
+  if (typeof window === "undefined")
+    return false;
+  return navigator.standalone === true || window.matchMedia("(display-mode: standalone)").matches;
+}
+function detectVolumeAvailability(media) {
+  if (isIOSSafari())
+    return "unsupported";
+  if (!media)
+    return "unavailable";
+  return "available";
+}
+async function probeVolumeAvailability(media) {
+  const original = media.volume;
+  try {
+    const testValue = original === 1 ? 0.5 : 1;
+    media.volume = testValue;
+    await new Promise((r) => setTimeout(r, 0));
+    const changed = media.volume !== original;
+    media.volume = original;
+    return changed ? "available" : "unsupported";
+  } catch {
+    try {
+      media.volume = original;
+    } catch {}
+    return "unsupported";
+  }
+}
+function detectFullscreenAvailability(container, videoElement) {
+  const doc = typeof document !== "undefined" ? document : null;
+  if (!doc)
+    return "unsupported";
+  if (doc.fullscreenEnabled || doc.webkitFullscreenEnabled)
+    return "available";
+  if (doc.mozFullScreenEnabled || doc.msFullscreenEnabled)
+    return "available";
+  if (videoElement) {
+    const video = videoElement;
+    if (video.webkitSupportsFullscreen === true)
+      return "available";
+    if (typeof video.webkitEnterFullscreen === "function")
+      return "available";
+  }
+  if (!container && !videoElement)
+    return "unavailable";
+  return "unsupported";
+}
+function isVideoOnlyFullscreen() {
+  if (typeof document === "undefined")
+    return false;
+  const doc = document;
+  return isIOSSafari() && !doc.fullscreenEnabled && !doc.webkitFullscreenEnabled;
+}
+async function enterFullscreen(container, media) {
+  const video = media;
+  if (container) {
+    const el = container;
+    if (typeof el.requestFullscreen === "function")
+      return el.requestFullscreen();
+    if (typeof el.webkitRequestFullscreen === "function")
+      return el.webkitRequestFullscreen();
+    if (typeof el.webkitRequestFullScreen === "function")
+      return el.webkitRequestFullScreen();
+  }
+  if (video && typeof video.webkitEnterFullscreen === "function") {
+    video.webkitEnterFullscreen();
+    return;
+  }
+  if (media && typeof media.requestFullscreen === "function") {
+    return media.requestFullscreen();
+  }
+}
+async function exitFullscreen(media) {
+  const doc = document;
+  const video = media;
+  if (typeof doc.exitFullscreen === "function")
+    return doc.exitFullscreen();
+  if (typeof doc.webkitExitFullscreen === "function")
+    return doc.webkitExitFullscreen();
+  if (typeof doc.webkitCancelFullScreen === "function")
+    return doc.webkitCancelFullScreen();
+  if (video && typeof video.webkitExitFullscreen === "function") {
+    video.webkitExitFullscreen();
+  }
+}
+function detectPipAvailability(videoElement) {
+  if (!videoElement)
+    return "unavailable";
+  if ("requestPictureInPicture" in videoElement) {
+    if (typeof document !== "undefined" && document.pictureInPictureEnabled === false) {
+      return "unavailable";
+    }
+    if (isSafari() && isStandalonePWA())
+      return "unavailable";
+    return "available";
+  }
+  const video = videoElement;
+  if (typeof video.webkitSetPresentationMode === "function") {
+    if (isStandalonePWA())
+      return "unavailable";
+    if (typeof video.webkitSupportsPresentationMode === "function") {
+      return video.webkitSupportsPresentationMode("picture-in-picture") ? "available" : "unsupported";
+    }
+    return "available";
+  }
+  return "unsupported";
+}
+async function enterPiP(media) {
+  const video = media;
+  if (typeof video.requestPictureInPicture === "function") {
+    await video.requestPictureInPicture();
+    return;
+  }
+  if (typeof video.webkitSetPresentationMode === "function") {
+    video.webkitSetPresentationMode("picture-in-picture");
+  }
+}
+async function exitPiP(media) {
+  if (document.pictureInPictureElement && typeof document.exitPictureInPicture === "function") {
+    await document.exitPictureInPicture();
+    return;
+  }
+  if (media) {
+    const video = media;
+    if (video.webkitPresentationMode === "picture-in-picture" && typeof video.webkitSetPresentationMode === "function") {
+      video.webkitSetPresentationMode("inline");
+    }
+  }
+}
+function detectAllFeatures(container, videoElement, mediaElement) {
+  return {
+    volume: detectVolumeAvailability(mediaElement),
+    fullscreen: detectFullscreenAvailability(container, videoElement),
+    pip: detectPipAvailability(videoElement)
+  };
+}
+
+export { shallowEqual, createSignal, computed, createDefaultState, StateStore, selectBufferedAmount, selectProgress, selectRemainingTime, selectIsIdle, selectIsLoading, selectIsLive, selectIsDVR, selectCurrentQuality, selectCurrentTextTrack, selectCurrentAudioTrack, loadPersistedState, savePersistedState, createStorageSync, EventEmitter, MediaEventsNormalizer, onFullscreenChange, onPiPChange, DEFAULT_KEYBOARD_SHORTCUTS, createKeyboardHandler, createActivityDetector, createGestureDetector, isIOSSafari, isSafari, isStandalonePWA, detectVolumeAvailability, probeVolumeAvailability, detectFullscreenAvailability, isVideoOnlyFullscreen, enterFullscreen, exitFullscreen, detectPipAvailability, enterPiP, exitPiP, detectAllFeatures };
+
+//# debugId=24A95575AA67786364756E2164756E21