@kesha-antonov/react-native-chat 5.0.1 → 6.0.1

package/lib/components/mediaPlayback.js

@@ -1,34 +1,763 @@
+import { c as _c } from "react/compiler-runtime";
+import { createContext, useContext, useEffect, useLayoutEffect, useRef, useSyncExternalStore } from 'react';
+import { createNotePlayerCache, detachRoundNote } from './roundNotePlayers';
+
 /**
  * Module-level registry so only one piece of media plays at a time.
  *
  * Every voice note and round video note owns its own player, and nothing
  * coordinated them: starting a second note left the first one playing, and a
- * chat with several round notes played all of them at once. Telegram always
- * stops the current one when a new one starts.
+ * chat with several round notes played all of them at once. Now the current
+ * one always stops when a new one starts.
  *
  * Deliberately not React context - bubbles are recycled by the list, and the
  * registry has to outlive individual mounts to stop a player whose row has
  * already scrolled away.
  */
+
+/**
+ * Why a player is told to stop. `replaced`: another note started, so this one
+ * is no longer current and resets its progress. `paused`: something else took the audio (a
+ * recording), so it pauses and stays current.
+ */
+
 const players = new Map();
+
 /**
  * Claim playback for `id`, stopping whatever else was playing.
- * Call when a player actually starts.
+ * Call when a player actually starts. A paused note may keep its claim, so a
+ * later note can still reset it.
  */
 export const claimPlayback = (id, stop) => {
-    for (const [otherId, stopOther] of players)
-        if (otherId !== id)
-            try {
-                stopOther();
-            }
-            catch {
-                // a player that fails to stop must not block the new one
-            }
-    players.clear();
-    players.set(id, stop);
-};
-/** Give up the claim (on pause, completion or unmount). */
-export const releasePlayback = (id) => {
-    players.delete(id);
+  for (const [otherId, stopOther] of players) if (otherId !== id) try {
+    stopOther('replaced');
+  } catch {
+    // a player that fails to stop must not block the new one
+  }
+  players.clear();
+  players.set(id, stop);
+};
+
+/** Give up the claim (on completion, reset or unmount). */
+export const releasePlayback = id => {
+  players.delete(id);
+};
+
+/**
+ * Pause whatever is playing. Recording calls this first: opening the mic takes
+ * audio focus, which pauses the playing note - otherwise it would bleed straight into the new take. The
+ * paused note keeps its claim and stays current.
+ */
+export const stopAllPlayback = () => {
+  for (const stop of [...players.values()]) try {
+    stop('paused');
+  } catch {
+    // a player that fails to stop must not block the others
+  }
+};
+
+/** A tap of the speed pill cycles through these. */
+export const PLAYBACK_RATES = [1, 1.5, 2];
+
+/**
+ * The presets a long press on the speed pill offers: Slow, Normal, Medium,
+ * Fast, Very fast and Super fast.
+ */
+export const PLAYBACK_RATE_PRESETS = [0.5, 1, 1.2, 1.5, 1.7, 2];
+
+/*
+ * One playback speed for every voice and round note: picking 2x on one note keeps 2x for
+ * the next instead of resetting each bubble to 1x. Module-level so it survives
+ * rows being recycled; apps that want it across launches persist it through
+ * `mediaPlayback.onPlaybackRateChange` and hand it back as `playbackRate`.
+ */
+let playbackRate = 1;
+const rateListeners = new Set();
+export const getPlaybackRate = () => playbackRate;
+export const setPlaybackRate = rate => {
+  if (!Number.isFinite(rate) || rate <= 0 || rate === playbackRate) return;
+  playbackRate = rate;
+  for (const listener of rateListeners) listener();
+};
+
+/** The next step on the speed pill after `rate`. */
+export const nextPlaybackRate = rate => {
+  const index = PLAYBACK_RATES.indexOf(rate);
+  return PLAYBACK_RATES[(index + 1) % PLAYBACK_RATES.length];
+};
+const subscribeRate = listener => {
+  rateListeners.add(listener);
+  return () => {
+    rateListeners.delete(listener);
+  };
+};
+
+/** The shared playback speed, re-rendering when any note changes it. */
+export const usePlaybackRate = () => {
+  return useSyncExternalStore(subscribeRate, getPlaybackRate, getPlaybackRate);
+};
+export const subscribePlaybackRate = listener => subscribeRate(() => listener(playbackRate));
+
+/** What a message needs for the "play the next note" lookup. */
+
+/** Chat-level playback options, from the `mediaPlayback` prop. */
+
+/** A mounted player the controller can start when the previous note ends. */
+
+/**
+ * Per-chat coordinator for auto-playing the next note. When a voice or round
+ * note finishes on its own, playback moves on to the next newer voice/round
+ * message in the chat, so a run of notes plays as one.
+ *
+ * The chat feeds it the current messages on every render (a ref write, no
+ * re-render), and players register by message id while they are mounted. The
+ * next note can only be started if its row is mounted - the list virtualizes,
+ * but the next note sits right below the current one, so it nearly always is.
+ */
+
+/** What the "now playing" bar shows and controls. */
+
+const isPlayableNote = message => !!message.audio || !!message.video && !!message.videoNote;
+export const createMediaPlaybackController = () => {
+  let messages = [];
+  let isInverted = true;
+  let options = {
+    isAutoPlayNextEnabled: true,
+    isRoundVideoAutoplayEnabled: false
+  };
+  const entries = new Map();
+  const nearEarListeners = new Set();
+  let grownNote = null;
+  let grownTimeShift = 0;
+  const grownListeners = new Set();
+  let scroller = null;
+  let nowPlaying = null;
+  const nowPlayingListeners = new Set();
+  const notifyNowPlaying = () => nowPlayingListeners.forEach(listener => listener());
+  let viewable = null;
+  const viewableListeners = new Set();
+  let floatingNote = null;
+  const floatingListeners = new Set();
+  const notePlayers = createNotePlayerCache();
+  return {
+    notePlayers,
+    setViewableMessages(messageIds) {
+      const next = new Set(messageIds);
+      if (viewable && viewable.size === next.size && [...next].every(id => viewable.has(id))) return;
+      viewable = next;
+      viewableListeners.forEach(listener => listener());
+    },
+    isMessageViewable(messageId) {
+      return viewable ? viewable.has(messageId) : undefined;
+    },
+    subscribeViewable(listener) {
+      viewableListeners.add(listener);
+      return () => {
+        viewableListeners.delete(listener);
+      };
+    },
+    setFloatingNote(messageId) {
+      if (floatingNote === messageId) return;
+      floatingNote = messageId;
+      floatingListeners.forEach(listener => listener());
+    },
+    getFloatingNote() {
+      return floatingNote;
+    },
+    subscribeFloatingNote(listener) {
+      floatingListeners.add(listener);
+      return () => {
+        floatingListeners.delete(listener);
+      };
+    },
+    setNowPlaying(entry) {
+      nowPlaying = entry;
+      notifyNowPlaying();
+    },
+    clearNowPlaying(messageId) {
+      if (nowPlaying?.messageId !== messageId) return;
+      nowPlaying = null;
+      notifyNowPlaying();
+    },
+    getNowPlaying() {
+      return nowPlaying;
+    },
+    subscribeNowPlaying(listener) {
+      nowPlayingListeners.add(listener);
+      return () => {
+        nowPlayingListeners.delete(listener);
+      };
+    },
+    getMessage(messageId) {
+      return messages.find(message => message._id === messageId);
+    },
+    setScroller(next) {
+      scroller = next;
+    },
+    scrollToMessage(messageId) {
+      scroller?.(messageId);
+    },
+    setGrownNote(messageId, timeShift = 0) {
+      if (grownNote === messageId && grownTimeShift === timeShift) return;
+      grownTimeShift = messageId == null ? 0 : timeShift;
+      grownNote = messageId;
+      grownListeners.forEach(listener => listener());
+    },
+    getGrownTimeShift() {
+      return grownTimeShift;
+    },
+    getGrownNote() {
+      return grownNote;
+    },
+    subscribeGrownNote(listener) {
+      grownListeners.add(listener);
+      return () => {
+        grownListeners.delete(listener);
+      };
+    },
+    setMessages(next, inverted) {
+      messages = next;
+      isInverted = inverted;
+    },
+    setOptions(next) {
+      const wasNearEar = !!options.isNearEar;
+      options = next;
+      // Rows do not re-render when the chat's options change, so the sensor
+      // reaches players through a subscription.
+      if (wasNearEar !== !!next.isNearEar) nearEarListeners.forEach(listener => listener());
+    },
+    subscribeNearEar(listener) {
+      nearEarListeners.add(listener);
+      return () => {
+        nearEarListeners.delete(listener);
+      };
+    },
+    getOptions() {
+      return options;
+    },
+    markRead(messageId) {
+      const message = messages.find(m => m._id === messageId);
+      if (message?.isMediaUnread) options.onMediaRead?.(message);
+    },
+    register(messageId, entry) {
+      entries.set(messageId, entry);
+      return () => {
+        if (entries.get(messageId) === entry) entries.delete(messageId);
+      };
+    },
+    onEnded(messageId) {
+      if (!options.isAutoPlayNextEnabled) return;
+      const index = messages.findIndex(message => message._id === messageId);
+      if (index < 0) return;
+
+      // An inverted list keeps the newest message first, so "newer" walks
+      // towards index 0; a non-inverted one walks the other way.
+      const step = isInverted ? -1 : 1;
+      for (let i = index + step; i >= 0 && i < messages.length; i += step) {
+        const message = messages[i];
+        if (!isPlayableNote(message)) continue;
+        entries.get(message._id)?.play();
+        return;
+      }
+    }
+  };
+};
+export const MediaPlaybackContext = createContext(null);
+
+/**
+ * Inside the long-press copy of a message: the chat's playback, to show (never drive). The copy
+ * sits over its hidden original while the menu is open; its media mirrors what the original is
+ * playing, as Telegram's lifted message does, instead of starting a player of its own.
+ */
+export const LiftedPlaybackContext = createContext(null);
+
+/**
+ * The horizontal shift of each grown round note, by its player key, so a lifted copy of it sits
+ * exactly over the original.
+ */
+export const noteGrowShifts = new Map();
+
+// Media a lifted copy is showing, by player key. On Android a player draws into one view at a
+// time, so the hidden original lets go of it while the copy holds it, and takes it back after.
+const liftedMedia = new Set();
+const liftedListeners = new Set();
+const subscribeLifted = listener => {
+  liftedListeners.add(listener);
+  return () => {
+    liftedListeners.delete(listener);
+  };
+};
+
+/** A lifted copy started (or stopped) showing the media under `key`. */
+export const setMediaLifted = (key, isLifted) => {
+  if (isLifted) liftedMedia.add(key);else liftedMedia.delete(key);
+  liftedListeners.forEach(listener => listener());
+};
+
+/** Whether a lifted copy is showing the media under `key`. */
+export const useIsMediaLifted = key => {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== key) {
+    t0 = () => liftedMedia.has(key);
+    $[0] = key;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return useSyncExternalStore(subscribeLifted, t0, _temp);
+};
+
+/** The chat's controller, or, inside a lifted copy, the one it mirrors. Read-only uses only. */
+const useReadablePlayback = () => {
+  const controller = useContext(MediaPlaybackContext);
+  const lifted = useContext(LiftedPlaybackContext);
+  return controller ?? lifted;
+};
+
+/**
+ * Registers a player for auto-play-next and returns the `onEnded` callback it
+ * should fire when its note finishes on its own. A no-op outside a `Chat`, or
+ * when the message id is unknown.
+ */
+export const usePlaylistEntry = (messageId, play) => {
+  const $ = _c(9);
+  const controller = useContext(MediaPlaybackContext);
+  const playRef = useRef(play);
+  let t0;
+  if ($[0] !== play) {
+    t0 = () => {
+      playRef.current = play;
+    };
+    $[0] = play;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  useLayoutEffect(t0);
+  let t1;
+  let t2;
+  if ($[2] !== controller || $[3] !== messageId) {
+    t1 = () => {
+      if (!controller || messageId == null) {
+        return;
+      }
+      return controller.register(messageId, {
+        play: () => playRef.current()
+      });
+    };
+    t2 = [controller, messageId];
+    $[2] = controller;
+    $[3] = messageId;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t1 = $[4];
+    t2 = $[5];
+  }
+  useEffect(t1, t2);
+  const onEndedRef = useRef(_temp2);
+  let t3;
+  if ($[6] !== controller || $[7] !== messageId) {
+    t3 = () => {
+      onEndedRef.current = () => {
+        if (controller && messageId != null) {
+          controller.onEnded(messageId);
+        }
+      };
+    };
+    $[6] = controller;
+    $[7] = messageId;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  useLayoutEffect(t3);
+  return onEndedRef;
+};
+
+/**
+ * Whether round notes loop silently in the list, and a callback that reports
+ * an incoming unread note as read. Both are no-ops outside a `Chat`.
+ */
+export const useNotePlaybackOptions = messageId => {
+  const $ = _c(10);
+  const controller = useContext(MediaPlaybackContext);
+  const markReadRef = useRef(_temp3);
+  let t0;
+  if ($[0] !== controller || $[1] !== messageId) {
+    t0 = () => {
+      markReadRef.current = () => {
+        if (controller && messageId != null) {
+          controller.markRead(messageId);
+        }
+      };
+    };
+    $[0] = controller;
+    $[1] = messageId;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  useLayoutEffect(t0);
+  let t1;
+  if ($[3] !== controller) {
+    t1 = controller?.getOptions();
+    $[3] = controller;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const options = t1;
+  const t2 = options?.isRoundVideoAutoplayEnabled ?? false;
+  const t3 = options?.isNearEar ?? false;
+  const t4 = options?.onTranscribe;
+  const t5 = options?.onViewOnceEnd;
+  let t6;
+  if ($[5] !== t2 || $[6] !== t3 || $[7] !== t4 || $[8] !== t5) {
+    t6 = {
+      isRoundVideoAutoplayEnabled: t2,
+      isNearEar: t3,
+      onTranscribe: t4,
+      onViewOnceEnd: t5,
+      markReadRef
+    };
+    $[5] = t2;
+    $[6] = t3;
+    $[7] = t4;
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  return t6;
+};
+const noSubscription = () => () => {};
+
+/** Whether this message's round note is grown to play; false outside a `Chat`. */
+export const useIsNoteGrown = messageId => {
+  const $ = _c(3);
+  const controller = useReadablePlayback();
+  let t0;
+  if ($[0] !== controller || $[1] !== messageId) {
+    t0 = () => messageId != null && controller?.getGrownNote() === messageId;
+    $[0] = controller;
+    $[1] = messageId;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useSyncExternalStore(controller?.subscribeGrownNote ?? noSubscription, t0, _temp4);
+};
+
+/** Reports this note growing or shrinking back, so its row can hide the avatar. */
+export const useReportNoteGrown = (messageId, isGrown, t0) => {
+  const $ = _c(11);
+  const timeShift = t0 === undefined ? 0 : t0;
+  const controller = useContext(MediaPlaybackContext);
+  let t1;
+  let t2;
+  if ($[0] !== controller || $[1] !== isGrown || $[2] !== messageId || $[3] !== timeShift) {
+    t1 = () => {
+      if (!controller || messageId == null || !isGrown) {
+        return;
+      }
+      controller.setGrownNote(messageId, timeShift);
+    };
+    t2 = [controller, messageId, isGrown, timeShift];
+    $[0] = controller;
+    $[1] = isGrown;
+    $[2] = messageId;
+    $[3] = timeShift;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t1 = $[4];
+    t2 = $[5];
+  }
+  useEffect(t1, t2);
+  let t3;
+  let t4;
+  if ($[6] !== controller || $[7] !== isGrown || $[8] !== messageId) {
+    t3 = () => {
+      if (!controller || messageId == null || !isGrown) {
+        return;
+      }
+      return () => {
+        if (controller.getGrownNote() === messageId) {
+          controller.setGrownNote(null);
+        }
+      };
+    };
+    t4 = [controller, messageId, isGrown];
+    $[6] = controller;
+    $[7] = isGrown;
+    $[8] = messageId;
+    $[9] = t3;
+    $[10] = t4;
+  } else {
+    t3 = $[9];
+    t4 = $[10];
+  }
+  useEffect(t3, t4);
+};
+
+/** How far this message's grown round note moved its right edge; 0 at rest. */
+export const useNoteTimeShift = messageId => {
+  const $ = _c(3);
+  const controller = useReadablePlayback();
+  let t0;
+  if ($[0] !== controller || $[1] !== messageId) {
+    t0 = () => messageId != null && controller?.getGrownNote() === messageId ? controller.getGrownTimeShift() : 0;
+    $[0] = controller;
+    $[1] = messageId;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useSyncExternalStore(controller?.subscribeGrownNote ?? noSubscription, t0, _temp5);
+};
+
+/**
+ * Puts this note in the "now playing" bar while it owns playback, playing or
+ * paused, and takes it out when it stops, is replaced or unmounts.
+ */
+export const useReportNowPlaying = (messageId, kind, isCurrent, isPlaying, toggle, stop, player) => {
+  const $ = _c(19);
+  const controller = useContext(MediaPlaybackContext);
+  let t0;
+  if ($[0] !== stop || $[1] !== toggle) {
+    t0 = {
+      toggle,
+      stop
+    };
+    $[0] = stop;
+    $[1] = toggle;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const actionsRef = useRef(t0);
+  let t1;
+  if ($[3] !== stop || $[4] !== toggle) {
+    t1 = () => {
+      actionsRef.current = {
+        toggle,
+        stop
+      };
+    };
+    $[3] = stop;
+    $[4] = toggle;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  useLayoutEffect(t1);
+  let t2;
+  let t3;
+  if ($[6] !== controller || $[7] !== isCurrent || $[8] !== isPlaying || $[9] !== kind || $[10] !== messageId || $[11] !== player) {
+    t2 = () => {
+      if (!controller || messageId == null || !isCurrent) {
+        return;
+      }
+      controller.setNowPlaying({
+        messageId,
+        kind,
+        isPlaying,
+        toggle: () => actionsRef.current.toggle(),
+        stop: () => actionsRef.current.stop(),
+        player
+      });
+    };
+    t3 = [controller, messageId, kind, isCurrent, isPlaying, player];
+    $[6] = controller;
+    $[7] = isCurrent;
+    $[8] = isPlaying;
+    $[9] = kind;
+    $[10] = messageId;
+    $[11] = player;
+    $[12] = t2;
+    $[13] = t3;
+  } else {
+    t2 = $[12];
+    t3 = $[13];
+  }
+  useEffect(t2, t3);
+  let t4;
+  let t5;
+  if ($[14] !== controller || $[15] !== isCurrent || $[16] !== messageId) {
+    t4 = () => {
+      if (!controller || messageId == null || !isCurrent) {
+        return;
+      }
+      return () => controller.clearNowPlaying(messageId);
+    };
+    t5 = [controller, messageId, isCurrent];
+    $[14] = controller;
+    $[15] = isCurrent;
+    $[16] = messageId;
+    $[17] = t4;
+    $[18] = t5;
+  } else {
+    t4 = $[17];
+    t5 = $[18];
+  }
+  useEffect(t4, t5);
+};
+
+/** Centres a message in the chat's list; a no-op outside a `Chat`. */
+export const useScrollToMessage = () => {
+  const $ = _c(2);
+  const controller = useContext(MediaPlaybackContext);
+  let t0;
+  if ($[0] !== controller) {
+    t0 = messageId => {
+      if (controller && messageId != null) {
+        controller.scrollToMessage(messageId);
+      }
+    };
+    $[0] = controller;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+};
+
+/** The note in the "now playing" bar, or null; null outside a `Chat`. */
+export const useNowPlaying = () => {
+  const $ = _c(2);
+  const controller = useContext(MediaPlaybackContext);
+  let t0;
+  if ($[0] !== controller) {
+    t0 = () => controller?.getNowPlaying() ?? null;
+    $[0] = controller;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return useSyncExternalStore(controller?.subscribeNowPlaying ?? noSubscription, t0, _temp6);
+};
+
+/** The phone is held to the ear (raise to listen); false outside a `Chat`. */
+export const useIsNearEar = () => {
+  const $ = _c(2);
+  const controller = useContext(MediaPlaybackContext);
+  let t0;
+  if ($[0] !== controller) {
+    t0 = () => !!controller?.getOptions().isNearEar;
+    $[0] = controller;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return useSyncExternalStore(controller?.subscribeNearEar ?? noSubscription, t0, _temp7);
+};
+
+/**
+ * Whether a message's row is on screen: `undefined` outside a `Chat` or before
+ * the list has reported, so callers can tell "scrolled away" from "unknown".
+ */
+export const useIsMessageViewable = messageId => {
+  const $ = _c(3);
+  const controller = useContext(MediaPlaybackContext);
+  let t0;
+  if ($[0] !== controller || $[1] !== messageId) {
+    t0 = () => controller && messageId != null ? controller.isMessageViewable(messageId) : undefined;
+    $[0] = controller;
+    $[1] = messageId;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useSyncExternalStore(controller?.subscribeViewable ?? noSubscription, t0, _temp8);
+};
+
+/** Whether this message's round note is currently drawn floating over the list. */
+export const useIsNoteFloating = messageId => {
+  const $ = _c(3);
+  const controller = useContext(MediaPlaybackContext);
+  let t0;
+  if ($[0] !== controller || $[1] !== messageId) {
+    t0 = () => messageId != null && controller?.getFloatingNote() === messageId;
+    $[0] = controller;
+    $[1] = messageId;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useSyncExternalStore(controller?.subscribeFloatingNote ?? noSubscription, t0, _temp9);
+};
+
+// Round notes rendered outside a `Chat` still borrow their players from a
+// cache, so React's strict effects (unmount, mount again) do not release a
+// player that is still on screen.
+const sharedNotePlayers = createNotePlayerCache();
+
+/** The chat's round note players, or a shared cache outside a `Chat`. */
+export const useNotePlayerCache = () => {
+  const controller = useContext(MediaPlaybackContext);
+  return controller?.notePlayers ?? sharedNotePlayers;
+};
+
+/**
+ * Hands a current round note whose row is unmounting over to a detached
+ * session, so it keeps playing (and floating) until it ends, another note
+ * starts, or its row mounts again and takes it back. Without a `Chat`, or
+ * while the chat itself is going away, the note just stops.
+ */
+export const detachRoundNoteFromRow = (controller, cache, cacheKey, messageId, player, isPlaying, /** False for a note that must not outlive its row (a view-once one). */
+canFloat = true) => {
+  if (!canFloat || !controller || messageId == null || !cache.isActive() || controller.getOptions().isFloatingRoundNoteEnabled === false) {
+    try {
+      player.pause();
+    } catch {
+      // already torn down
+    }
+    cache.keep(cacheKey, false);
+    return;
+  }
+  detachRoundNote(cacheKey, player, isPlaying, {
+    cache,
+    claim: claimPlayback,
+    unclaim: releasePlayback,
+    getRate: getPlaybackRate,
+    subscribeRate: subscribePlaybackRate,
+    report: state => {
+      if (state) controller.setNowPlaying({
+        messageId,
+        kind: 'round',
+        player,
+        ...state
+      });else controller.clearNowPlaying(messageId);
+    },
+    onEnded: () => controller.onEnded(messageId)
+  });
+};
+
+/** The chat's playback controller, or `null` outside a `Chat`. */
+export const useMediaPlaybackController = () => {
+  return useContext(MediaPlaybackContext);
 };
+function _temp() {
+  return false;
+}
+function _temp2() {}
+function _temp3() {}
+function _temp4() {
+  return false;
+}
+function _temp5() {
+  return 0;
+}
+function _temp6() {
+  return null;
+}
+function _temp7() {
+  return false;
+}
+function _temp8() {}
+function _temp9() {
+  return false;
+}
 //# sourceMappingURL=mediaPlayback.js.map