{"version":3,"file":"hooks-C6T19zG6.mjs","sources":["../src/hooks/internal/useResizeObserver.ts","../src/hooks/internal/useObservableState.ts","../src/hooks/internal/useMediaQuery.ts","../src/hooks/useAudioPlayback.ts","../src/hooks/useClearPinButton.ts","../src/hooks/useConnectionQualityIndicator.ts","../src/hooks/useConnectionStatus.ts","../src/hooks/useDataChannel.ts","../src/hooks/useDisconnectButton.ts","../src/hooks/useFacingMode.ts","../src/hooks/useFocusToggle.ts","../src/hooks/useGridLayout.ts","../src/hooks/useIsMuted.ts","../src/hooks/useIsSpeaking.ts","../src/hooks/useLocalParticipant.ts","../src/hooks/useLocalParticipantPermissions.ts","../src/hooks/useMediaDeviceSelect.ts","../src/hooks/useMediaDevices.ts","../src/hooks/useVisualStableUpdate.ts","../src/hooks/usePagination.ts","../src/hooks/useParticipantInfo.ts","../src/hooks/useParticipantPermissions.ts","../src/hooks/useParticipantTile.ts","../src/hooks/useRemoteParticipants.ts","../src/hooks/useParticipants.ts","../src/hooks/usePinnedTracks.ts","../src/hooks/useRemoteParticipant.ts","../src/hooks/useRoomInfo.ts","../src/hooks/useSpeakingParticipants.ts","../src/hooks/useSortedParticipants.ts","../src/hooks/useStartAudio.ts","../src/hooks/useStartVideo.ts","../src/hooks/useSwipe.ts","../src/hooks/useChatToggle.ts","../src/hooks/useToken.ts","../src/hooks/useTrackMutedIndicator.ts","../src/hooks/useTrackToggle.ts","../src/hooks/useTracks.ts","../src/hooks/useTrackRefBySourceOrName.ts","../src/hooks/useTrackByName.ts","../src/hooks/useChat.ts","../src/hooks/usePersistentUserChoices.ts","../src/hooks/useIsEncrypted.ts","../src/hooks/useTrackVolume.ts","../src/hooks/useParticipantTracks.ts","../src/hooks/useTrackSyncTime.ts","../src/hooks/useTrackTranscription.ts","../src/hooks/useParticipantAttributes.ts","../src/hooks/useVoiceAssistant.ts","../src/hooks/useIsRecording.ts"],"sourcesContent":["/* eslint-disable no-return-assign */\n/* eslint-disable no-underscore-dangle */\nimport * as React from 'react';\n\nconst useLatest = <T>(current: T) => {\n  const storedValue = React.useRef(current);\n  React.useEffect(() => {\n    storedValue.current = current;\n  });\n  return storedValue;\n};\n\n/**\n * A React hook that fires a callback whenever ResizeObserver detects a change to its size\n * code extracted from https://github.com/jaredLunde/react-hook/blob/master/packages/resize-observer/src/index.tsx in order to not include the polyfill for resize-observer\n *\n * @internal\n */\nexport function useResizeObserver<T extends HTMLElement>(\n  target: React.RefObject<T>,\n  callback: UseResizeObserverCallback,\n) {\n  const resizeObserver = getResizeObserver();\n  const storedCallback = useLatest(callback);\n\n  React.useLayoutEffect(() => {\n    let didUnsubscribe = false;\n\n    const targetEl = target.current;\n    if (!targetEl) return;\n\n    function cb(entry: ResizeObserverEntry, observer: ResizeObserver) {\n      if (didUnsubscribe) return;\n      storedCallback.current(entry, observer);\n    }\n\n    resizeObserver?.subscribe(targetEl as HTMLElement, cb);\n\n    return () => {\n      didUnsubscribe = true;\n      resizeObserver?.unsubscribe(targetEl as HTMLElement, cb);\n    };\n  }, [target.current, resizeObserver, storedCallback]);\n\n  return resizeObserver?.observer;\n}\n\nfunction createResizeObserver() {\n  let ticking = false;\n  let allEntries: ResizeObserverEntry[] = [];\n\n  const callbacks: Map<unknown, Array<UseResizeObserverCallback>> = new Map();\n\n  if (typeof window === 'undefined') {\n    return;\n  }\n\n  const observer = new ResizeObserver((entries: ResizeObserverEntry[], obs: ResizeObserver) => {\n    allEntries = allEntries.concat(entries);\n    if (!ticking) {\n      window.requestAnimationFrame(() => {\n        const triggered = new Set<Element>();\n        for (let i = 0; i < allEntries.length; i++) {\n          if (triggered.has(allEntries[i].target)) continue;\n          triggered.add(allEntries[i].target);\n          const cbs = callbacks.get(allEntries[i].target);\n          cbs?.forEach((cb) => cb(allEntries[i], obs));\n        }\n        allEntries = [];\n        ticking = false;\n      });\n    }\n    ticking = true;\n  });\n\n  return {\n    observer,\n    subscribe(target: HTMLElement, callback: UseResizeObserverCallback) {\n      observer.observe(target);\n      const cbs = callbacks.get(target) ?? [];\n      cbs.push(callback);\n      callbacks.set(target, cbs);\n    },\n    unsubscribe(target: HTMLElement, callback: UseResizeObserverCallback) {\n      const cbs = callbacks.get(target) ?? [];\n      if (cbs.length === 1) {\n        observer.unobserve(target);\n        callbacks.delete(target);\n        return;\n      }\n      const cbIndex = cbs.indexOf(callback);\n      if (cbIndex !== -1) cbs.splice(cbIndex, 1);\n      callbacks.set(target, cbs);\n    },\n  };\n}\n\nlet _resizeObserver: ReturnType<typeof createResizeObserver>;\n\nconst getResizeObserver = () =>\n  !_resizeObserver ? (_resizeObserver = createResizeObserver()) : _resizeObserver;\n\nexport type UseResizeObserverCallback = (\n  entry: ResizeObserverEntry,\n  observer: ResizeObserver,\n) => unknown;\n\nexport const useSize = (target: React.RefObject<HTMLDivElement>) => {\n  const [size, setSize] = React.useState({ width: 0, height: 0 });\n  React.useLayoutEffect(() => {\n    if (target.current) {\n      const { width, height } = target.current.getBoundingClientRect();\n      setSize({ width, height });\n    }\n  }, [target.current]);\n\n  const resizeCallback = React.useCallback(\n    (entry: ResizeObserverEntry) => setSize(entry.contentRect),\n    [],\n  );\n  // Where the magic happens\n  useResizeObserver(target, resizeCallback);\n  return size;\n};\n","import * as React from 'react';\n// @ts-ignore\nimport type { Observable } from 'rxjs';\n\n/**\n * @internal\n */\nexport function useObservableState<T>(\n  observable: Observable<T> | undefined,\n  startWith: T,\n  resetWhenObservableChanges = true,\n) {\n  const [state, setState] = React.useState<T>(startWith);\n  React.useEffect(() => {\n    if (resetWhenObservableChanges) {\n      setState(startWith);\n    }\n    // observable state doesn't run in SSR\n    if (typeof window === 'undefined' || !observable) return;\n    const subscription = observable.subscribe(setState);\n    return () => subscription.unsubscribe();\n  }, [observable, resetWhenObservableChanges]);\n  return state;\n}\n","import * as React from 'react';\n/**\n * Implementation used from https://github.com/juliencrn/usehooks-ts\n *\n * @internal\n */\nexport function useMediaQuery(query: string): boolean {\n  const getMatches = (query: string): boolean => {\n    // Prevents SSR issues\n    if (typeof window !== 'undefined') {\n      return window.matchMedia(query).matches;\n    }\n    return false;\n  };\n\n  const [matches, setMatches] = React.useState<boolean>(getMatches(query));\n\n  function handleChange() {\n    setMatches(getMatches(query));\n  }\n\n  React.useEffect(() => {\n    const matchMedia = window.matchMedia(query);\n\n    // Triggered at the first client-side load and if query changes\n    handleChange();\n\n    // Listen matchMedia\n    if (matchMedia.addListener) {\n      matchMedia.addListener(handleChange);\n    } else {\n      matchMedia.addEventListener('change', handleChange);\n    }\n\n    return () => {\n      if (matchMedia.removeListener) {\n        matchMedia.removeListener(handleChange);\n      } else {\n        matchMedia.removeEventListener('change', handleChange);\n      }\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [query]);\n\n  return matches;\n}\n","import type { Room } from 'livekit-client';\nimport * as React from 'react';\nimport { useObservableState } from './internal';\nimport { roomAudioPlaybackAllowedObservable } from '@livekit/components-core';\nimport { useEnsureRoom } from '../context';\n\n/**\n * In many browsers to start audio playback, the user must perform a user-initiated event such as clicking a button.\n * The `useAudioPlayback` hook returns an object with a boolean `canPlayAudio` flag that indicates whether audio\n * playback is allowed in the current context, as well as a `startAudio` function that can be called in a button\n * `onClick` callback to start audio playback in the current context.\n *\n * @see Autoplay policy on MDN web docs for more info: {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Best_practices#autoplay_policy}\n * @alpha\n */\nexport function useAudioPlayback(room?: Room): {\n  canPlayAudio: boolean;\n  startAudio: () => Promise<void>;\n} {\n  const roomEnsured = useEnsureRoom(room);\n  const startAudio = React.useCallback(async () => {\n    await roomEnsured.startAudio();\n  }, [roomEnsured]);\n\n  const observable = React.useMemo(\n    () => roomAudioPlaybackAllowedObservable(roomEnsured),\n    [roomEnsured],\n  );\n  const { canPlayAudio } = useObservableState(observable, {\n    canPlayAudio: roomEnsured.canPlaybackAudio,\n  });\n\n  return { canPlayAudio, startAudio };\n}\n","import { setupClearPinButton } from '@livekit/components-core';\nimport * as React from 'react';\nimport { useLayoutContext } from '../context';\nimport { mergeProps } from '../mergeProps';\nimport type { ClearPinButtonProps } from '../components';\n\n/**\n * The `useClearPinButton` hook provides props for the {@link ClearPinButton}\n * or your custom implementation of it component. It adds the `onClick` handler\n * to signal the `LayoutContext` that the tile in focus should be cleared.\n * @public\n */\nexport function useClearPinButton(props: ClearPinButtonProps) {\n  const { state, dispatch } = useLayoutContext().pin;\n\n  const buttonProps = React.useMemo(() => {\n    const { className } = setupClearPinButton();\n    const mergedProps = mergeProps(props, {\n      className,\n      disabled: !state?.length,\n      onClick: () => {\n        if (dispatch) dispatch({ msg: 'clear_pin' });\n      },\n    });\n    return mergedProps;\n  }, [props, dispatch, state]);\n\n  return { buttonProps };\n}\n","import { setupConnectionQualityIndicator } from '@livekit/components-core';\nimport type { Participant } from 'livekit-client';\nimport { ConnectionQuality } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureParticipant } from '../context';\nimport { useObservableState } from './internal';\n\n/** @public */\nexport interface ConnectionQualityIndicatorOptions {\n  participant?: Participant;\n}\n\n/**\n * The `useConnectionQualityIndicator` hook provides props for the `ConnectionQualityIndicator` or your custom implementation of it component.\n * @example\n * ```tsx\n * const { quality } = useConnectionQualityIndicator();\n * // or\n * const { quality } = useConnectionQualityIndicator({ participant });\n * ```\n * @public\n */\nexport function useConnectionQualityIndicator(options: ConnectionQualityIndicatorOptions = {}) {\n  const p = useEnsureParticipant(options.participant);\n\n  const { className, connectionQualityObserver } = React.useMemo(\n    () => setupConnectionQualityIndicator(p),\n    [p],\n  );\n\n  const quality = useObservableState(connectionQualityObserver, ConnectionQuality.Unknown);\n\n  return { className, quality };\n}\n","import { connectionStateObserver } from '@livekit/components-core';\nimport type { Room } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureRoom } from '../context';\nimport { useObservableState } from './internal';\n\n/**\n * The `useConnectionState` hook allows you to simply implement your own `ConnectionState` component.\n *\n * @example\n * ```tsx\n * const connectionState = useConnectionState(room);\n * ```\n * @public\n */\nexport function useConnectionState(room?: Room) {\n  // passed room takes precedence, if not supplied get current room context\n  const r = useEnsureRoom(room);\n  const observable = React.useMemo(() => connectionStateObserver(r), [r]);\n  const connectionState = useObservableState(observable, r.state);\n  return connectionState;\n}\n","import type { ReceivedDataMessage } from '@livekit/components-core';\nimport { setupDataMessageHandler } from '@livekit/components-core';\nimport * as React from 'react';\nimport type { DataPublishOptions } from 'livekit-client';\nimport { useRoomContext } from '../context';\nimport { useObservableState } from './internal';\n\ntype UseDataChannelReturnType<T extends string | undefined = undefined> = {\n  isSending: boolean;\n  send: (payload: Uint8Array, options: DataPublishOptions) => void;\n  message: ReceivedDataMessage<T> | undefined;\n};\n\n/**\n * The `useDataChannel` hook returns the ability to send and receive messages.\n * By optionally passing a `topic`, you can narrow down which messages are returned in the messages array.\n * @remarks\n * There is only one data channel. Passing a `topic` does not open a new data channel.\n * It is only used to filter out messages with no or a different `topic`.\n *\n * @example\n * ```tsx\n * // Send messages to all participants via the 'chat' topic.\n * const { message: latestMessage, send } = useDataChannel('chat', (msg) => console.log(\"message received\", msg));\n * ```\n * @public\n */\nexport function useDataChannel<T extends string>(\n  topic: T,\n  onMessage?: (msg: ReceivedDataMessage<T>) => void,\n): UseDataChannelReturnType<T>;\n/**\n * The `useDataChannel` hook returns the ability to send and receive messages.\n * @remarks\n * There is only one data channel. Passing a `topic` does not open a new data channel.\n * It is only used to filter out messages with no or a different `topic`.\n *\n * @example\n * ```tsx\n * // Send messages to all participants\n * const { message: latestMessage, send } = useDataChannel('chat', (msg) => console.log(\"message received\", msg));\n * ```\n * @public\n */\nexport function useDataChannel(\n  onMessage?: (msg: ReceivedDataMessage) => void,\n): UseDataChannelReturnType;\n/**\n * @internal\n */\nexport function useDataChannel<T extends string>(\n  topicOrCallback?: T | ((msg: ReceivedDataMessage) => void),\n  callback?: (msg: ReceivedDataMessage<T>) => void,\n) {\n  const onMessage = typeof topicOrCallback === 'function' ? topicOrCallback : callback;\n\n  const topic = typeof topicOrCallback === 'string' ? topicOrCallback : undefined;\n  const room = useRoomContext();\n  const { send, messageObservable, isSendingObservable } = React.useMemo(\n    () => setupDataMessageHandler(room, topic, onMessage),\n    [room, topic, onMessage],\n  );\n\n  const message = useObservableState(messageObservable, undefined);\n  const isSending = useObservableState(isSendingObservable, false);\n\n  return {\n    message,\n    send,\n    isSending,\n  };\n}\n","import { setupDisconnectButton } from '@livekit/components-core';\nimport { ConnectionState } from 'livekit-client';\nimport * as React from 'react';\nimport type { DisconnectButtonProps } from '../components';\nimport { useRoomContext } from '../context';\nimport { mergeProps } from '../mergeProps';\nimport { useConnectionState } from './useConnectionStatus';\n\n/**\n * The `useDisconnectButton` hook is used to implement the `DisconnectButton` or your\n * custom implementation of it. It adds onClick handler to the button to disconnect\n * from the room.\n *\n * @example\n * ```tsx\n * const { buttonProps } = useDisconnectButton(buttonProps);\n * return <button {...buttonProps}>Disconnect</button>;\n * ```\n * @public\n */\nexport function useDisconnectButton(props: DisconnectButtonProps) {\n  const room = useRoomContext();\n  const connectionState = useConnectionState(room);\n\n  const buttonProps = React.useMemo(() => {\n    const { className, disconnect } = setupDisconnectButton(room);\n    const mergedProps = mergeProps(props, {\n      className,\n      onClick: () => disconnect(props.stopTracks ?? true),\n      disabled: connectionState === ConnectionState.Disconnected,\n    });\n    return mergedProps;\n  }, [room, props, connectionState]);\n\n  return { buttonProps };\n}\n","import type { TrackReferenceOrPlaceholder } from '@livekit/components-core';\nimport { LocalTrackPublication, facingModeFromLocalTrack } from 'livekit-client';\n\n/**\n * Try to determine the `facingMode` of a local participant video track.\n * @remarks\n * Works only on local video tracks.\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}\n * @alpha\n */\nexport function useFacingMode(\n  trackReference: TrackReferenceOrPlaceholder,\n): 'user' | 'environment' | 'left' | 'right' | 'undefined' {\n  if (trackReference.publication instanceof LocalTrackPublication) {\n    const localTrack = trackReference.publication.track;\n    if (localTrack) {\n      const { facingMode } = facingModeFromLocalTrack(localTrack);\n      return facingMode;\n    }\n  }\n  return 'undefined';\n}\n","import type { TrackReferenceOrPlaceholder } from '@livekit/components-core';\nimport { setupFocusToggle, isTrackReferencePinned } from '@livekit/components-core';\nimport { useEnsureTrackRef, useMaybeLayoutContext } from '../context';\nimport { mergeProps } from '../mergeProps';\nimport * as React from 'react';\n\n/** @public */\nexport interface UseFocusToggleProps {\n  trackRef?: TrackReferenceOrPlaceholder;\n  props: React.ButtonHTMLAttributes<HTMLButtonElement>;\n}\n\n/**\n * The `useFocusToggle` hook is used to implement the `FocusToggle` or your custom implementation of it.\n * The `TrackReferenceOrPlaceholder` is used to register a onClick handler and to identify the track to focus on.\n *\n * @example\n * ```tsx\n * const { mergedProps, inFocus } = useFocusToggle({ trackRef, props: yourButtonProps });\n * return <button {...mergedProps}>{inFocus ? 'Unfocus' : 'Focus'}</button>;\n * ```\n * @public\n */\nexport function useFocusToggle({ trackRef, props }: UseFocusToggleProps) {\n  const trackReference = useEnsureTrackRef(trackRef);\n\n  const layoutContext = useMaybeLayoutContext();\n  const { className } = React.useMemo(() => setupFocusToggle(), []);\n\n  const inFocus: boolean = React.useMemo(() => {\n    return isTrackReferencePinned(trackReference, layoutContext?.pin.state);\n  }, [trackReference, layoutContext?.pin.state]);\n\n  const mergedProps = React.useMemo(\n    () =>\n      mergeProps(props, {\n        className,\n        onClick: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => {\n          // Call user defined on click callbacks.\n          props.onClick?.(event);\n\n          // Set or clear focus based on current focus state.\n          if (inFocus) {\n            layoutContext?.pin.dispatch?.({\n              msg: 'clear_pin',\n            });\n          } else {\n            layoutContext?.pin.dispatch?.({\n              msg: 'set_pin',\n              trackReference,\n            });\n          }\n        },\n      }),\n    [props, className, trackReference, inFocus, layoutContext?.pin],\n  );\n\n  return { mergedProps, inFocus };\n}\n","import { GRID_LAYOUTS, selectGridLayout } from '@livekit/components-core';\nimport type { GridLayoutDefinition, GridLayoutInfo } from '@livekit/components-core';\nimport * as React from 'react';\nimport { useSize } from './internal';\n\n/**\n * The `useGridLayout` hook tries to select the best layout to fit all tiles.\n * If the available screen space is not enough, it will reduce the number of maximum visible\n * tiles and select a layout that still works visually within the given limitations.\n * As the order of tiles changes over time, the hook tries to keep visual updates to a minimum\n * while trying to display important tiles such as speaking participants or screen shares.\n *\n * @example\n * ```tsx\n * const { layout } = useGridLayout(gridElement, trackCount);\n * ```\n * @public\n */\nexport function useGridLayout(\n  /** HTML element that contains the grid. */\n  gridElement: React.RefObject<HTMLDivElement>,\n  /** Count of tracks that should get layed out */\n  trackCount: number,\n  options: {\n    gridLayouts?: GridLayoutDefinition[];\n  } = {},\n): { layout: GridLayoutInfo; containerWidth: number; containerHeight: number } {\n  const gridLayouts = options.gridLayouts ?? GRID_LAYOUTS;\n  const { width, height } = useSize(gridElement);\n  const layout = selectGridLayout(gridLayouts, trackCount, width, height);\n\n  React.useEffect(() => {\n    if (gridElement.current && layout) {\n      gridElement.current.style.setProperty('--lk-col-count', layout?.columns.toString());\n      gridElement.current.style.setProperty('--lk-row-count', layout?.rows.toString());\n    }\n  }, [gridElement, layout]);\n\n  return {\n    layout,\n    containerWidth: width,\n    containerHeight: height,\n  };\n}\n","import {\n  type TrackReferenceOrPlaceholder,\n  getTrackReferenceId,\n  mutedObserver,\n} from '@livekit/components-core';\nimport type { Participant, Track } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureParticipant } from '../context';\n\n/** @public */\nexport interface UseIsMutedOptions {\n  participant?: Participant;\n}\n\n/**\n * The `useIsMuted` hook is used to implement the `TrackMutedIndicator` or your custom implementation of it.\n * It returns a `boolean` that indicates if the track is muted or not.\n *\n * @example\n * ```tsx\n * const isMuted = useIsMuted(track);\n * ```\n * @public\n */\nexport function useIsMuted(trackRef: TrackReferenceOrPlaceholder): boolean;\nexport function useIsMuted(\n  sourceOrTrackRef: TrackReferenceOrPlaceholder | Track.Source,\n  options: UseIsMutedOptions = {},\n) {\n  const passedParticipant =\n    typeof sourceOrTrackRef === 'string' ? options.participant : sourceOrTrackRef.participant;\n  const p = useEnsureParticipant(passedParticipant);\n  const ref =\n    typeof sourceOrTrackRef === 'string'\n      ? { participant: p, source: sourceOrTrackRef }\n      : sourceOrTrackRef;\n  const [isMuted, setIsMuted] = React.useState(\n    !!(ref.publication?.isMuted || p.getTrackPublication(ref.source)?.isMuted),\n  );\n\n  React.useEffect(() => {\n    const listener = mutedObserver(ref).subscribe(setIsMuted);\n    return () => listener.unsubscribe();\n  }, [getTrackReferenceId(ref)]);\n\n  return isMuted;\n}\n","import { createIsSpeakingObserver } from '@livekit/components-core';\nimport type { Participant } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureParticipant } from '../context';\nimport { useObservableState } from './internal';\n\n/**\n * The `useIsSpeaking` hook returns a `boolean` that indicates if the participant is speaking or not.\n * @example\n * ```tsx\n * const isSpeaking = useIsSpeaking(participant);\n * ```\n * @public\n */\nexport function useIsSpeaking(participant?: Participant) {\n  const p = useEnsureParticipant(participant);\n  const observable = React.useMemo(() => createIsSpeakingObserver(p), [p]);\n  const isSpeaking = useObservableState(observable, p.isSpeaking);\n\n  return isSpeaking;\n}\n","import type { ParticipantMedia } from '@livekit/components-core';\nimport { observeParticipantMedia } from '@livekit/components-core';\nimport type { TrackPublication, LocalParticipant, Room } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureRoom } from '../context';\n\n/** @public */\nexport interface UseLocalParticipantOptions {\n  /**\n   * The room to use. If not provided, the hook will use the room from the context.\n   */\n  room?: Room;\n}\n\n/**\n * The `useLocalParticipant` hook returns the local participant and the associated state\n * around the participant.\n *\n * @example\n * ```tsx\n * const { localParticipant } = useLocalParticipant();\n * ```\n * @public\n */\nexport function useLocalParticipant(options: UseLocalParticipantOptions = {}) {\n  const room = useEnsureRoom(options.room);\n  const [localParticipant, setLocalParticipant] = React.useState(room.localParticipant);\n  const [isMicrophoneEnabled, setIsMicrophoneEnabled] = React.useState(\n    localParticipant.isMicrophoneEnabled,\n  );\n  const [isCameraEnabled, setIsCameraEnabled] = React.useState(\n    localParticipant.isMicrophoneEnabled,\n  );\n  const [lastMicrophoneError, setLastMicrophoneError] = React.useState(\n    localParticipant.lastMicrophoneError,\n  );\n  const [lastCameraError, setLastCameraError] = React.useState(localParticipant.lastCameraError);\n  const [isScreenShareEnabled, setIsScreenShareEnabled] = React.useState(\n    localParticipant.isMicrophoneEnabled,\n  );\n  const [microphoneTrack, setMicrophoneTrack] = React.useState<TrackPublication | undefined>(\n    undefined,\n  );\n  const [cameraTrack, setCameraTrack] = React.useState<TrackPublication | undefined>(undefined);\n\n  const handleUpdate = (media: ParticipantMedia<LocalParticipant>) => {\n    setIsCameraEnabled(media.isCameraEnabled);\n    setIsMicrophoneEnabled(media.isMicrophoneEnabled);\n    setIsScreenShareEnabled(media.isScreenShareEnabled);\n    setCameraTrack(media.cameraTrack);\n    setMicrophoneTrack(media.microphoneTrack);\n    setLastMicrophoneError(media.participant.lastMicrophoneError);\n    setLastCameraError(media.participant.lastCameraError);\n    setLocalParticipant(media.participant);\n  };\n  React.useEffect(() => {\n    const listener = observeParticipantMedia(room.localParticipant).subscribe(handleUpdate);\n    // TODO also listen to permission and metadata etc. events\n    return () => listener.unsubscribe();\n  }, [room]);\n\n  return {\n    isMicrophoneEnabled,\n    isScreenShareEnabled,\n    isCameraEnabled,\n    microphoneTrack,\n    cameraTrack,\n    lastMicrophoneError,\n    lastCameraError,\n    localParticipant,\n  };\n}\n","import { participantPermissionObserver } from '@livekit/components-core';\nimport type { ParticipantPermission } from '@livekit/protocol';\nimport * as React from 'react';\nimport { useRoomContext } from '../context';\nimport { useObservableState } from './internal';\n\n/**\n * The `useLocalParticipantPermissions` hook returns the local participant's permissions.\n *\n * @example\n * ```tsx\n * const { canPublish, canPublishData } = useLocalParticipantPermissions();\n * ```\n * @public\n */\nexport function useLocalParticipantPermissions(): ParticipantPermission | undefined {\n  const room = useRoomContext();\n  const permissionObserver = React.useMemo(\n    () => participantPermissionObserver(room.localParticipant),\n    [room],\n  );\n  const permissions = useObservableState(permissionObserver, room.localParticipant.permissions);\n  return permissions;\n}\n","import { createMediaDeviceObserver, setupDeviceSelector, log } from '@livekit/components-core';\nimport type { LocalAudioTrack, LocalVideoTrack, Room } from 'livekit-client';\nimport * as React from 'react';\nimport { useMaybeRoomContext } from '../context';\nimport { useObservableState } from './internal';\n\n/** @public */\nexport interface UseMediaDeviceSelectProps {\n  kind: MediaDeviceKind;\n  room?: Room;\n  track?: LocalAudioTrack | LocalVideoTrack;\n  /**\n   * this will call getUserMedia if the permissions are not yet given to enumerate the devices with device labels.\n   * in some browsers multiple calls to getUserMedia result in multiple permission prompts.\n   * It's generally advised only flip this to true, once a (preview) track has been acquired successfully with the\n   * appropriate permissions.\n   *\n   * @see {@link MediaDeviceMenu}\n   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices | MDN enumerateDevices}\n   */\n  requestPermissions?: boolean;\n  /**\n   * this callback gets called if an error is thrown when failing to select a device and also if a user\n   * denied permissions, eventhough the `requestPermissions` option is set to `true`.\n   * Most commonly this will emit a MediaDeviceError\n   */\n  onError?: (e: Error) => void;\n}\n\n/**\n * The `useMediaDeviceSelect` hook is used to implement the `MediaDeviceSelect` component and\n * returns o.a. the list of devices of a given kind (audioinput or videoinput), the currently active device\n * and a function to set the the active device.\n *\n * @example\n * ```tsx\n * const { devices, activeDeviceId, setActiveMediaDevice } = useMediaDeviceSelect({kind: 'audioinput'});\n * ```\n * @public\n */\nexport function useMediaDeviceSelect({\n  kind,\n  room,\n  track,\n  requestPermissions,\n  onError,\n}: UseMediaDeviceSelectProps) {\n  const roomContext = useMaybeRoomContext();\n  // List of all devices.\n  const deviceObserver = React.useMemo(\n    () => createMediaDeviceObserver(kind, onError, requestPermissions),\n    [kind, requestPermissions, onError],\n  );\n  const devices = useObservableState(deviceObserver, [] as MediaDeviceInfo[]);\n  // Active device management.\n  const [currentDeviceId, setCurrentDeviceId] = React.useState<string>('');\n  const { className, activeDeviceObservable, setActiveMediaDevice } = React.useMemo(\n    () => setupDeviceSelector(kind, room ?? roomContext, track),\n    [kind, room, roomContext, track],\n  );\n\n  React.useEffect(() => {\n    const listener = activeDeviceObservable.subscribe((deviceId) => {\n      log.info('setCurrentDeviceId', deviceId);\n      if (deviceId) setCurrentDeviceId(deviceId);\n    });\n    return () => {\n      listener?.unsubscribe();\n    };\n  }, [activeDeviceObservable]);\n\n  return { devices, className, activeDeviceId: currentDeviceId, setActiveMediaDevice };\n}\n","import * as React from 'react';\nimport { useObservableState } from './internal';\nimport { createMediaDeviceObserver } from '@livekit/components-core';\n\n/**\n * The `useMediaDevices` hook returns the list of media devices of a given kind.\n *\n * @example\n * ```tsx\n * const videoDevices = useMediaDevices({ kind: 'videoinput' });\n * const audioDevices = useMediaDevices({ kind: 'audioinput' });\n * ```\n * @public\n */\nexport function useMediaDevices({\n  kind,\n  onError,\n}: {\n  kind: MediaDeviceKind;\n  onError?: (e: Error) => void;\n}) {\n  const deviceObserver = React.useMemo(\n    () => createMediaDeviceObserver(kind, onError),\n    [kind, onError],\n  );\n  const devices = useObservableState(deviceObserver, [] as MediaDeviceInfo[]);\n  return devices;\n}\n","import type { TrackReferenceOrPlaceholder } from '@livekit/components-core';\nimport { log, sortTrackReferences, updatePages } from '@livekit/components-core';\nimport * as React from 'react';\n\n/** @public */\nexport interface UseVisualStableUpdateOptions {\n  /** Overwrites the default sort function. */\n  customSortFunction?: (\n    trackReferences: TrackReferenceOrPlaceholder[],\n  ) => TrackReferenceOrPlaceholder[];\n}\n\n/**\n * The `useVisualStableUpdate` hook is used to prevent visually jarring jumps and shifts of elements\n * in an array. The algorithm only starts to update when there are more items than visually fit\n * on a page. If this is the case, it will make sure that speaking participants move to the first\n * page and are always visible.\n * @remarks\n * Updating the array can occur because attendees leave or join a room, or because they mute/unmute\n * or start speaking.\n * The hook is used for the `GridLayout` and `CarouselLayout` components.\n *\n * @example\n * ```tsx\n * const trackRefs = useTracks();\n * const updatedTrackRefs = useVisualStableUpdate(trackRefs, itemPerPage);\n * ```\n * @public\n */\nexport function useVisualStableUpdate(\n  /** `TrackReference`s to display in the grid.  */\n  trackReferences: TrackReferenceOrPlaceholder[],\n  maxItemsOnPage: number,\n  options: UseVisualStableUpdateOptions = {},\n): TrackReferenceOrPlaceholder[] {\n  const lastTrackRefs = React.useRef<TrackReferenceOrPlaceholder[]>([]);\n  const lastMaxItemsOnPage = React.useRef<number>(-1);\n  const layoutChanged = maxItemsOnPage !== lastMaxItemsOnPage.current;\n\n  const sortedTrackRefs =\n    typeof options.customSortFunction === 'function'\n      ? options.customSortFunction(trackReferences)\n      : sortTrackReferences(trackReferences);\n\n  let updatedTrackRefs: TrackReferenceOrPlaceholder[] = [...sortedTrackRefs];\n  if (layoutChanged === false) {\n    try {\n      updatedTrackRefs = updatePages(lastTrackRefs.current, sortedTrackRefs, maxItemsOnPage);\n    } catch (error) {\n      log.error('Error while running updatePages(): ', error);\n    }\n  }\n\n  // Save info for to compare against in the next update cycle.\n  if (layoutChanged) {\n    lastTrackRefs.current = sortedTrackRefs;\n  } else {\n    lastTrackRefs.current = updatedTrackRefs;\n  }\n  lastMaxItemsOnPage.current = maxItemsOnPage;\n\n  return updatedTrackRefs;\n}\n","import type { TrackReferenceOrPlaceholder } from '@livekit/components-core';\nimport * as React from 'react';\nimport { useVisualStableUpdate } from './useVisualStableUpdate';\n\n/**\n * The `usePagination` hook implements simple pagination logic for use with arrays.\n * @example\n * ```tsx\n * const tracks = useTracks();\n * const pagination = usePagination(4, tracks);\n *\n * <TrackLoop tracks={pagination.tracks} />\n * ```\n * @alpha\n */\nexport function usePagination(itemPerPage: number, trackReferences: TrackReferenceOrPlaceholder[]) {\n  const [currentPage, setCurrentPage] = React.useState(1);\n  const totalPageCount = Math.max(Math.ceil(trackReferences.length / itemPerPage), 1);\n  if (currentPage > totalPageCount) {\n    setCurrentPage(totalPageCount);\n  }\n  const lastItemIndex = currentPage * itemPerPage;\n  const firstItemIndex = lastItemIndex - itemPerPage;\n\n  const changePage = (direction: 'next' | 'previous') => {\n    setCurrentPage((state) => {\n      if (direction === 'next') {\n        if (state === totalPageCount) {\n          return state;\n        }\n        return state + 1;\n      } else {\n        if (state === 1) {\n          return state;\n        }\n        return state - 1;\n      }\n    });\n  };\n\n  const goToPage = (num: number) => {\n    if (num > totalPageCount) {\n      setCurrentPage(totalPageCount);\n    } else if (num < 1) {\n      setCurrentPage(1);\n    } else {\n      setCurrentPage(num);\n    }\n  };\n\n  const updatedTrackReferences = useVisualStableUpdate(trackReferences, itemPerPage);\n\n  const tracksOnPage = updatedTrackReferences.slice(firstItemIndex, lastItemIndex);\n\n  return {\n    totalPageCount,\n    nextPage: () => changePage('next'),\n    prevPage: () => changePage('previous'),\n    setPage: goToPage,\n    firstItemIndex,\n    lastItemIndex,\n    tracks: tracksOnPage,\n    currentPage,\n  };\n}\n\nexport default usePagination;\n","import { participantInfoObserver } from '@livekit/components-core';\nimport type { Participant } from 'livekit-client';\nimport * as React from 'react';\nimport { useMaybeParticipantContext } from '../context';\nimport { useObservableState } from './internal';\n\n/**\n * The `useParticipantInfo` hook returns the identity, name, and metadata of a given participant.\n * It requires a `Participant` object passed as property or via the `ParticipantContext`.\n *\n * @example\n * ```tsx\n * const { identity, name, metadata } = useParticipantInfo({ participant });\n * ```\n * @public\n */\nexport interface UseParticipantInfoOptions {\n  participant?: Participant;\n}\n\n/** @public */\nexport function useParticipantInfo(props: UseParticipantInfoOptions = {}) {\n  let p = useMaybeParticipantContext();\n  if (props.participant) {\n    p = props.participant;\n  }\n  const infoObserver = React.useMemo(() => participantInfoObserver(p), [p]);\n  const { identity, name, metadata } = useObservableState(infoObserver, {\n    name: p?.name,\n    identity: p?.identity,\n    metadata: p?.metadata,\n  });\n\n  return { identity, name, metadata };\n}\n","import { participantPermissionObserver } from '@livekit/components-core';\nimport type { ParticipantPermission } from '@livekit/protocol';\nimport type { Participant } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureParticipant } from '../context';\nimport { useObservableState } from './internal/useObservableState';\n\n/**\n * The `useParticipantPermissions` hook returns the permissions of a given participant.\n *\n * @example\n * ```tsx\n * const permissions = useParticipantPermissions({ participant });\n * ```\n * @public\n */\nexport interface UseParticipantPermissionsOptions {\n  participant?: Participant;\n}\n\n/** @public */\nexport function useParticipantPermissions(\n  options: UseParticipantPermissionsOptions = {},\n): ParticipantPermission | undefined {\n  const p = useEnsureParticipant(options.participant);\n  const permissionObserver = React.useMemo(() => participantPermissionObserver(p), [p]);\n  const permissions = useObservableState(permissionObserver, p.permissions);\n  return permissions;\n}\n","import type { ParticipantClickEvent, TrackReferenceOrPlaceholder } from '@livekit/components-core';\nimport { setupParticipantTile } from '@livekit/components-core';\nimport * as React from 'react';\nimport { useEnsureTrackRef } from '../context';\nimport { mergeProps } from '../mergeProps';\nimport { useFacingMode } from './useFacingMode';\nimport { useIsMuted } from './useIsMuted';\nimport { useIsSpeaking } from './useIsSpeaking';\nimport { Track } from 'livekit-client';\n\n/** @public */\nexport interface UseParticipantTileProps<T extends HTMLElement> extends React.HTMLAttributes<T> {\n  /** The track reference to display. */\n  trackRef?: TrackReferenceOrPlaceholder;\n  disableSpeakingIndicator?: boolean;\n  onParticipantClick?: (event: ParticipantClickEvent) => void;\n  htmlProps: React.HTMLAttributes<T>;\n}\n\n/**\n * The `useParticipantTile` hook is used to implement the `ParticipantTile` and returns the props needed to render the tile.\n * @remarks\n * The returned props include many data attributes that are useful for CSS styling purposes because they\n * indicate the state of the participant and the track.\n * For example: `data-lk-audio-muted`, `data-lk-video-muted`, `data-lk-speaking`, `data-lk-local-participant`, `data-lk-source`, `data-lk-facing-mode`.\n * @public\n */\nexport function useParticipantTile<T extends HTMLElement>({\n  trackRef,\n  onParticipantClick,\n  disableSpeakingIndicator,\n  htmlProps,\n}: UseParticipantTileProps<T>) {\n  const trackReference = useEnsureTrackRef(trackRef);\n\n  const mergedProps = React.useMemo(() => {\n    const { className } = setupParticipantTile();\n    return mergeProps(htmlProps, {\n      className,\n      onClick: (event: React.MouseEvent<T, MouseEvent>) => {\n        htmlProps.onClick?.(event);\n        if (typeof onParticipantClick === 'function') {\n          const track =\n            trackReference.publication ??\n            trackReference.participant.getTrackPublication(trackReference.source);\n          onParticipantClick({ participant: trackReference.participant, track });\n        }\n      },\n    });\n  }, [\n    htmlProps,\n    onParticipantClick,\n    trackReference.publication,\n    trackReference.source,\n    trackReference.participant,\n  ]);\n\n  const micTrack = trackReference.participant.getTrackPublication(Track.Source.Microphone);\n  const micRef = React.useMemo(() => {\n    return {\n      participant: trackReference.participant,\n      source: Track.Source.Microphone,\n      publication: micTrack,\n    };\n  }, [micTrack, trackReference.participant]);\n  const isVideoMuted = useIsMuted(trackReference);\n  const isAudioMuted = useIsMuted(micRef);\n  const isSpeaking = useIsSpeaking(trackReference.participant);\n  const facingMode = useFacingMode(trackReference);\n  return {\n    elementProps: {\n      'data-lk-audio-muted': isAudioMuted,\n      'data-lk-video-muted': isVideoMuted,\n      'data-lk-speaking': disableSpeakingIndicator === true ? false : isSpeaking,\n      'data-lk-local-participant': trackReference.participant.isLocal,\n      'data-lk-source': trackReference.source,\n      'data-lk-facing-mode': facingMode,\n      ...mergedProps,\n    } as React.HTMLAttributes<T>,\n  };\n}\n","import { connectedParticipantsObserver } from '@livekit/components-core';\nimport type { RoomEvent, RemoteParticipant, Room } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureRoom } from '../context';\n\n/** @public */\nexport interface UseRemoteParticipantsOptions {\n  /**\n   * To optimize performance, you can use the `updateOnlyOn` property to decide on what RoomEvents the hook updates.\n   * By default it updates on all relevant RoomEvents to keep the returned participants array up to date.\n   * The minimal set of non-overwriteable `RoomEvents` is: `[RoomEvent.ParticipantConnected, RoomEvent.ParticipantDisconnected, RoomEvent.ConnectionStateChanged]`\n   */\n  updateOnlyOn?: RoomEvent[];\n  /**\n   * The room to use. If not provided, the hook will use the room from the context.\n   */\n  room?: Room;\n}\n\n/**\n * The `useRemoteParticipants` hook returns all remote participants (without the local) of the current room.\n * @remarks\n * To optimize performance, you can use the `updateOnlyOn` property to decide on what `RoomEvents` the hook updates.\n *\n * @example\n * ```tsx\n * const participants = useRemoteParticipants();\n * <ParticipantLoop participants={participants}>\n *  <ParticipantName />\n * </ParticipantLoop>\n * ```\n * @public\n */\nexport function useRemoteParticipants(options: UseRemoteParticipantsOptions = {}) {\n  const room = useEnsureRoom(options.room);\n  const [participants, setParticipants] = React.useState<RemoteParticipant[]>([]);\n\n  React.useEffect(() => {\n    const listener = connectedParticipantsObserver(room, {\n      additionalRoomEvents: options.updateOnlyOn,\n    }).subscribe(setParticipants);\n    return () => listener.unsubscribe();\n  }, [room, JSON.stringify(options.updateOnlyOn)]);\n  return participants;\n}\n","import type { Room, RoomEvent } from 'livekit-client';\nimport { useLocalParticipant } from './useLocalParticipant';\nimport { useRemoteParticipants } from './useRemoteParticipants';\nimport * as React from 'react';\n\n/** @public */\nexport interface UseParticipantsOptions {\n  /**\n   * To optimize performance, you can use the `updateOnlyOn` property to decide on what RoomEvents the hook updates.\n   * By default it updates on all relevant RoomEvents to keep the returned participants array up to date.\n   * The minimal set of non-overwriteable `RoomEvents` is: `[RoomEvent.ParticipantConnected, RoomEvent.ParticipantDisconnected, RoomEvent.ConnectionStateChanged]`\n   */\n  updateOnlyOn?: RoomEvent[];\n  /**\n   * The room to use. If not provided, the hook will use the room from the context.\n   */\n  room?: Room;\n}\n\n/**\n * The `useParticipants` hook returns all participants (local and remote) of the current room.\n * @remarks\n * To optimize performance, you can use the `updateOnlyOn` property to decide on what `RoomEvents` the hook updates.\n *\n * @example\n * ```tsx\n * const participants = useParticipants();\n * <ParticipantLoop participants={participants}>\n *  <ParticipantName />\n * </ParticipantLoop>\n * ```\n * @public\n */\nexport function useParticipants(options: UseParticipantsOptions = {}) {\n  const remoteParticipants = useRemoteParticipants(options);\n  const { localParticipant } = useLocalParticipant(options);\n\n  return React.useMemo(\n    () => [localParticipant, ...remoteParticipants],\n    [localParticipant, remoteParticipants],\n  );\n}\n","import type { TrackReferenceOrPlaceholder } from '@livekit/components-core';\nimport * as React from 'react';\nimport type { LayoutContextType } from '../context';\nimport { useEnsureLayoutContext } from '../context';\n\n/**\n * The `usePinnedTracks` hook returns a array of the pinned tracks of the current room.\n * @remarks\n * To function properly, this hook must be called within a `LayoutContext`.\n * @example\n * ```tsx\n * const pinnedTracks = usePinnedTracks();\n * ```\n * @public\n */\nexport function usePinnedTracks(layoutContext?: LayoutContextType): TrackReferenceOrPlaceholder[] {\n  layoutContext = useEnsureLayoutContext(layoutContext);\n  return React.useMemo(() => {\n    if (layoutContext?.pin.state !== undefined && layoutContext.pin.state.length >= 1) {\n      return layoutContext.pin.state;\n    }\n    return [];\n  }, [layoutContext.pin.state]);\n}\n","import {\n  type ParticipantIdentifier,\n  connectedParticipantObserver,\n  participantByIdentifierObserver,\n} from '@livekit/components-core';\nimport type { ParticipantEvent, RemoteParticipant } from 'livekit-client';\nimport * as React from 'react';\nimport { useRoomContext } from '../context';\n\n/** @public */\nexport interface UseRemoteParticipantOptions {\n  /**\n   * To optimize performance, you can use the `updateOnlyOn` property to decide on what `ParticipantEvents` the hook updates.\n   * By default it updates on all relevant ParticipantEvents to keep the returned participant up to date.\n   */\n  updateOnlyOn?: ParticipantEvent[];\n}\n\n/**\n * The `useRemoteParticipant` hook returns the first RemoteParticipant by either identity and/or based on the participant kind.\n * @remarks\n * To optimize performance, you can use the `updateOnlyOn` property to decide on what `ParticipantEvents` the hook updates.\n *\n * @example\n * ```tsx\n * const participant = useRemoteParticipant({kind: ParticipantKind.Agent, identity: 'myAgent'});\n * ```\n * @public\n */\nexport function useRemoteParticipant(\n  identifier: ParticipantIdentifier,\n  options?: UseRemoteParticipantOptions,\n): RemoteParticipant | undefined;\n/**\n * The `useRemoteParticipant` hook returns the first RemoteParticipant by either identity or based on the participant kind.\n * @remarks\n * To optimize performance, you can use the `updateOnlyOn` property to decide on what `ParticipantEvents` the hook updates.\n *\n * @example\n * ```tsx\n * const participant = useRemoteParticipant('Russ');\n * ```\n * @public\n */\nexport function useRemoteParticipant(\n  identity: string,\n  options?: UseRemoteParticipantOptions,\n): RemoteParticipant | undefined;\nexport function useRemoteParticipant(\n  identityOrIdentifier: string | ParticipantIdentifier,\n  options: UseRemoteParticipantOptions = {},\n): RemoteParticipant | undefined {\n  const room = useRoomContext();\n  const [updateOnlyOn] = React.useState(options.updateOnlyOn);\n\n  const observable = React.useMemo(() => {\n    if (typeof identityOrIdentifier === 'string') {\n      return connectedParticipantObserver(room, identityOrIdentifier, {\n        additionalEvents: updateOnlyOn,\n      });\n    } else {\n      return participantByIdentifierObserver(room, identityOrIdentifier, {\n        additionalEvents: updateOnlyOn,\n      });\n    }\n  }, [room, JSON.stringify(identityOrIdentifier), updateOnlyOn]);\n\n  // Using `wrapperParticipant` to ensure a new object reference,\n  // triggering a re-render when the participant events fire.\n  const [participantWrapper, setParticipantWrapper] = React.useState({\n    p: undefined as RemoteParticipant | undefined,\n  });\n  React.useEffect(() => {\n    const listener = observable.subscribe((p) => setParticipantWrapper({ p }));\n    return () => listener.unsubscribe();\n  }, [observable]);\n\n  return participantWrapper.p;\n}\n","import { roomInfoObserver } from '@livekit/components-core';\nimport type { Room } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureRoom } from '../context';\nimport { useObservableState } from './internal';\n\n/**\n * The `useRoomInfo` hook returns the name and metadata of the given `Room`.\n * @remarks\n * Needs to be called inside a `RoomContext` or by passing a `Room` instance.\n *\n * @example\n * ```tsx\n * const { name, metadata } = useRoomInfo();\n * ```\n * @public\n */\nexport interface UseRoomInfoOptions {\n  room?: Room;\n}\n\n/** @public */\nexport function useRoomInfo(options: UseRoomInfoOptions = {}) {\n  const room = useEnsureRoom(options.room);\n  const infoObserver = React.useMemo(() => roomInfoObserver(room), [room]);\n  const { name, metadata } = useObservableState(infoObserver, {\n    name: room.name,\n    metadata: room.metadata,\n  });\n\n  return { name, metadata };\n}\n","import { activeSpeakerObserver } from '@livekit/components-core';\nimport * as React from 'react';\nimport { useRoomContext } from '../context';\nimport { useObservableState } from './internal';\n\n/**\n * The `useSpeakingParticipants` hook returns the only the active speakers of all participants.\n *\n * @example\n * ```tsx\n * const activeSpeakers = useSpeakingParticipants();\n * ```\n * @public\n */\nexport function useSpeakingParticipants() {\n  const room = useRoomContext();\n  const speakerObserver = React.useMemo(() => activeSpeakerObserver(room), [room]);\n  const activeSpeakers = useObservableState(speakerObserver, room.activeSpeakers);\n  return activeSpeakers;\n}\n","import { sortParticipants } from '@livekit/components-core';\nimport type { Participant } from 'livekit-client';\nimport * as React from 'react';\nimport { useSpeakingParticipants } from './useSpeakingParticipants';\n\n/**\n * The `useSortedParticipants` hook returns the participants sorted by importance.\n * @public\n */\nexport function useSortedParticipants(participants: Array<Participant>) {\n  const [sortedParticipants, setSortedParticipants] = React.useState(\n    sortParticipants(participants),\n  );\n  const activeSpeakers = useSpeakingParticipants();\n\n  React.useEffect(() => {\n    setSortedParticipants(sortParticipants(participants));\n  }, [activeSpeakers, participants]);\n  return sortedParticipants;\n}\n","import { setupStartAudio } from '@livekit/components-core';\nimport type { Room } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureRoom } from '../context';\nimport { mergeProps } from '../mergeProps';\nimport { useObservableState } from './internal';\n\n/** @alpha */\nexport interface UseStartAudioProps {\n  room?: Room;\n  props: React.ButtonHTMLAttributes<HTMLButtonElement>;\n}\n\n/**\n * In many browsers to start audio playback, the user must perform a user-initiated event such as clicking a button.\n * The `useStatAudio` hook returns an object with a boolean `canPlayAudio` flag\n * that indicates whether audio playback is allowed in the current context,\n * as well as a `startAudio` function that can be called in a button `onClick` callback to start audio playback in the current context.\n *\n * @see Autoplay policy on MDN web docs for more info: {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Best_practices#autoplay_policy}\n * @alpha\n */\nexport function useStartAudio({ room, props }: UseStartAudioProps) {\n  const roomEnsured = useEnsureRoom(room);\n  const { className, roomAudioPlaybackAllowedObservable, handleStartAudioPlayback } = React.useMemo(\n    () => setupStartAudio(),\n    [],\n  );\n  const observable = React.useMemo(\n    () => roomAudioPlaybackAllowedObservable(roomEnsured),\n    [roomEnsured, roomAudioPlaybackAllowedObservable],\n  );\n  const { canPlayAudio } = useObservableState(observable, {\n    canPlayAudio: roomEnsured.canPlaybackAudio,\n  });\n\n  const mergedProps = React.useMemo(\n    () =>\n      mergeProps(props, {\n        className,\n        onClick: () => {\n          handleStartAudioPlayback(roomEnsured);\n        },\n        style: { display: canPlayAudio ? 'none' : 'block' },\n      }),\n    [props, className, canPlayAudio, handleStartAudioPlayback, roomEnsured],\n  );\n\n  return { mergedProps, canPlayAudio };\n}\n","import { setupStartVideo } from '@livekit/components-core';\nimport type { Room } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureRoom } from '../context';\nimport { mergeProps } from '../mergeProps';\nimport { useObservableState } from './internal';\n\n/** @alpha */\nexport interface UseStartVideoProps {\n  room?: Room;\n  props: React.ButtonHTMLAttributes<HTMLButtonElement>;\n}\n\n/**\n * In some browsers to start video playback in low power mode, the user must perform a user-initiated event such as clicking a button.\n * The `useStartVideo` hook returns an object with a boolean `canPlayVideo` flag\n * that indicates whether video playback is allowed in the current context,\n * as well as a `startVideo` function that can be called in a button `onClick` callback to start video playback in the current context.\n *\n * @alpha\n */\nexport function useStartVideo({ room, props }: UseStartVideoProps) {\n  const roomEnsured = useEnsureRoom(room);\n  const { className, roomVideoPlaybackAllowedObservable, handleStartVideoPlayback } = React.useMemo(\n    () => setupStartVideo(),\n    [],\n  );\n  const observable = React.useMemo(\n    () => roomVideoPlaybackAllowedObservable(roomEnsured),\n    [roomEnsured, roomVideoPlaybackAllowedObservable],\n  );\n  const { canPlayVideo } = useObservableState(observable, {\n    canPlayVideo: roomEnsured.canPlaybackVideo,\n  });\n\n  const mergedProps = React.useMemo(\n    () =>\n      mergeProps(props, {\n        className,\n        onClick: () => {\n          handleStartVideoPlayback(roomEnsured);\n        },\n        style: { display: canPlayVideo ? 'none' : 'block' },\n      }),\n    [props, className, canPlayVideo, handleStartVideoPlayback, roomEnsured],\n  );\n\n  return { mergedProps, canPlayVideo };\n}\n","import * as React from 'react';\n\n/**\n * @alpha\n */\nexport type UseSwipeOptions = {\n  minSwipeDistance?: number;\n  onLeftSwipe?: () => void;\n  onRightSwipe?: () => void;\n};\n\n/**\n * Simple implementation to detect horizontal swipe actions.\n * Accepts callbacks for on right and left swipes.\n * @example\n * ```tsx\n *  <div\n      onTouchStart={onTouchStart}\n      onTouchMove={onTouchMove}\n      onTouchEnd={onTouchEnd}\n    >\n * ```\n * @alpha\n */\nexport function useSwipe(element: React.RefObject<HTMLElement>, options: UseSwipeOptions = {}) {\n  const touchStart = React.useRef<number | null>(null);\n  const touchEnd = React.useRef<number | null>(null);\n\n  // The required distance between touchStart and touchEnd to be detected as a swipe.\n  const minSwipeDistance = options.minSwipeDistance ?? 50;\n\n  const onTouchStart = (event: TouchEvent) => {\n    touchEnd.current = null; // Otherwise the swipe is fired even with usual touch events.\n    touchStart.current = event.targetTouches[0].clientX;\n  };\n\n  const onTouchMove = (event: TouchEvent) => {\n    touchEnd.current = event.targetTouches[0].clientX;\n  };\n\n  const onTouchEnd = React.useCallback(() => {\n    if (!touchStart.current || !touchEnd.current) {\n      return;\n    }\n    const distance = touchStart.current - touchEnd.current;\n    const isLeftSwipe = distance > minSwipeDistance;\n    const isRightSwipe = distance < -minSwipeDistance;\n\n    if (isLeftSwipe && options.onLeftSwipe) options.onLeftSwipe();\n    if (isRightSwipe && options.onRightSwipe) options.onRightSwipe();\n  }, [minSwipeDistance, options]);\n\n  React.useEffect(() => {\n    const elementCopy = element.current;\n    if (elementCopy) {\n      elementCopy.addEventListener('touchstart', onTouchStart, { passive: true });\n      elementCopy.addEventListener('touchmove', onTouchMove, { passive: true });\n      elementCopy.addEventListener('touchend', onTouchEnd, { passive: true });\n    }\n    return () => {\n      if (elementCopy) {\n        elementCopy.removeEventListener('touchstart', onTouchStart);\n        elementCopy.removeEventListener('touchmove', onTouchMove);\n        elementCopy.removeEventListener('touchend', onTouchEnd);\n      }\n    };\n  }, [element, onTouchEnd]);\n}\n","import { setupChatToggle } from '@livekit/components-core';\nimport { useLayoutContext } from '../context';\nimport { mergeProps } from '../mergeProps';\nimport * as React from 'react';\n\n/** @public */\nexport interface UseChatToggleProps {\n  props: React.ButtonHTMLAttributes<HTMLButtonElement>;\n}\n\n/**\n * The `useChatToggle` hook provides state and functions for toggling the chat window.\n * @remarks\n * Depends on the `LayoutContext` to work properly.\n * @see {@link ChatToggle}, {@link Chat}\n * @public\n */\nexport function useChatToggle({ props }: UseChatToggleProps) {\n  const { dispatch, state } = useLayoutContext().widget;\n  const { className } = React.useMemo(() => setupChatToggle(), []);\n\n  const mergedProps = React.useMemo(() => {\n    return mergeProps(props, {\n      className,\n      onClick: () => {\n        if (dispatch) dispatch({ msg: 'toggle_chat' });\n      },\n      'aria-pressed': state?.showChat ? 'true' : 'false',\n      'data-lk-unread-msgs': state\n        ? state.unreadMessages < 10\n          ? state.unreadMessages.toFixed(0)\n          : '9+'\n        : '0',\n    });\n  }, [props, className, dispatch, state]);\n\n  return { mergedProps };\n}\n","import { log } from '@livekit/components-core';\nimport * as React from 'react';\n\n/** @public */\nexport interface UserInfo {\n  identity?: string;\n  name?: string;\n  metadata?: string;\n}\n\n/** @public */\nexport interface UseTokenOptions {\n  userInfo?: UserInfo;\n}\n\n/**\n * The `useToken` hook fetches a token from the given token endpoint with the given user info.\n *\n * @example\n * ```tsx\n * const token = useToken(<token-endpoint>, roomName, { userInfo: { identity, name }});\n * ```\n * @public */\nexport function useToken(\n  tokenEndpoint: string | undefined,\n  roomName: string,\n  options: UseTokenOptions = {},\n) {\n  const [token, setToken] = React.useState<string | undefined>(undefined);\n\n  React.useEffect(() => {\n    if (tokenEndpoint === undefined) {\n      throw Error('token endpoint needs to be defined');\n    }\n    if (options.userInfo?.identity === undefined) {\n      return;\n    }\n    const tokenFetcher = async () => {\n      log.debug('fetching token');\n      const params = new URLSearchParams({ ...options.userInfo, roomName });\n      const res = await fetch(`${tokenEndpoint}?${params.toString()}`);\n      if (!res.ok) {\n        log.error(\n          `Could not fetch token. Server responded with status ${res.status}: ${res.statusText}`,\n        );\n        return;\n      }\n      const { accessToken } = await res.json();\n      setToken(accessToken);\n    };\n    tokenFetcher();\n  }, [tokenEndpoint, roomName, JSON.stringify(options)]);\n  return token;\n}\n","import {\n  type TrackReferenceOrPlaceholder,\n  setupTrackMutedIndicator,\n  getTrackReferenceId,\n} from '@livekit/components-core';\nimport * as React from 'react';\nimport { useEnsureTrackRef } from '../context';\nimport { useObservableState } from './internal';\n\ninterface TrackMutedIndicatorReturnType {\n  isMuted: boolean;\n  className: string;\n}\n\n/**\n * The `useTrackMutedIndicator` hook is used to implement the `TrackMutedIndicator` component\n * and returns the muted state of the given track.\n *\n * @example\n * ```tsx\n * const { isMuted } = useTrackMutedIndicator(trackRef);\n * ```\n * @public\n */\nexport function useTrackMutedIndicator(\n  trackRef?: TrackReferenceOrPlaceholder,\n): TrackMutedIndicatorReturnType {\n  const trackReference = useEnsureTrackRef(trackRef);\n\n  const { className, mediaMutedObserver } = React.useMemo(\n    () => setupTrackMutedIndicator(trackReference),\n    [getTrackReferenceId(trackReference)],\n  );\n\n  const isMuted = useObservableState(\n    mediaMutedObserver,\n    !!(\n      trackReference.publication?.isMuted ||\n      trackReference.participant.getTrackPublication(trackReference.source)?.isMuted\n    ),\n  );\n\n  return { isMuted, className };\n}\n","import type { ToggleSource } from '@livekit/components-core';\nimport { setupMediaToggle, setupManualToggle, log } from '@livekit/components-core';\nimport * as React from 'react';\nimport type { TrackToggleProps } from '../components';\nimport { useMaybeRoomContext } from '../context';\nimport { mergeProps } from '../mergeProps';\nimport { useObservableState } from './internal';\n\n/** @public */\nexport interface UseTrackToggleProps<T extends ToggleSource>\n  extends Omit<TrackToggleProps<T>, 'showIcon'> {}\n\n/**\n * The `useTrackToggle` hook is used to implement the `TrackToggle` component and returns state\n * and functionality of the given track.\n *\n * @example\n * ```tsx\n * const { buttonProps, enabled } = useTrackToggle(trackRef);\n * return <button {...buttonProps}>{enabled ? 'disable' : 'enable'}</button>;\n * ```\n * @public\n */\nexport function useTrackToggle<T extends ToggleSource>({\n  source,\n  onChange,\n  initialState,\n  captureOptions,\n  publishOptions,\n  onDeviceError,\n  ...rest\n}: UseTrackToggleProps<T>) {\n  const room = useMaybeRoomContext();\n  const track = room?.localParticipant?.getTrackPublication(source);\n  /** `true` if a user interaction such as a click on the TrackToggle button has occurred. */\n  const userInteractionRef = React.useRef(false);\n\n  const { toggle, className, pendingObserver, enabledObserver } = React.useMemo(\n    () =>\n      room\n        ? setupMediaToggle<T>(source, room, captureOptions, publishOptions, onDeviceError)\n        : setupManualToggle(),\n    [room, source, JSON.stringify(captureOptions), publishOptions],\n  );\n\n  const pending = useObservableState(pendingObserver, false);\n  const enabled = useObservableState(enabledObserver, initialState ?? !!track?.isEnabled);\n\n  React.useEffect(() => {\n    onChange?.(enabled, userInteractionRef.current);\n    userInteractionRef.current = false;\n  }, [enabled, onChange]);\n\n  React.useEffect(() => {\n    if (initialState !== undefined) {\n      log.debug('forcing initial toggle state', source, initialState);\n      toggle(initialState);\n    }\n    // only execute once at the beginning\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  const newProps = React.useMemo(() => mergeProps(rest, { className }), [rest, className]);\n\n  const clickHandler: React.MouseEventHandler<HTMLButtonElement> = React.useCallback(\n    (evt) => {\n      userInteractionRef.current = true;\n      toggle().catch(() => (userInteractionRef.current = false));\n      rest.onClick?.(evt);\n    },\n    [rest, toggle],\n  );\n\n  return {\n    toggle,\n    enabled,\n    pending,\n    track,\n    buttonProps: {\n      ...newProps,\n      'aria-pressed': enabled,\n      'data-lk-source': source,\n      'data-lk-enabled': enabled,\n      disabled: pending,\n      onClick: clickHandler,\n    } as React.ButtonHTMLAttributes<HTMLButtonElement>,\n  };\n}\n","import type {\n  SourcesArray,\n  TrackReference,\n  TrackReferenceOrPlaceholder,\n  TrackSourceWithOptions,\n  TrackReferencePlaceholder,\n} from '@livekit/components-core';\nimport {\n  isSourcesWithOptions,\n  isSourceWitOptions,\n  log,\n  trackReferencesObservable,\n} from '@livekit/components-core';\nimport type { Participant, Room, RoomEvent } from 'livekit-client';\nimport { Track } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureRoom } from '../context';\n\n/** @public */\nexport type UseTracksOptions = {\n  updateOnlyOn?: RoomEvent[];\n  onlySubscribed?: boolean;\n  room?: Room;\n};\n\n/** @public */\nexport type UseTracksHookReturnType<T> = T extends Track.Source[]\n  ? TrackReference[]\n  : T extends TrackSourceWithOptions[]\n    ? TrackReferenceOrPlaceholder[]\n    : never;\n\n/**\n * The `useTracks` hook returns an array of `TrackReference` or `TrackReferenceOrPlaceholder` depending on the provided `sources` property.\n * If only subscribed tracks are desired, set the `onlySubscribed` property to `true`.\n * @example\n * ```ts\n * // Return all camera track publications.\n * const trackReferences: TrackReference[] = useTracks([Track.Source.Camera])\n * ```\n * @example\n * ```ts\n * // Return all subscribed camera tracks as well as placeholders for\n * // participants without a camera subscription.\n * const trackReferencesWithPlaceholders: TrackReferenceOrPlaceholder[] = useTracks([{source: Track.Source.Camera, withPlaceholder: true}])\n * ```\n * @public\n */\nexport function useTracks<T extends SourcesArray = Track.Source[]>(\n  sources: T = [\n    Track.Source.Camera,\n    Track.Source.Microphone,\n    Track.Source.ScreenShare,\n    Track.Source.ScreenShareAudio,\n    Track.Source.Unknown,\n  ] as T,\n  options: UseTracksOptions = {},\n): UseTracksHookReturnType<T> {\n  const room = useEnsureRoom(options.room);\n  const [trackReferences, setTrackReferences] = React.useState<TrackReference[]>([]);\n  const [participants, setParticipants] = React.useState<Participant[]>([]);\n\n  const sources_ = React.useMemo(() => {\n    return sources.map((s) => (isSourceWitOptions(s) ? s.source : s));\n  }, [JSON.stringify(sources)]);\n\n  React.useEffect(() => {\n    const subscription = trackReferencesObservable(room, sources_, {\n      additionalRoomEvents: options.updateOnlyOn,\n      onlySubscribed: options.onlySubscribed,\n    }).subscribe(({ trackReferences, participants }) => {\n      log.debug('setting track bundles', trackReferences, participants);\n      setTrackReferences(trackReferences);\n      setParticipants(participants);\n    });\n    return () => subscription.unsubscribe();\n  }, [\n    room,\n    JSON.stringify(options.onlySubscribed),\n    JSON.stringify(options.updateOnlyOn),\n    JSON.stringify(sources),\n  ]);\n\n  const maybeTrackReferences = React.useMemo(() => {\n    if (isSourcesWithOptions(sources)) {\n      const requirePlaceholder = requiredPlaceholders(sources, participants);\n      const trackReferencesWithPlaceholders: TrackReferenceOrPlaceholder[] =\n        Array.from(trackReferences);\n      participants.forEach((participant) => {\n        if (requirePlaceholder.has(participant.identity)) {\n          const sourcesToAddPlaceholder = requirePlaceholder.get(participant.identity) ?? [];\n          sourcesToAddPlaceholder.forEach((placeholderSource) => {\n            if (\n              trackReferences.find(\n                ({ participant: p, publication }) =>\n                  participant.identity === p.identity && publication.source === placeholderSource,\n              )\n            ) {\n              return;\n            }\n            log.debug(\n              `Add ${placeholderSource} placeholder for participant ${participant.identity}.`,\n            );\n            const placeholder: TrackReferencePlaceholder = {\n              participant,\n              source: placeholderSource,\n            };\n            trackReferencesWithPlaceholders.push(placeholder);\n          });\n        }\n      });\n      return trackReferencesWithPlaceholders;\n    } else {\n      return trackReferences;\n    }\n  }, [trackReferences, participants, sources]);\n\n  return maybeTrackReferences as UseTracksHookReturnType<T>;\n}\n\nfunction difference<T>(setA: Set<T>, setB: Set<T>): Set<T> {\n  const _difference = new Set(setA);\n  for (const elem of setB) {\n    _difference.delete(elem);\n  }\n  return _difference;\n}\n\nexport function requiredPlaceholders<T extends SourcesArray>(\n  sources: T,\n  participants: Participant[],\n): Map<Participant['identity'], Track.Source[]> {\n  const placeholderMap = new Map<Participant['identity'], Track.Source[]>();\n  if (isSourcesWithOptions(sources)) {\n    const sourcesThatNeedPlaceholder = sources\n      .filter((sourceWithOption) => sourceWithOption.withPlaceholder)\n      .map((sourceWithOption) => sourceWithOption.source);\n\n    participants.forEach((participant) => {\n      const sourcesOfSubscribedTracks = participant\n        .getTrackPublications()\n        .map((pub) => pub.track?.source)\n        .filter((trackSource): trackSource is Track.Source => trackSource !== undefined);\n      const placeholderNeededForThisParticipant = Array.from(\n        difference(new Set(sourcesThatNeedPlaceholder), new Set(sourcesOfSubscribedTracks)),\n      );\n      // If the participant needs placeholder add it to the placeholder map.\n      if (placeholderNeededForThisParticipant.length > 0) {\n        placeholderMap.set(participant.identity, placeholderNeededForThisParticipant);\n      }\n    });\n  }\n  return placeholderMap;\n}\n","import type { TrackReferenceOrPlaceholder, TrackSource } from '@livekit/components-core';\nimport { setupMediaTrack, getTrackByIdentifier } from '@livekit/components-core';\nimport * as React from 'react';\nimport { Track } from 'livekit-client';\n\n/**\n * @internal\n */\nexport function useTrackRefBySourceOrName(\n  source: TrackSource<Track.Source>,\n): TrackReferenceOrPlaceholder {\n  const [publication, setPublication] = React.useState(getTrackByIdentifier(source));\n\n  const { trackObserver } = React.useMemo(() => {\n    return setupMediaTrack(source);\n  }, [source.participant.sid ?? source.participant.identity, source.source]);\n\n  React.useEffect(() => {\n    const subscription = trackObserver.subscribe((publication) => {\n      setPublication(publication);\n    });\n    return () => subscription?.unsubscribe();\n  }, [trackObserver]);\n\n  return {\n    participant: source.participant,\n    source: source.source ?? Track.Source.Unknown,\n    publication,\n  };\n}\n","import type { Participant } from 'livekit-client';\nimport { useEnsureParticipant } from '../context';\nimport { useTrackRefBySourceOrName } from './useTrackRefBySourceOrName';\n\n/**\n * This function `useTrackByName` allows you to access a track by referencing its track name.\n * Inside the function, it ensures that the a valid `participant` reference is available by checking\n * for both a passed participant argument and, if not available, a valid participant context.\n *\n * @public\n */\nexport function useTrackByName(name: string, participant?: Participant) {\n  const p = useEnsureParticipant(participant);\n  return useTrackRefBySourceOrName({ name, participant: p });\n}\n","import * as React from 'react';\nimport type { ChatOptions, ReceivedChatMessage } from '@livekit/components-core';\nimport { setupChat } from '@livekit/components-core';\nimport { ConnectionState } from 'livekit-client';\nimport { useRoomContext } from '../context';\nimport { useObservableState } from './internal/useObservableState';\nimport { useConnectionState } from './useConnectionStatus';\n\n/**\n * The `useChat` hook provides chat functionality for a LiveKit room.\n * It returns a simple `send` function to send chat messages and an array of `chatMessages` to hold received messages.\n * It also returns a `update` function that allows you to implement message-edit functionality.\n * @public\n */\nexport function useChat(options?: ChatOptions) {\n  const room = useRoomContext();\n  const connectionState = useConnectionState(room);\n  const isDisconnected = React.useMemo(\n    () => connectionState === ConnectionState.Disconnected,\n    [connectionState],\n  ); // used to reset the messages on room disconnect\n  const setup = React.useMemo<ReturnType<typeof setupChat>>(\n    () => setupChat(room, options),\n    [room, options, isDisconnected],\n  );\n  const isSending = useObservableState(setup.isSendingObservable, false);\n  const chatMessages = useObservableState<ReceivedChatMessage[]>(setup.messageObservable, []);\n\n  return { send: setup.send, update: setup.update, chatMessages, isSending };\n}\n","import type { LocalUserChoices } from '@livekit/components-core';\nimport { loadUserChoices, saveUserChoices } from '@livekit/components-core';\nimport * as React from 'react';\n\n/**\n * Options for the `usePersistentDeviceSettings` hook.\n * @alpha\n */\nexport interface UsePersistentUserChoicesOptions {\n  /**\n   * The default value to use if reading from local storage returns no results or fails.\n   */\n  defaults?: Partial<LocalUserChoices>;\n  /**\n   * Whether to prevent saving to persistent storage.\n   * @defaultValue false\n   */\n  preventSave?: boolean;\n  /**\n   * Whether to prevent loading user choices from persistent storage and use `defaults` instead.\n   * @defaultValue false\n   */\n  preventLoad?: boolean;\n}\n\n/**\n * A hook that provides access to user choices stored in local storage, such as\n * selected media devices and their current state (on or off), as well as the user name.\n * @alpha\n */\nexport function usePersistentUserChoices(options: UsePersistentUserChoicesOptions = {}) {\n  const [userChoices, setSettings] = React.useState<LocalUserChoices>(\n    loadUserChoices(options.defaults, options.preventLoad ?? false),\n  );\n\n  const saveAudioInputEnabled = React.useCallback((isEnabled: boolean) => {\n    setSettings((prev) => ({ ...prev, audioEnabled: isEnabled }));\n  }, []);\n  const saveVideoInputEnabled = React.useCallback((isEnabled: boolean) => {\n    setSettings((prev) => ({ ...prev, videoEnabled: isEnabled }));\n  }, []);\n  const saveAudioInputDeviceId = React.useCallback((deviceId: string) => {\n    setSettings((prev) => ({ ...prev, audioDeviceId: deviceId }));\n  }, []);\n  const saveVideoInputDeviceId = React.useCallback((deviceId: string) => {\n    setSettings((prev) => ({ ...prev, videoDeviceId: deviceId }));\n  }, []);\n  const saveUsername = React.useCallback((username: string) => {\n    setSettings((prev) => ({ ...prev, username: username }));\n  }, []);\n\n  React.useEffect(() => {\n    saveUserChoices(userChoices, options.preventSave ?? false);\n  }, [userChoices, options.preventSave]);\n\n  return {\n    userChoices,\n    saveAudioInputEnabled,\n    saveVideoInputEnabled,\n    saveAudioInputDeviceId,\n    saveVideoInputDeviceId,\n    saveUsername,\n  };\n}\n","import * as React from 'react';\nimport { LocalParticipant } from 'livekit-client';\nimport type { Participant, Room } from 'livekit-client';\nimport { encryptionStatusObservable } from '@livekit/components-core';\nimport { useEnsureParticipant, useEnsureRoom } from '../context';\nimport { useObservableState } from './internal';\n\n/**\n * @alpha\n */\nexport interface UseIsEncryptedOptions {\n  room?: Room;\n}\n\n/**\n * @alpha\n */\nexport function useIsEncrypted(participant?: Participant, options: UseIsEncryptedOptions = {}) {\n  const p = useEnsureParticipant(participant);\n\n  const room = useEnsureRoom(options.room);\n\n  const observer = React.useMemo(() => encryptionStatusObservable(room, p), [room, p]);\n  const isEncrypted = useObservableState(\n    observer,\n    p instanceof LocalParticipant ? p.isE2EEEnabled : !!p?.isEncrypted,\n  );\n  return isEncrypted;\n}\n","import * as React from 'react';\nimport type { LocalAudioTrack, RemoteAudioTrack, AudioAnalyserOptions } from 'livekit-client';\nimport { Track, createAudioAnalyser } from 'livekit-client';\nimport {\n  type TrackReference,\n  isTrackReference,\n  type TrackReferenceOrPlaceholder,\n} from '@livekit/components-core';\n\n/**\n * @alpha\n * Hook for tracking the volume of an audio track using the Web Audio API.\n */\nexport function useTrackVolume(\n  trackOrTrackReference?: LocalAudioTrack | RemoteAudioTrack | TrackReference,\n  options: AudioAnalyserOptions = { fftSize: 32, smoothingTimeConstant: 0 },\n) {\n  const track = isTrackReference(trackOrTrackReference)\n    ? <LocalAudioTrack | RemoteAudioTrack | undefined>trackOrTrackReference.publication.track\n    : trackOrTrackReference;\n  const [volume, setVolume] = React.useState(0);\n  React.useEffect(() => {\n    if (!track || !track.mediaStream) {\n      return;\n    }\n\n    const { cleanup, analyser } = createAudioAnalyser(track, options);\n\n    const bufferLength = analyser.frequencyBinCount;\n    const dataArray = new Uint8Array(bufferLength);\n\n    const updateVolume = () => {\n      analyser.getByteFrequencyData(dataArray);\n      let sum = 0;\n      for (let i = 0; i < dataArray.length; i++) {\n        const a = dataArray[i];\n        sum += a * a;\n      }\n      setVolume(Math.sqrt(sum / dataArray.length) / 255);\n    };\n\n    const interval = setInterval(updateVolume, 1000 / 30);\n\n    return () => {\n      cleanup();\n      clearInterval(interval);\n    };\n  }, [track, track?.mediaStream, JSON.stringify(options)]);\n\n  return volume;\n}\n\nconst normalizeFrequencies = (frequencies: Float32Array) => {\n  const normalizeDb = (value: number) => {\n    const minDb = -100;\n    const maxDb = -10;\n    let db = 1 - (Math.max(minDb, Math.min(maxDb, value)) * -1) / 100;\n    db = Math.sqrt(db);\n\n    return db;\n  };\n\n  // Normalize all frequency values\n  return frequencies.map((value) => {\n    if (value === -Infinity) {\n      return 0;\n    }\n    return normalizeDb(value);\n  });\n};\n\n/**\n * Interface for configuring options for the useMultibandTrackVolume hook.\n * @alpha\n */\nexport interface MultiBandTrackVolumeOptions {\n  bands?: number;\n  /**\n   * cut off of frequency bins on the lower end\n   * Note: this is not a frequency measure, but in relation to analyserOptions.fftSize,\n   */\n  loPass?: number;\n  /**\n   * cut off of frequency bins on the higher end\n   * Note: this is not a frequency measure, but in relation to analyserOptions.fftSize,\n   */\n  hiPass?: number;\n  /**\n   * update should run every x ms\n   */\n  updateInterval?: number;\n  analyserOptions?: AnalyserOptions;\n}\n\nconst multibandDefaults = {\n  bands: 5,\n  loPass: 100,\n  hiPass: 600,\n  updateInterval: 32,\n  analyserOptions: { fftSize: 2048 },\n} as const satisfies MultiBandTrackVolumeOptions;\n\n/**\n * Hook for tracking the volume of an audio track across multiple frequency bands using the Web Audio API.\n * @alpha\n */\nexport function useMultibandTrackVolume(\n  trackOrTrackReference?: LocalAudioTrack | RemoteAudioTrack | TrackReferenceOrPlaceholder,\n  options: MultiBandTrackVolumeOptions = {},\n) {\n  const track =\n    trackOrTrackReference instanceof Track\n      ? trackOrTrackReference\n      : <LocalAudioTrack | RemoteAudioTrack | undefined>trackOrTrackReference?.publication?.track;\n  const opts = { ...multibandDefaults, ...options };\n  const [frequencyBands, setFrequencyBands] = React.useState<Array<number>>(\n    new Array(opts.bands).fill(0),\n  );\n\n  React.useEffect(() => {\n    if (!track || !track?.mediaStream) {\n      return;\n    }\n    const { analyser, cleanup } = createAudioAnalyser(track, opts.analyserOptions);\n\n    const bufferLength = analyser.frequencyBinCount;\n    const dataArray = new Float32Array(bufferLength);\n\n    const updateVolume = () => {\n      analyser.getFloatFrequencyData(dataArray);\n      let frequencies: Float32Array = new Float32Array(dataArray.length);\n      for (let i = 0; i < dataArray.length; i++) {\n        frequencies[i] = dataArray[i];\n      }\n      frequencies = frequencies.slice(options.loPass, options.hiPass);\n\n      const normalizedFrequencies = normalizeFrequencies(frequencies); // is this needed ?\n      const chunkSize = Math.ceil(normalizedFrequencies.length / opts.bands); // we want logarithmic chunking here\n      const chunks: Array<number> = [];\n      for (let i = 0; i < opts.bands; i++) {\n        const summedVolumes = normalizedFrequencies\n          .slice(i * chunkSize, (i + 1) * chunkSize)\n          .reduce((acc, val) => (acc += val), 0);\n        chunks.push(summedVolumes / chunkSize);\n      }\n\n      setFrequencyBands(chunks);\n    };\n\n    const interval = setInterval(updateVolume, opts.updateInterval);\n\n    return () => {\n      cleanup();\n      clearInterval(interval);\n    };\n  }, [track, track?.mediaStream, JSON.stringify(options)]);\n\n  return frequencyBands;\n}\n\n/**\n * @alpha\n */\nexport interface AudioWaveformOptions {\n  barCount?: number;\n  volMultiplier?: number;\n  updateInterval?: number;\n}\n\nconst waveformDefaults = {\n  barCount: 120,\n  volMultiplier: 5,\n  updateInterval: 20,\n} as const satisfies AudioWaveformOptions;\n\n/**\n * @alpha\n */\nexport function useAudioWaveform(\n  trackOrTrackReference?: LocalAudioTrack | RemoteAudioTrack | TrackReferenceOrPlaceholder,\n  options: AudioWaveformOptions = {},\n) {\n  const track =\n    trackOrTrackReference instanceof Track\n      ? trackOrTrackReference\n      : <LocalAudioTrack | RemoteAudioTrack | undefined>trackOrTrackReference?.publication?.track;\n  const opts = { ...waveformDefaults, ...options };\n\n  const aggregateWave = React.useRef(new Float32Array());\n  const timeRef = React.useRef(performance.now());\n  const updates = React.useRef(0);\n  const [bars, setBars] = React.useState<number[]>([]);\n\n  const onUpdate = React.useCallback((wave: Float32Array) => {\n    setBars(\n      Array.from(\n        filterData(wave, opts.barCount).map((v) => Math.sqrt(v) * opts.volMultiplier),\n        // wave.slice(0, opts.barCount).map((v) => sigmoid(v * opts.volMultiplier, 0.08, 0.2)),\n      ),\n    );\n  }, []);\n\n  React.useEffect(() => {\n    if (!track || !track?.mediaStream) {\n      return;\n    }\n    const { analyser, cleanup } = createAudioAnalyser(track, {\n      fftSize: getFFTSizeValue(opts.barCount),\n    });\n\n    const bufferLength = getFFTSizeValue(opts.barCount);\n    const dataArray = new Float32Array(bufferLength);\n\n    const update = () => {\n      updateWaveform = requestAnimationFrame(update);\n      analyser.getFloatTimeDomainData(dataArray);\n      aggregateWave.current.map((v, i) => v + dataArray[i]);\n      updates.current += 1;\n\n      if (performance.now() - timeRef.current >= opts.updateInterval) {\n        const newData = dataArray.map((v) => v / updates.current);\n        onUpdate(newData);\n        timeRef.current = performance.now();\n        updates.current = 0;\n      }\n    };\n\n    let updateWaveform = requestAnimationFrame(update);\n\n    return () => {\n      cleanup();\n      cancelAnimationFrame(updateWaveform);\n    };\n  }, [track, track?.mediaStream, JSON.stringify(options), onUpdate]);\n\n  return {\n    bars,\n  };\n}\n\nfunction getFFTSizeValue(x: number) {\n  if (x < 32) return 32;\n  else return pow2ceil(x);\n}\n\n// function sigmoid(x: number, k = 2, s = 0) {\n//   return 1 / (1 + Math.exp(-(x - s) / k));\n// }\n\nfunction pow2ceil(v: number) {\n  let p = 2;\n  while ((v >>= 1)) {\n    p <<= 1;\n  }\n  return p;\n}\n\nfunction filterData(audioData: Float32Array, numSamples: number) {\n  const blockSize = Math.floor(audioData.length / numSamples); // the number of samples in each subdivision\n  const filteredData = new Float32Array(numSamples);\n  for (let i = 0; i < numSamples; i++) {\n    const blockStart = blockSize * i; // the location of the first sample in the block\n    let sum = 0;\n    for (let j = 0; j < blockSize; j++) {\n      sum = sum + Math.abs(audioData[blockStart + j]); // find the sum of all the samples in the block\n    }\n    filteredData[i] = sum / blockSize; // divide the sum by the block size to get the average\n  }\n  return filteredData;\n}\n\n// function normalizeData(audioData: Float32Array) {\n//   const multiplier = Math.pow(Math.max(...audioData), -1);\n//   return audioData.map((n) => n * multiplier);\n// }\n","import * as React from 'react';\nimport type { TrackReference } from '@livekit/components-core';\nimport { participantTracksObservable } from '@livekit/components-core';\nimport { useObservableState } from './internal';\nimport type { Track } from 'livekit-client';\nimport { useMaybeParticipantContext, useRoomContext } from '../context';\n\n/**\n * `useParticipantTracks` is a custom React that allows you to get tracks of a specific participant only, by specifiying the participant's identity.\n * If the participant identity is not passed the hook will try to get the participant from a participant context.\n * @public\n */\nexport function useParticipantTracks(\n  sources: Track.Source[],\n  participantIdentity?: string,\n): TrackReference[] {\n  const room = useRoomContext();\n  const participantContext = useMaybeParticipantContext();\n  const p = participantIdentity\n    ? room.getParticipantByIdentity(participantIdentity)\n    : participantContext;\n  const observable = React.useMemo(\n    () => (p ? participantTracksObservable(p, { sources }) : undefined),\n    [p?.sid, p?.identity, JSON.stringify(sources)],\n  );\n\n  const trackRefs = useObservableState(observable, [] as TrackReference[]);\n\n  return trackRefs;\n}\n","import * as React from 'react';\nimport { type TrackReferenceOrPlaceholder, trackSyncTimeObserver } from '@livekit/components-core';\nimport { useObservableState } from './internal';\n\n/**\n * @internal\n */\nexport function useTrackSyncTime(ref: TrackReferenceOrPlaceholder | undefined) {\n  const observable = React.useMemo(\n    () => (ref?.publication?.track ? trackSyncTimeObserver(ref?.publication.track) : undefined),\n    [ref?.publication?.track],\n  );\n  return useObservableState(observable, {\n    timestamp: Date.now(),\n    rtpTimestamp: ref?.publication?.track?.rtpTimestamp,\n  });\n}\n","import {\n  type ReceivedTranscriptionSegment,\n  addMediaTimestampToTranscription as addTimestampsToTranscription,\n  dedupeSegments,\n  // getActiveTranscriptionSegments,\n  getTrackReferenceId,\n  trackTranscriptionObserver,\n  type TrackReferenceOrPlaceholder,\n  // didActiveSegmentsChange,\n} from '@livekit/components-core';\nimport type { TranscriptionSegment } from 'livekit-client';\nimport * as React from 'react';\nimport { useTrackSyncTime } from './useTrackSyncTime';\n\n/**\n * @alpha\n */\nexport interface TrackTranscriptionOptions {\n  /**\n   * how many transcription segments should be buffered in state\n   * @defaultValue 100\n   */\n  bufferSize?: number;\n  /**\n   * optional callback for retrieving newly incoming transcriptions only\n   */\n  onTranscription?: (newSegments: TranscriptionSegment[]) => void;\n  /** amount of time (in ms) that the segment is considered `active` past its original segment duration, defaults to 2_000 */\n  // maxAge?: number;\n}\n\nconst TRACK_TRANSCRIPTION_DEFAULTS = {\n  bufferSize: 100,\n  // maxAge: 2_000,\n} as const satisfies TrackTranscriptionOptions;\n\n/**\n * @returns An object consisting of `segments` with maximum length of opts.windowLength and `activeSegments` that are valid for the current track timestamp\n * @alpha\n */\nexport function useTrackTranscription(\n  trackRef: TrackReferenceOrPlaceholder | undefined,\n  options?: TrackTranscriptionOptions,\n) {\n  const opts = { ...TRACK_TRANSCRIPTION_DEFAULTS, ...options };\n  const [segments, setSegments] = React.useState<Array<ReceivedTranscriptionSegment>>([]);\n  // const [activeSegments, setActiveSegments] = React.useState<Array<ReceivedTranscriptionSegment>>(\n  //   [],\n  // );\n  // const prevActiveSegments = React.useRef<ReceivedTranscriptionSegment[]>([]);\n  const syncTimestamps = useTrackSyncTime(trackRef);\n  const handleSegmentMessage = (newSegments: TranscriptionSegment[]) => {\n    opts.onTranscription?.(newSegments);\n    setSegments((prevSegments) =>\n      dedupeSegments(\n        prevSegments,\n        // when first receiving a segment, add the current media timestamp to it\n        newSegments.map((s) => addTimestampsToTranscription(s, syncTimestamps)),\n        opts.bufferSize,\n      ),\n    );\n  };\n  React.useEffect(() => {\n    if (!trackRef?.publication) {\n      return;\n    }\n    const subscription = trackTranscriptionObserver(trackRef.publication).subscribe((evt) => {\n      handleSegmentMessage(...evt);\n    });\n    return () => {\n      subscription.unsubscribe();\n    };\n  }, [trackRef && getTrackReferenceId(trackRef), handleSegmentMessage]);\n\n  // React.useEffect(() => {\n  //   if (syncTimestamps) {\n  //     const newActiveSegments = getActiveTranscriptionSegments(\n  //       segments,\n  //       syncTimestamps,\n  //       opts.maxAge,\n  //     );\n  //     // only update active segment array if content actually changed\n  //     if (didActiveSegmentsChange(prevActiveSegments.current, newActiveSegments)) {\n  //       setActiveSegments(newActiveSegments);\n  //       prevActiveSegments.current = newActiveSegments;\n  //     }\n  //   }\n  // }, [syncTimestamps, segments, opts.maxAge]);\n\n  return { segments };\n}\n","import { participantAttributesObserver } from '@livekit/components-core';\nimport type { Participant } from 'livekit-client';\nimport * as React from 'react';\nimport { useEnsureParticipant, useMaybeParticipantContext } from '../context';\nimport { useObservableState } from './internal';\n\n/**\n * The `useParticipantAttributes` hook returns the attributes of a given participant and allows to set them.\n * It requires a `Participant` object passed as property or via the `ParticipantContext`.\n *\n * @example\n * ```tsx\n * const { attributes } = useParticipantAttributes({ participant });\n * ```\n * @public\n */\nexport interface UseParticipantAttributesOptions {\n  participant?: Participant;\n}\n\n/** @public */\nexport function useParticipantAttributes(props: UseParticipantAttributesOptions = {}) {\n  const participantContext = useMaybeParticipantContext();\n  const p = props.participant ?? participantContext;\n  const attributeObserver = React.useMemo(\n    // weird typescript constraint\n    () => (p ? participantAttributesObserver(p) : participantAttributesObserver(p)),\n    [p],\n  );\n  const attributeState = useObservableState(attributeObserver, {\n    attributes: p?.attributes,\n  });\n\n  return attributeState;\n}\n\n/**\n * The `useParticipantAttribute` hook returns the latest value of a given attribute key of a participant.\n * It requires a `Participant` object passed as property in the `UseParticipantAttributesOptions` or via the `ParticipantContext`.\n *\n * @example\n * ```tsx\n * const myAttributeValue = useParticipantAttribute('targetAttributeName');\n * ```\n * @public\n */\nexport function useParticipantAttribute(\n  attributeKey: string,\n  options: UseParticipantAttributesOptions = {},\n) {\n  const p = useEnsureParticipant(options.participant);\n  const [attribute, setAttribute] = React.useState(p.attributes[attributeKey]);\n\n  React.useEffect(() => {\n    if (!p) {\n      return;\n    }\n    const subscription = participantAttributesObserver(p).subscribe((val) => {\n      if (val.changed[attributeKey] !== undefined) {\n        setAttribute(val.attributes[attributeKey]);\n      }\n    });\n    return () => {\n      subscription.unsubscribe();\n    };\n  }, [p, attributeKey]);\n\n  return attribute;\n}\n","import * as React from 'react';\nimport { ConnectionState, ParticipantKind, Track } from 'livekit-client';\nimport type { RemoteParticipant } from 'livekit-client';\nimport type { ReceivedTranscriptionSegment, TrackReference } from '@livekit/components-core';\nimport { useRemoteParticipants } from './useRemoteParticipants';\nimport { useParticipantTracks } from './useParticipantTracks';\nimport { useTrackTranscription } from './useTrackTranscription';\nimport { useConnectionState } from './useConnectionStatus';\nimport { useParticipantAttributes } from './useParticipantAttributes';\n\n/**\n * @beta\n */\nexport type AgentState =\n  | 'disconnected'\n  | 'connecting'\n  | 'initializing'\n  | 'listening'\n  | 'thinking'\n  | 'speaking';\n\n/**\n * @beta\n */\nexport interface VoiceAssistant {\n  agent: RemoteParticipant | undefined;\n  state: AgentState;\n  audioTrack: TrackReference | undefined;\n  agentTranscriptions: ReceivedTranscriptionSegment[];\n  agentAttributes: RemoteParticipant['attributes'] | undefined;\n}\n\nconst state_attribute = 'lk.agent.state';\n\n/**\n * This hook looks for the first agent-participant in the room.\n * @remarks This hook requires an agent running with livekit-agents \\>= 0.9.0\n * @example\n * ```tsx\n * const { state, audioTrack, agentTranscriptions, agentAttributes } = useVoiceAssistant();\n * ```\n * @beta\n */\nexport function useVoiceAssistant(): VoiceAssistant {\n  const agent = useRemoteParticipants().find((p) => p.kind === ParticipantKind.AGENT);\n  const audioTrack = useParticipantTracks([Track.Source.Microphone], agent?.identity)[0];\n  const { segments: agentTranscriptions } = useTrackTranscription(audioTrack);\n  const connectionState = useConnectionState();\n  const { attributes } = useParticipantAttributes({ participant: agent });\n\n  const state: AgentState = React.useMemo(() => {\n    if (connectionState === ConnectionState.Disconnected) {\n      return 'disconnected';\n    } else if (\n      connectionState === ConnectionState.Connecting ||\n      !agent ||\n      !attributes?.[state_attribute]\n    ) {\n      return 'connecting';\n    } else {\n      return attributes[state_attribute] as AgentState;\n    }\n  }, [attributes, agent, connectionState]);\n\n  return {\n    agent,\n    state,\n    audioTrack,\n    agentTranscriptions,\n    agentAttributes: attributes,\n  };\n}\n","import { recordingStatusObservable } from '@livekit/components-core';\nimport * as React from 'react';\nimport { useEnsureRoom } from '../context';\nimport { useObservableState } from './internal';\nimport { useConnectionState } from './useConnectionStatus';\nimport type { Room } from 'livekit-client';\n\n/**\n * The `useIsRecording` hook returns a `boolean` that indicates if the room is currently being recorded.\n * @example\n * ```tsx\n * const isRecording = useIsRecording();\n * ```\n * @public\n */\nexport function useIsRecording(room?: Room) {\n  const r = useEnsureRoom(room);\n  const connectionState = useConnectionState(r);\n  const observable = React.useMemo(() => recordingStatusObservable(r), [r, connectionState]);\n  const isRecording = useObservableState(observable, r.isRecording);\n\n  return isRecording;\n}\n"],"names":["useLatest","current","storedValue","React","useResizeObserver","target","callback","resizeObserver","getResizeObserver","storedCallback","didUnsubscribe","targetEl","cb","entry","observer","createResizeObserver","ticking","allEntries","callbacks","entries","obs","triggered","i","cbs","cbIndex","_resizeObserver","useSize","size","setSize","width","height","resizeCallback","useObservableState","observable","startWith","resetWhenObservableChanges","state","setState","subscription","useMediaQuery","query","getMatches","matches","setMatches","handleChange","matchMedia","useAudioPlayback","room","roomEnsured","useEnsureRoom","startAudio","roomAudioPlaybackAllowedObservable","canPlayAudio","useClearPinButton","props","dispatch","useLayoutContext","className","setupClearPinButton","mergeProps","useConnectionQualityIndicator","options","p","useEnsureParticipant","connectionQualityObserver","setupConnectionQualityIndicator","quality","ConnectionQuality","useConnectionState","r","connectionStateObserver","useDataChannel","topicOrCallback","onMessage","topic","useRoomContext","send","messageObservable","isSendingObservable","setupDataMessageHandler","message","isSending","useDisconnectButton","connectionState","disconnect","setupDisconnectButton","ConnectionState","useFacingMode","trackReference","LocalTrackPublication","localTrack","facingMode","facingModeFromLocalTrack","useFocusToggle","trackRef","useEnsureTrackRef","layoutContext","useMaybeLayoutContext","setupFocusToggle","inFocus","isTrackReferencePinned","event","_a","_c","_b","_e","_d","useGridLayout","gridElement","trackCount","gridLayouts","GRID_LAYOUTS","layout","selectGridLayout","useIsMuted","sourceOrTrackRef","passedParticipant","ref","isMuted","setIsMuted","listener","mutedObserver","getTrackReferenceId","useIsSpeaking","participant","createIsSpeakingObserver","useLocalParticipant","localParticipant","setLocalParticipant","isMicrophoneEnabled","setIsMicrophoneEnabled","isCameraEnabled","setIsCameraEnabled","lastMicrophoneError","setLastMicrophoneError","lastCameraError","setLastCameraError","isScreenShareEnabled","setIsScreenShareEnabled","microphoneTrack","setMicrophoneTrack","cameraTrack","setCameraTrack","handleUpdate","media","observeParticipantMedia","useLocalParticipantPermissions","permissionObserver","participantPermissionObserver","useMediaDeviceSelect","kind","track","requestPermissions","onError","roomContext","useMaybeRoomContext","deviceObserver","createMediaDeviceObserver","devices","currentDeviceId","setCurrentDeviceId","activeDeviceObservable","setActiveMediaDevice","setupDeviceSelector","deviceId","log","useMediaDevices","useVisualStableUpdate","trackReferences","maxItemsOnPage","lastTrackRefs","lastMaxItemsOnPage","layoutChanged","sortedTrackRefs","sortTrackReferences","updatedTrackRefs","updatePages","error","usePagination","itemPerPage","currentPage","setCurrentPage","totalPageCount","lastItemIndex","firstItemIndex","changePage","direction","goToPage","num","tracksOnPage","useParticipantInfo","useMaybeParticipantContext","infoObserver","participantInfoObserver","identity","name","metadata","useParticipantPermissions","useParticipantTile","onParticipantClick","disableSpeakingIndicator","htmlProps","mergedProps","setupParticipantTile","micTrack","Track","micRef","isVideoMuted","isAudioMuted","isSpeaking","useRemoteParticipants","participants","setParticipants","connectedParticipantsObserver","useParticipants","remoteParticipants","usePinnedTracks","useEnsureLayoutContext","useRemoteParticipant","identityOrIdentifier","updateOnlyOn","connectedParticipantObserver","participantByIdentifierObserver","participantWrapper","setParticipantWrapper","useRoomInfo","roomInfoObserver","useSpeakingParticipants","speakerObserver","activeSpeakerObserver","useSortedParticipants","sortedParticipants","setSortedParticipants","sortParticipants","activeSpeakers","useStartAudio","handleStartAudioPlayback","setupStartAudio","useStartVideo","roomVideoPlaybackAllowedObservable","handleStartVideoPlayback","setupStartVideo","canPlayVideo","useSwipe","element","touchStart","touchEnd","minSwipeDistance","onTouchStart","onTouchMove","onTouchEnd","distance","isLeftSwipe","isRightSwipe","elementCopy","useChatToggle","setupChatToggle","useToken","tokenEndpoint","roomName","token","setToken","params","res","accessToken","useTrackMutedIndicator","mediaMutedObserver","setupTrackMutedIndicator","useTrackToggle","source","onChange","initialState","captureOptions","publishOptions","onDeviceError","rest","userInteractionRef","toggle","pendingObserver","enabledObserver","setupMediaToggle","setupManualToggle","pending","enabled","newProps","clickHandler","evt","useTracks","sources","setTrackReferences","sources_","s","isSourceWitOptions","trackReferencesObservable","isSourcesWithOptions","requirePlaceholder","requiredPlaceholders","trackReferencesWithPlaceholders","placeholderSource","publication","placeholder","difference","setA","setB","_difference","elem","placeholderMap","sourcesThatNeedPlaceholder","sourceWithOption","sourcesOfSubscribedTracks","pub","trackSource","placeholderNeededForThisParticipant","useTrackRefBySourceOrName","setPublication","getTrackByIdentifier","trackObserver","setupMediaTrack","useTrackByName","useChat","isDisconnected","setup","setupChat","chatMessages","usePersistentUserChoices","userChoices","setSettings","loadUserChoices","saveAudioInputEnabled","isEnabled","prev","saveVideoInputEnabled","saveAudioInputDeviceId","saveVideoInputDeviceId","saveUsername","username","saveUserChoices","useIsEncrypted","encryptionStatusObservable","LocalParticipant","useTrackVolume","trackOrTrackReference","isTrackReference","volume","setVolume","cleanup","analyser","createAudioAnalyser","bufferLength","dataArray","interval","sum","a","normalizeFrequencies","frequencies","normalizeDb","value","db","multibandDefaults","useMultibandTrackVolume","opts","frequencyBands","setFrequencyBands","normalizedFrequencies","chunkSize","chunks","summedVolumes","acc","val","waveformDefaults","useAudioWaveform","aggregateWave","timeRef","updates","bars","setBars","onUpdate","wave","filterData","v","getFFTSizeValue","update","updateWaveform","newData","x","pow2ceil","audioData","numSamples","blockSize","filteredData","blockStart","j","useParticipantTracks","participantIdentity","participantContext","participantTracksObservable","useTrackSyncTime","trackSyncTimeObserver","TRACK_TRANSCRIPTION_DEFAULTS","useTrackTranscription","segments","setSegments","syncTimestamps","handleSegmentMessage","newSegments","prevSegments","dedupeSegments","addTimestampsToTranscription","trackTranscriptionObserver","useParticipantAttributes","attributeObserver","participantAttributesObserver","useParticipantAttribute","attributeKey","attribute","setAttribute","state_attribute","useVoiceAssistant","agent","ParticipantKind","audioTrack","agentTranscriptions","attributes","useIsRecording","recordingStatusObservable"],"mappings":"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"}