@locpd/vidstack 1.12.14

package/prod/chunks/vidstack-DbkZGjSn.js

@@ -0,0 +1,107 @@
+import { createContext, useContext, Component, provideContext, signal, effect, createDisposalBin } from './vidstack-BGSTndAW.js';
+import { useMediaContext } from './vidstack-DJDnh4xT.js';
+
+const plyrLayoutContext = createContext();
+function usePlyrLayoutContext() {
+  return useContext(plyrLayoutContext);
+}
+
+const plyrLayoutProps = {
+  clickToPlay: true,
+  clickToFullscreen: true,
+  controls: [
+    "play-large",
+    "play",
+    "progress",
+    "current-time",
+    "mute+volume",
+    "captions",
+    "settings",
+    "pip",
+    "airplay",
+    "fullscreen"
+  ],
+  customIcons: false,
+  displayDuration: false,
+  download: null,
+  markers: null,
+  invertTime: true,
+  thumbnails: null,
+  toggleTime: true,
+  translations: null,
+  seekTime: 10,
+  speed: [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 4]
+};
+
+class PlyrLayout extends Component {
+  static props = plyrLayoutProps;
+  #media;
+  onSetup() {
+    this.#media = useMediaContext();
+    provideContext(plyrLayoutContext, {
+      ...this.$props,
+      previewTime: signal(0)
+    });
+  }
+}
+function usePlyrLayoutClasses(el, media) {
+  const {
+    canAirPlay,
+    canFullscreen,
+    canPictureInPicture,
+    controlsHidden,
+    currentTime,
+    fullscreen,
+    hasCaptions,
+    isAirPlayConnected,
+    paused,
+    pictureInPicture,
+    playing,
+    pointer,
+    poster,
+    textTrack,
+    viewType,
+    waiting
+  } = media.$state;
+  el.classList.add("plyr");
+  el.classList.add("plyr--full-ui");
+  const classes = {
+    "plyr--airplay-active": isAirPlayConnected,
+    "plyr--airplay-supported": canAirPlay,
+    "plyr--fullscreen-active": fullscreen,
+    "plyr--fullscreen-enabled": canFullscreen,
+    "plyr--hide-controls": controlsHidden,
+    "plyr--is-touch": () => pointer() === "coarse",
+    "plyr--loading": waiting,
+    "plyr--paused": paused,
+    "plyr--pip-active": pictureInPicture,
+    "plyr--pip-enabled": canPictureInPicture,
+    "plyr--playing": playing,
+    "plyr__poster-enabled": poster,
+    "plyr--stopped": () => paused() && currentTime() === 0,
+    "plyr--captions-active": textTrack,
+    "plyr--captions-enabled": hasCaptions
+  };
+  const disposal = createDisposalBin();
+  for (const token of Object.keys(classes)) {
+    disposal.add(effect(() => void el.classList.toggle(token, !!classes[token]())));
+  }
+  disposal.add(
+    effect(() => {
+      const token = `plyr--${viewType()}`;
+      el.classList.add(token);
+      return () => el.classList.remove(token);
+    }),
+    effect(() => {
+      const { $provider } = media, type = $provider()?.type, token = `plyr--${isHTMLProvider(type) ? "html5" : type}`;
+      el.classList.toggle(token, !!type);
+      return () => el.classList.remove(token);
+    })
+  );
+  return () => disposal.empty();
+}
+function isHTMLProvider(type) {
+  return type === "audio" || type === "video";
+}
+
+export { PlyrLayout, usePlyrLayoutClasses, usePlyrLayoutContext };

package/prod/chunks/vidstack-Dihypf8P.js

@@ -0,0 +1,11 @@
+function round(num, decimalPlaces = 2) {
+  return Number(num.toFixed(decimalPlaces));
+}
+function getNumberOfDecimalPlaces(num) {
+  return String(num).split(".")[1]?.length ?? 0;
+}
+function clampNumber(min, value, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+export { clampNumber, getNumberOfDecimalPlaces, round };

package/prod/chunks/vidstack-Dm1xEU9Q.js

@@ -0,0 +1,34 @@
+const videoIdRE = /(?:youtu\.be|youtube|youtube\.com|youtube-nocookie\.com)(?:\/shorts)?\/(?:embed\/|v\/|watch\?v=|watch\?.+&v=|)((?:\w|-){11})/;
+const posterCache = /* @__PURE__ */ new Map();
+const pendingFetch = /* @__PURE__ */ new Map();
+function resolveYouTubeVideoId(src) {
+  return src.match(videoIdRE)?.[1];
+}
+async function findYouTubePoster(videoId, abort) {
+  if (posterCache.has(videoId)) return posterCache.get(videoId);
+  if (pendingFetch.has(videoId)) return pendingFetch.get(videoId);
+  const pending = new Promise(async (resolve) => {
+    const sizes = ["maxresdefault", "sddefault", "hqdefault"];
+    for (const size of sizes) {
+      for (const webp of [true, false]) {
+        const url = resolveYouTubePosterURL(videoId, size, webp), response = await fetch(url, {
+          mode: "no-cors",
+          signal: abort.signal
+        });
+        if (response.status < 400) {
+          posterCache.set(videoId, url);
+          resolve(url);
+          return;
+        }
+      }
+    }
+  }).catch(() => "").finally(() => pendingFetch.delete(videoId));
+  pendingFetch.set(videoId, pending);
+  return pending;
+}
+function resolveYouTubePosterURL(videoId, size, webp) {
+  const type = webp ? "webp" : "jpg";
+  return `https://i.ytimg.com/${webp ? "vi_webp" : "vi"}/${videoId}/${size}.${type}`;
+}
+
+export { findYouTubePoster, resolveYouTubeVideoId };

package/prod/chunks/vidstack-Dq5Yu0Vr.js

@@ -0,0 +1,205 @@
+import { computed, peek, effect, onDispose, isDOMNode, animationFrameThrottle, isString } from './vidstack-BGSTndAW.js';
+import { nothing, render, html } from 'lit-html';
+import { ifDefined } from 'lit-html/directives/if-defined.js';
+import { unsafeSVG } from 'lit-html/directives/unsafe-svg.js';
+import { directive, AsyncDirective, PartType } from 'lit-html/async-directive.js';
+import { useMediaContext } from './vidstack-DJDnh4xT.js';
+
+class SignalDirective extends AsyncDirective {
+  #signal = null;
+  #isAttr = false;
+  #stop = null;
+  constructor(part) {
+    super(part);
+    this.#isAttr = part.type === PartType.ATTRIBUTE || part.type === PartType.BOOLEAN_ATTRIBUTE;
+  }
+  render(signal) {
+    if (signal !== this.#signal) {
+      this.disconnected();
+      this.#signal = signal;
+      if (this.isConnected) this.#watch();
+    }
+    return this.#signal ? this.#resolveValue(peek(this.#signal)) : nothing;
+  }
+  reconnected() {
+    this.#watch();
+  }
+  disconnected() {
+    this.#stop?.();
+    this.#stop = null;
+  }
+  #watch() {
+    if (!this.#signal) return;
+    this.#stop = effect(this.#onValueChange.bind(this));
+  }
+  #resolveValue(value) {
+    return this.#isAttr ? ifDefined(value) : value;
+  }
+  #setValue(value) {
+    this.setValue(this.#resolveValue(value));
+  }
+  #onValueChange() {
+    {
+      this.#setValue(this.#signal?.());
+    }
+  }
+}
+function $signal(compute) {
+  return directive(SignalDirective)(computed(compute));
+}
+
+class SlotObserver {
+  #roots;
+  #callback;
+  elements = /* @__PURE__ */ new Set();
+  constructor(roots, callback) {
+    this.#roots = roots;
+    this.#callback = callback;
+  }
+  connect() {
+    this.#update();
+    const observer = new MutationObserver(this.#onMutation);
+    for (const root of this.#roots) observer.observe(root, { childList: true, subtree: true });
+    onDispose(() => observer.disconnect());
+    onDispose(this.disconnect.bind(this));
+  }
+  disconnect() {
+    this.elements.clear();
+  }
+  assign(template, slot) {
+    if (isDOMNode(template)) {
+      slot.textContent = "";
+      slot.append(template);
+    } else {
+      render(null, slot);
+      render(template, slot);
+    }
+    if (!slot.style.display) {
+      slot.style.display = "contents";
+    }
+    const el = slot.firstElementChild;
+    if (!el) return;
+    const classList = slot.getAttribute("data-class");
+    if (classList) el.classList.add(...classList.split(" "));
+  }
+  #onMutation = animationFrameThrottle(this.#update.bind(this));
+  #update(entries) {
+    if (entries && !entries.some((e) => e.addedNodes.length)) return;
+    let changed = false, slots = this.#roots.flatMap((root) => [...root.querySelectorAll("slot")]);
+    for (const slot of slots) {
+      if (!slot.hasAttribute("name") || this.elements.has(slot)) continue;
+      this.elements.add(slot);
+      changed = true;
+    }
+    if (changed) this.#callback(this.elements);
+  }
+}
+
+let id = 0, slotIdAttr = "data-slot-id";
+class SlotManager {
+  #roots;
+  slots;
+  constructor(roots) {
+    this.#roots = roots;
+    this.slots = new SlotObserver(roots, this.#update.bind(this));
+  }
+  connect() {
+    this.slots.connect();
+    this.#update();
+    const mutations = new MutationObserver(this.#onMutation);
+    for (const root of this.#roots) mutations.observe(root, { childList: true });
+    onDispose(() => mutations.disconnect());
+  }
+  #onMutation = animationFrameThrottle(this.#update.bind(this));
+  #update() {
+    for (const root of this.#roots) {
+      for (const node of root.children) {
+        if (node.nodeType !== 1) continue;
+        const name = node.getAttribute("slot");
+        if (!name) continue;
+        node.style.display = "none";
+        let slotId = node.getAttribute(slotIdAttr);
+        if (!slotId) {
+          node.setAttribute(slotIdAttr, slotId = ++id + "");
+        }
+        for (const slot of this.slots.elements) {
+          if (slot.getAttribute("name") !== name || slot.getAttribute(slotIdAttr) === slotId) {
+            continue;
+          }
+          const clone = document.importNode(node, true);
+          if (name.includes("-icon")) clone.classList.add("vds-icon");
+          clone.style.display = "";
+          clone.removeAttribute("slot");
+          this.slots.assign(clone, slot);
+          slot.setAttribute(slotIdAttr, slotId);
+        }
+      }
+    }
+  }
+}
+
+function Icon({ name, class: _class, state, paths, viewBox = "0 0 32 32" }) {
+  return html`<svg
+    class="${"vds-icon" + (_class ? ` ${_class}` : "")}"
+    viewBox="${viewBox}"
+    fill="none"
+    aria-hidden="true"
+    focusable="false"
+    xmlns="http://www.w3.org/2000/svg"
+    data-icon=${ifDefined(name ?? state)}
+  >
+    ${!isString(paths) ? $signal(paths) : unsafeSVG(paths)}
+  </svg>`;
+}
+
+class IconsLoader {
+  #icons = {};
+  #loaded = false;
+  slots;
+  constructor(roots) {
+    this.slots = new SlotObserver(roots, this.#insertIcons.bind(this));
+  }
+  connect() {
+    this.slots.connect();
+  }
+  load() {
+    this.loadIcons().then((icons) => {
+      this.#icons = icons;
+      this.#loaded = true;
+      this.#insertIcons();
+    });
+  }
+  *#iterate() {
+    for (const iconName of Object.keys(this.#icons)) {
+      const slotName = `${iconName}-icon`;
+      for (const slot of this.slots.elements) {
+        if (slot.name !== slotName) continue;
+        yield { icon: this.#icons[iconName], slot };
+      }
+    }
+  }
+  #insertIcons() {
+    if (!this.#loaded) return;
+    for (const { icon, slot } of this.#iterate()) {
+      this.slots.assign(icon, slot);
+    }
+  }
+}
+
+class LayoutIconsLoader extends IconsLoader {
+  connect() {
+    super.connect();
+    const { player } = useMediaContext();
+    if (!player.el) return;
+    let dispose, observer = new IntersectionObserver((entries) => {
+      if (!entries[0]?.isIntersecting) return;
+      dispose?.();
+      dispose = void 0;
+      this.load();
+    });
+    observer.observe(player.el);
+    dispose = onDispose(() => observer.disconnect());
+  }
+}
+
+export { $signal, Icon, LayoutIconsLoader, SlotManager };

package/prod/chunks/vidstack-DqAw8m9J.js

@@ -0,0 +1,26 @@
+import { isUndefined, isNumber } from './vidstack-BGSTndAW.js';
+
+class RAFLoop {
+  #id;
+  #callback;
+  constructor(callback) {
+    this.#callback = callback;
+  }
+  start() {
+    if (!isUndefined(this.#id)) return;
+    this.#loop();
+  }
+  stop() {
+    if (isNumber(this.#id)) window.cancelAnimationFrame(this.#id);
+    this.#id = void 0;
+  }
+  #loop() {
+    this.#id = window.requestAnimationFrame(() => {
+      if (isUndefined(this.#id)) return;
+      this.#callback();
+      this.#loop();
+    });
+  }
+}
+
+export { RAFLoop };

package/prod/chunks/vidstack-DsPOyKtl.js

@@ -0,0 +1,57 @@
+import { signal, listenEvent, ViewController, effect, setAttribute, EventsController } from './vidstack-BGSTndAW.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/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-nLyr4NEP.js

@@ -0,0 +1,58 @@
+import { listenEvent, scoped, isString, getScope } from './vidstack-BGSTndAW.js';
+
+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(() => {
+        const off = listenEvent(
+          track,
+          "load",
+          () => {
+            onChange(track);
+            off();
+          },
+          { once: true }
+        );
+      }, scope);
+    }
+    currentTrack = track;
+  }
+  onModeChange();
+  return listenEvent(tracks, "mode-change", onModeChange);
+}
+function watchCueTextChange(tracks, kind, callback) {
+  watchActiveTextTrack(tracks, kind, (track) => {
+    if (!track) {
+      callback("");
+      return;
+    }
+    const onCueChange = () => {
+      const activeCue = track?.activeCues[0];
+      callback(activeCue?.text || "");
+    };
+    onCueChange();
+    listenEvent(track, "cue-change", onCueChange);
+  });
+}
+
+export { findActiveCue, isCueActive, watchActiveTextTrack, watchCueTextChange };

package/prod/chunks/vidstack-xMS8dnYq.js

@@ -0,0 +1,114 @@
+import { isFunction, isUndefined, waitTimeout, isString } from './vidstack-BGSTndAW.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 };