@hanifhan1f/vidstack-react 1.12.19 → 1.12.22

package/prod/chunks/vidstack-C4tNkfXj.js

@@ -0,0 +1,470 @@
+"use client"
+
+import { listenEvent, effect, untrack, createScope, keysOf, onDispose, DOMEvent, peek } from './vidstack-CZgUA94N.js';
+import { ListSymbol, TimeRange, RAFLoop } from './vidstack-B9nEslvl.js';
+import { getCastSessionMedia, getCastContext, getCastSession, hasActiveCastSession, listenCastContextEvent, getCastErrorMessage } from './vidstack-dbLRgf2L.js';
+import 'react';
+import '@floating-ui/dom';
+
+class GoogleCastMediaInfoBuilder {
+  #info;
+  constructor(src) {
+    this.#info = new chrome.cast.media.MediaInfo(src.src, src.type);
+  }
+  build() {
+    return this.#info;
+  }
+  setStreamType(streamType) {
+    if (streamType.includes("live")) {
+      this.#info.streamType = chrome.cast.media.StreamType.LIVE;
+    } else {
+      this.#info.streamType = chrome.cast.media.StreamType.BUFFERED;
+    }
+    return this;
+  }
+  setTracks(tracks) {
+    this.#info.tracks = tracks.map(this.#buildCastTrack);
+    return this;
+  }
+  setMetadata(title, poster) {
+    this.#info.metadata = new chrome.cast.media.GenericMediaMetadata();
+    this.#info.metadata.title = title;
+    this.#info.metadata.images = [{ url: poster }];
+    return this;
+  }
+  #buildCastTrack(track, trackId) {
+    const castTrack = new chrome.cast.media.Track(trackId, chrome.cast.media.TrackType.TEXT);
+    castTrack.name = track.label;
+    castTrack.trackContentId = track.src;
+    castTrack.trackContentType = "text/vtt";
+    castTrack.language = track.language;
+    castTrack.subtype = track.kind.toUpperCase();
+    return castTrack;
+  }
+}
+
+class GoogleCastTracksManager {
+  #cast;
+  #ctx;
+  #onNewLocalTracks;
+  constructor(cast, ctx, onNewLocalTracks) {
+    this.#cast = cast;
+    this.#ctx = ctx;
+    this.#onNewLocalTracks = onNewLocalTracks;
+  }
+  setup() {
+    const syncRemoteActiveIds = this.syncRemoteActiveIds.bind(this);
+    listenEvent(this.#ctx.audioTracks, "change", syncRemoteActiveIds);
+    listenEvent(this.#ctx.textTracks, "mode-change", syncRemoteActiveIds);
+    effect(this.#syncLocalTracks.bind(this));
+  }
+  getLocalTextTracks() {
+    return this.#ctx.$state.textTracks().filter((track) => track.src && track.type === "vtt");
+  }
+  #getLocalAudioTracks() {
+    return this.#ctx.$state.audioTracks();
+  }
+  #getRemoteTracks(type) {
+    const tracks = this.#cast.mediaInfo?.tracks ?? [];
+    return type ? tracks.filter((track) => track.type === type) : tracks;
+  }
+  #getRemoteActiveIds() {
+    const activeIds = [], activeLocalAudioTrack = this.#getLocalAudioTracks().find((track) => track.selected), activeLocalTextTracks = this.getLocalTextTracks().filter((track) => track.mode === "showing");
+    if (activeLocalAudioTrack) {
+      const remoteAudioTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.AUDIO), remoteAudioTrack = this.#findRemoteTrack(remoteAudioTracks, activeLocalAudioTrack);
+      if (remoteAudioTrack) activeIds.push(remoteAudioTrack.trackId);
+    }
+    if (activeLocalTextTracks?.length) {
+      const remoteTextTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.TEXT);
+      if (remoteTextTracks.length) {
+        for (const localTrack of activeLocalTextTracks) {
+          const remoteTextTrack = this.#findRemoteTrack(remoteTextTracks, localTrack);
+          if (remoteTextTrack) activeIds.push(remoteTextTrack.trackId);
+        }
+      }
+    }
+    return activeIds;
+  }
+  #syncLocalTracks() {
+    const localTextTracks = this.getLocalTextTracks();
+    if (!this.#cast.isMediaLoaded) return;
+    const remoteTextTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.TEXT);
+    for (const localTrack of localTextTracks) {
+      const hasRemoteTrack = this.#findRemoteTrack(remoteTextTracks, localTrack);
+      if (!hasRemoteTrack) {
+        untrack(() => this.#onNewLocalTracks?.());
+        break;
+      }
+    }
+  }
+  syncRemoteTracks(event) {
+    if (!this.#cast.isMediaLoaded) return;
+    const localAudioTracks = this.#getLocalAudioTracks(), localTextTracks = this.getLocalTextTracks(), remoteAudioTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.AUDIO), remoteTextTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.TEXT);
+    for (const remoteAudioTrack of remoteAudioTracks) {
+      const hasLocalTrack = this.#findLocalTrack(localAudioTracks, remoteAudioTrack);
+      if (hasLocalTrack) continue;
+      const localAudioTrack = {
+        id: remoteAudioTrack.trackId.toString(),
+        label: remoteAudioTrack.name,
+        language: remoteAudioTrack.language,
+        kind: remoteAudioTrack.subtype ?? "main",
+        selected: false
+      };
+      this.#ctx.audioTracks[ListSymbol.add](localAudioTrack, event);
+    }
+    for (const remoteTextTrack of remoteTextTracks) {
+      const hasLocalTrack = this.#findLocalTrack(localTextTracks, remoteTextTrack);
+      if (hasLocalTrack) continue;
+      const localTextTrack = {
+        id: remoteTextTrack.trackId.toString(),
+        src: remoteTextTrack.trackContentId,
+        label: remoteTextTrack.name,
+        language: remoteTextTrack.language,
+        kind: remoteTextTrack.subtype.toLowerCase()
+      };
+      this.#ctx.textTracks.add(localTextTrack, event);
+    }
+  }
+  syncRemoteActiveIds(event) {
+    if (!this.#cast.isMediaLoaded) return;
+    const activeIds = this.#getRemoteActiveIds(), editRequest = new chrome.cast.media.EditTracksInfoRequest(activeIds);
+    this.#editTracksInfo(editRequest).catch((error) => {
+    });
+  }
+  #editTracksInfo(request) {
+    const media = getCastSessionMedia();
+    return new Promise((resolve, reject) => media?.editTracksInfo(request, resolve, reject));
+  }
+  #findLocalTrack(localTracks, remoteTrack) {
+    return localTracks.find((localTrack) => this.#isMatch(localTrack, remoteTrack));
+  }
+  #findRemoteTrack(remoteTracks, localTrack) {
+    return remoteTracks.find((remoteTrack) => this.#isMatch(localTrack, remoteTrack));
+  }
+  // Note: we can't rely on id matching because they will differ between local/remote. A local
+  // track id might not even exist.
+  #isMatch(localTrack, remoteTrack) {
+    return remoteTrack.name === localTrack.label && remoteTrack.language === localTrack.language && remoteTrack.subtype.toLowerCase() === localTrack.kind.toLowerCase();
+  }
+}
+
+class GoogleCastProvider {
+  $$PROVIDER_TYPE = "GOOGLE_CAST";
+  scope = createScope();
+  #player;
+  #ctx;
+  #tracks;
+  #currentSrc = null;
+  #state = "disconnected";
+  #currentTime = 0;
+  #played = 0;
+  #seekableRange = new TimeRange(0, 0);
+  #timeRAF = new RAFLoop(this.#onAnimationFrame.bind(this));
+  #playerEventHandlers;
+  #reloadInfo = null;
+  #isIdle = false;
+  constructor(player, ctx) {
+    this.#player = player;
+    this.#ctx = ctx;
+    this.#tracks = new GoogleCastTracksManager(player, ctx, this.#onNewLocalTracks.bind(this));
+  }
+  get type() {
+    return "google-cast";
+  }
+  get currentSrc() {
+    return this.#currentSrc;
+  }
+  /**
+   * The Google Cast remote player.
+   *
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.RemotePlayer}
+   */
+  get player() {
+    return this.#player;
+  }
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastContext}
+   */
+  get cast() {
+    return getCastContext();
+  }
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastSession}
+   */
+  get session() {
+    return getCastSession();
+  }
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/chrome.cast.media.Media}
+   */
+  get media() {
+    return getCastSessionMedia();
+  }
+  /**
+   * Whether the current Google Cast session belongs to this provider.
+   */
+  get hasActiveSession() {
+    return hasActiveCastSession(this.#currentSrc);
+  }
+  setup() {
+    this.#attachCastContextEventListeners();
+    this.#attachCastPlayerEventListeners();
+    this.#tracks.setup();
+    this.#ctx.notify("provider-setup", this);
+  }
+  #attachCastContextEventListeners() {
+    listenCastContextEvent(
+      cast.framework.CastContextEventType.CAST_STATE_CHANGED,
+      this.#onCastStateChange.bind(this)
+    );
+  }
+  #attachCastPlayerEventListeners() {
+    const Event2 = cast.framework.RemotePlayerEventType, handlers = {
+      [Event2.IS_CONNECTED_CHANGED]: this.#onCastStateChange,
+      [Event2.IS_MEDIA_LOADED_CHANGED]: this.#onMediaLoadedChange,
+      [Event2.CAN_CONTROL_VOLUME_CHANGED]: this.#onCanControlVolumeChange,
+      [Event2.CAN_SEEK_CHANGED]: this.#onCanSeekChange,
+      [Event2.DURATION_CHANGED]: this.#onDurationChange,
+      [Event2.IS_MUTED_CHANGED]: this.#onVolumeChange,
+      [Event2.VOLUME_LEVEL_CHANGED]: this.#onVolumeChange,
+      [Event2.IS_PAUSED_CHANGED]: this.#onPausedChange,
+      [Event2.LIVE_SEEKABLE_RANGE_CHANGED]: this.#onProgress,
+      [Event2.PLAYER_STATE_CHANGED]: this.#onPlayerStateChange
+    };
+    this.#playerEventHandlers = handlers;
+    const handler = this.#onRemotePlayerEvent.bind(this);
+    for (const type of keysOf(handlers)) {
+      this.#player.controller.addEventListener(type, handler);
+    }
+    onDispose(() => {
+      for (const type of keysOf(handlers)) {
+        this.#player.controller.removeEventListener(type, handler);
+      }
+    });
+  }
+  async play() {
+    if (!this.#player.isPaused && !this.#isIdle) return;
+    if (this.#isIdle) {
+      await this.#reload(false, 0);
+      return;
+    }
+    this.#player.controller?.playOrPause();
+  }
+  async pause() {
+    if (this.#player.isPaused) return;
+    this.#player.controller?.playOrPause();
+  }
+  getMediaStatus(request) {
+    return new Promise((resolve, reject) => {
+      this.media?.getStatus(request, resolve, reject);
+    });
+  }
+  setMuted(muted) {
+    const hasChanged = muted && !this.#player.isMuted || !muted && this.#player.isMuted;
+    if (hasChanged) this.#player.controller?.muteOrUnmute();
+  }
+  setCurrentTime(time) {
+    this.#player.currentTime = time;
+    this.#ctx.notify("seeking", time);
+    this.#player.controller?.seek();
+  }
+  setVolume(volume) {
+    this.#player.volumeLevel = volume;
+    this.#player.controller?.setVolumeLevel();
+  }
+  async loadSource(src) {
+    if (this.#reloadInfo?.src !== src) this.#reloadInfo = null;
+    if (hasActiveCastSession(src)) {
+      this.#resumeSession();
+      this.#currentSrc = src;
+      return;
+    }
+    this.#ctx.notify("load-start");
+    const loadRequest = this.#buildLoadRequest(src), errorCode = await this.session.loadMedia(loadRequest);
+    if (errorCode) {
+      this.#currentSrc = null;
+      this.#ctx.notify("error", Error(getCastErrorMessage(errorCode)));
+      return;
+    }
+    this.#currentSrc = src;
+  }
+  destroy() {
+    this.#reset();
+    this.#endSession();
+  }
+  #reset() {
+    if (!this.#reloadInfo) {
+      this.#played = 0;
+      this.#seekableRange = new TimeRange(0, 0);
+    }
+    this.#timeRAF.stop();
+    this.#currentTime = 0;
+    this.#reloadInfo = null;
+  }
+  #resumeSession() {
+    const resumeSessionEvent = new DOMEvent("resume-session", { detail: this.session });
+    this.#onMediaLoadedChange(resumeSessionEvent);
+    const { muted, volume, savedState } = this.#ctx.$state, localState = savedState();
+    this.setCurrentTime(Math.max(this.#player.currentTime, localState?.currentTime ?? 0));
+    this.setMuted(muted());
+    this.setVolume(volume());
+    if (localState?.paused === false) this.play();
+  }
+  #endSession() {
+    this.cast.endCurrentSession(true);
+    const { remotePlaybackLoader } = this.#ctx.$state;
+    remotePlaybackLoader.set(null);
+  }
+  #disconnectFromReceiver() {
+    const { savedState } = this.#ctx.$state;
+    savedState.set({
+      paused: this.#player.isPaused,
+      currentTime: this.#player.currentTime
+    });
+    this.#endSession();
+  }
+  #onAnimationFrame() {
+    this.#onCurrentTimeChange();
+  }
+  #onRemotePlayerEvent(event) {
+    this.#playerEventHandlers[event.type].call(this, event);
+  }
+  #onCastStateChange(data) {
+    const castState = this.cast.getCastState(), state = castState === cast.framework.CastState.CONNECTED ? "connected" : castState === cast.framework.CastState.CONNECTING ? "connecting" : "disconnected";
+    if (this.#state === state) return;
+    const detail = { type: "google-cast", state }, trigger = this.#createEvent(data);
+    this.#state = state;
+    this.#ctx.notify("remote-playback-change", detail, trigger);
+    if (state === "disconnected") {
+      this.#disconnectFromReceiver();
+    }
+  }
+  #onMediaLoadedChange(event) {
+    const hasLoaded = !!this.#player.isMediaLoaded;
+    if (!hasLoaded) return;
+    const src = peek(this.#ctx.$state.source);
+    Promise.resolve().then(() => {
+      if (src !== peek(this.#ctx.$state.source) || !this.#player.isMediaLoaded) return;
+      this.#reset();
+      const duration = this.#player.duration;
+      this.#seekableRange = new TimeRange(0, duration);
+      const detail = {
+        provider: this,
+        duration,
+        buffered: new TimeRange(0, 0),
+        seekable: this.#getSeekableRange()
+      }, trigger = this.#createEvent(event);
+      this.#ctx.notify("loaded-metadata", void 0, trigger);
+      this.#ctx.notify("loaded-data", void 0, trigger);
+      this.#ctx.notify("can-play", detail, trigger);
+      this.#onCanControlVolumeChange();
+      this.#onCanSeekChange(event);
+      const { volume, muted } = this.#ctx.$state;
+      this.setVolume(volume());
+      this.setMuted(muted());
+      this.#timeRAF.start();
+      this.#tracks.syncRemoteTracks(trigger);
+      this.#tracks.syncRemoteActiveIds(trigger);
+    });
+  }
+  #onCanControlVolumeChange() {
+    this.#ctx.$state.canSetVolume.set(this.#player.canControlVolume);
+  }
+  #onCanSeekChange(event) {
+    const trigger = this.#createEvent(event);
+    this.#ctx.notify("stream-type-change", this.#getStreamType(), trigger);
+  }
+  #getStreamType() {
+    const streamType = this.#player.mediaInfo?.streamType;
+    return streamType === chrome.cast.media.StreamType.LIVE ? this.#player.canSeek ? "live:dvr" : "live" : "on-demand";
+  }
+  #onCurrentTimeChange() {
+    if (this.#reloadInfo) return;
+    const currentTime = this.#player.currentTime;
+    if (currentTime === this.#currentTime) return;
+    this.#ctx.notify("time-change", currentTime);
+    if (currentTime > this.#played) {
+      this.#played = currentTime;
+      this.#onProgress();
+    }
+    if (this.#ctx.$state.seeking()) {
+      this.#ctx.notify("seeked", currentTime);
+    }
+    this.#currentTime = currentTime;
+  }
+  #onDurationChange(event) {
+    if (!this.#player.isMediaLoaded || this.#reloadInfo) return;
+    const duration = this.#player.duration, trigger = this.#createEvent(event);
+    this.#seekableRange = new TimeRange(0, duration);
+    this.#ctx.notify("duration-change", duration, trigger);
+  }
+  #onVolumeChange(event) {
+    if (!this.#player.isMediaLoaded) return;
+    const detail = {
+      muted: this.#player.isMuted,
+      volume: this.#player.volumeLevel
+    }, trigger = this.#createEvent(event);
+    this.#ctx.notify("volume-change", detail, trigger);
+  }
+  #onPausedChange(event) {
+    const trigger = this.#createEvent(event);
+    if (this.#player.isPaused) {
+      this.#ctx.notify("pause", void 0, trigger);
+    } else {
+      this.#ctx.notify("play", void 0, trigger);
+    }
+  }
+  #onProgress(event) {
+    const detail = {
+      seekable: this.#getSeekableRange(),
+      buffered: new TimeRange(0, this.#played)
+    }, trigger = event ? this.#createEvent(event) : void 0;
+    this.#ctx.notify("progress", detail, trigger);
+  }
+  #onPlayerStateChange(event) {
+    const state = this.#player.playerState, PlayerState = chrome.cast.media.PlayerState;
+    this.#isIdle = state === PlayerState.IDLE;
+    if (state === PlayerState.PAUSED) return;
+    const trigger = this.#createEvent(event);
+    switch (state) {
+      case PlayerState.PLAYING:
+        this.#ctx.notify("playing", void 0, trigger);
+        break;
+      case PlayerState.BUFFERING:
+        this.#ctx.notify("waiting", void 0, trigger);
+        break;
+      case PlayerState.IDLE:
+        this.#timeRAF.stop();
+        this.#ctx.notify("pause");
+        this.#ctx.notify("end");
+        break;
+    }
+  }
+  #getSeekableRange() {
+    return this.#player.liveSeekableRange ? new TimeRange(this.#player.liveSeekableRange.start, this.#player.liveSeekableRange.end) : this.#seekableRange;
+  }
+  #createEvent(detail) {
+    return detail instanceof Event ? detail : new DOMEvent(detail.type, { detail });
+  }
+  #buildMediaInfo(src) {
+    const { streamType, title, poster } = this.#ctx.$state;
+    return new GoogleCastMediaInfoBuilder(src).setMetadata(title(), poster()).setStreamType(streamType()).setTracks(this.#tracks.getLocalTextTracks()).build();
+  }
+  #buildLoadRequest(src) {
+    const mediaInfo = this.#buildMediaInfo(src), request = new chrome.cast.media.LoadRequest(mediaInfo), savedState = this.#ctx.$state.savedState();
+    request.autoplay = (this.#reloadInfo?.paused ?? savedState?.paused) === false;
+    request.currentTime = this.#reloadInfo?.time ?? savedState?.currentTime ?? 0;
+    return request;
+  }
+  async #reload(paused, time) {
+    const src = peek(this.#ctx.$state.source);
+    this.#reloadInfo = { src, paused, time };
+    await this.loadSource(src);
+  }
+  #onNewLocalTracks() {
+    this.#reload(this.#player.isPaused, this.#player.currentTime).catch((error) => {
+    });
+  }
+}
+
+export { GoogleCastProvider };

package/prod/chunks/vidstack-CNJwYQRW.js

@@ -0,0 +1,84 @@
+"use client"
+
+import * as React from 'react';
+import { listenEvent, EventsController, animationFrameThrottle, effect } from './vidstack-CZgUA94N.js';
+import { useMediaPlayer } from './vidstack-DpQw1Y33.js';
+
+function useClassName(el, className) {
+  React.useEffect(() => {
+    if (!el || !className) return;
+    const tokens = className.split(" ");
+    for (const token of tokens) el.classList.add(token);
+    return () => {
+      for (const token of tokens) el.classList.remove(token);
+    };
+  }, [el, className]);
+}
+function useResizeObserver(el, callback) {
+  React.useEffect(() => {
+    if (!el) return;
+    callback();
+    const observer = new ResizeObserver(animationFrameThrottle(callback));
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [el, callback]);
+}
+function useTransitionActive(el) {
+  const [isActive, setIsActive] = React.useState(false);
+  React.useEffect(() => {
+    if (!el) return;
+    const events = new EventsController(el).add("transitionstart", () => setIsActive(true)).add("transitionend", () => setIsActive(false));
+    return () => events.abort();
+  }, [el]);
+  return isActive;
+}
+function useMouseEnter(el) {
+  const [isMouseEnter, setIsMouseEnter] = React.useState(false);
+  React.useEffect(() => {
+    if (!el) return;
+    const events = new EventsController(el).add("mouseenter", () => setIsMouseEnter(true)).add("mouseleave", () => setIsMouseEnter(false));
+    return () => events.abort();
+  }, [el]);
+  return isMouseEnter;
+}
+function useFocusIn(el) {
+  const [isFocusIn, setIsFocusIn] = React.useState(false);
+  React.useEffect(() => {
+    if (!el) return;
+    const events = new EventsController(el).add("focusin", () => setIsFocusIn(true)).add("focusout", () => setIsFocusIn(false));
+    return () => events.abort();
+  }, [el]);
+  return isFocusIn;
+}
+function useActive(el) {
+  const isMouseEnter = useMouseEnter(el), isFocusIn = useFocusIn(el), prevMouseEnter = React.useRef(false);
+  if (prevMouseEnter.current && !isMouseEnter) return false;
+  prevMouseEnter.current = isMouseEnter;
+  return isMouseEnter || isFocusIn;
+}
+function useColorSchemePreference() {
+  const [colorScheme, setColorScheme] = React.useState("dark");
+  React.useEffect(() => {
+    const media = window.matchMedia("(prefers-color-scheme: light)");
+    function onChange() {
+      setColorScheme(media.matches ? "light" : "dark");
+    }
+    onChange();
+    return listenEvent(media, "change", onChange);
+  }, []);
+  return colorScheme;
+}
+
+function useLayoutName(name) {
+  const player = useMediaPlayer();
+  React.useEffect(() => {
+    if (!player) return;
+    return effect(() => {
+      const el = player.$el;
+      el?.setAttribute("data-layout", name);
+      return () => el?.removeAttribute("data-layout");
+    });
+  }, [player]);
+}
+
+export { useActive, useClassName, useColorSchemePreference, useLayoutName, useResizeObserver, useTransitionActive };

package/prod/chunks/vidstack-CVzVtf1j.js

@@ -0,0 +1,61 @@
+"use client"
+
+import { appendParamsToURL, IS_SERVER } from './vidstack-B9nEslvl.js';
+import { signal, listenEvent, effect, peek, isString } from './vidstack-CZgUA94N.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) {
+    if (IS_SERVER) return;
+    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 };