diff --git a/packages/call-sdk/package.json b/packages/call-sdk/package.json new file mode 100644 index 00000000..639d9039 --- /dev/null +++ b/packages/call-sdk/package.json @@ -0,0 +1,52 @@ +{ + "name": "@call0/call-sdk", + "version": "0.1.0", + "description": "Video calling SDK for Call0 using MediaSoup", + "main": "dist/index.js", + "module": "dist/index.mjs", + "types": "dist/index.d.ts", + "scripts": { + "build": "tsup src/index.ts --format cjs,esm --dts", + "dev": "tsup src/index.ts --format cjs,esm --dts --watch", + "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist", + "lint": "eslint \"src/**/*.ts*\"", + "lint:fix": "eslint \"src/**/*.ts*\" --fix", + "test": "jest", + "test:watch": "jest --watch", + "typecheck": "tsc --noEmit" + }, + "keywords": [ + "webrtc", + "mediasoup", + "video", + "call", + "sdk" + ], + "author": "Call0", + "license": "MIT", + "dependencies": { + "mediasoup-client": "^3.14.0", + "react": "^19.1.1", + "react-dom": "^19.1.1" + }, + "devDependencies": { + "@types/react": "^19.1.9", + "@types/react-dom": "^19.1.7", + "@typescript-eslint/eslint-plugin": "^8.38.0", + "@typescript-eslint/parser": "^8.38.0", + "eslint": "^9.32.0", + "eslint-config-prettier": "^10.1.8", + "eslint-plugin-prettier": "^5.5.3", + "jest": "^30.0.5", + "prettier": "^3.6.2", + "tsup": "^8.5.0", + "typescript": "^5.9.2" + }, + "peerDependencies": { + "react": ">=18.0.0", + "react-dom": ">=18.0.0" + }, + "publishConfig": { + "access": "public" + } +} diff --git a/packages/call-sdk/src/hooks/useCall.ts b/packages/call-sdk/src/hooks/useCall.ts new file mode 100644 index 00000000..14e7ff46 --- /dev/null +++ b/packages/call-sdk/src/hooks/useCall.ts @@ -0,0 +1,151 @@ +import { useCallback, useEffect, useState } from "react"; +import { useCall as useCallContext } from "../providers/CallProvider"; +import type { CallConfig, CallStats } from "../types/call"; +import type { Participant, Self } from "../types/participant"; + +export interface UseCallReturn { + // Connection state + isConnected: boolean; + isConnecting: boolean; + isReconnecting: boolean; + connectionError?: Error; + + // Participants + self: Self | null; + participants: Participant[]; + participantCount: number; + dominantSpeaker?: Participant; + pinnedParticipant?: Participant; + + // Media state + localStream: MediaStream | null; + isMicrophoneEnabled: boolean; + isCameraEnabled: boolean; + isScreenShareEnabled: boolean; + + // Call actions + joinCall: (config: CallConfig) => Promise; + leaveCall: () => Promise; + + // Media controls + toggleMicrophone: () => Promise; + toggleCamera: () => Promise; + startScreenShare: () => Promise; + stopScreenShare: () => Promise; + + // Participant management + pinParticipant: (participantId: string) => void; + unpinParticipant: () => void; + getParticipantById: (participantId: string) => Participant | undefined; + + // Device management + changeAudioDevice: (deviceId: string) => Promise; + changeVideoDevice: (deviceId: string) => Promise; + + // Call statistics + stats?: CallStats; + + // Advanced + callClient: any; // CallClient instance for advanced usage +} + +/** + * Main hook for call functionality + * Provides a comprehensive interface for managing video calls + */ +export function useCall(): UseCallReturn { + const context = useCallContext(); + const [isReconnecting, setIsReconnecting] = useState(false); + + // Derived state + const participantsArray = Array.from(context.participants.values()); + const dominantSpeaker = context.dominantSpeakerId + ? context.participants.get(context.dominantSpeakerId) + : undefined; + const pinnedParticipant = context.pinnedParticipantId + ? context.participants.get(context.pinnedParticipantId) + : undefined; + + // Media state derived from self + const isMicrophoneEnabled = context.self?.audioEnabled ?? false; + const isCameraEnabled = context.self?.videoEnabled ?? false; + const isScreenShareEnabled = context.self?.screenShareEnabled ?? false; + + // Handle reconnection logic + useEffect(() => { + if (context.callState.connectionStatus === "reconnecting") { + setIsReconnecting(true); + } else { + setIsReconnecting(false); + } + }, [context.callState.connectionStatus]); + + // Device management helpers + const changeAudioDevice = useCallback( + async (deviceId: string) => { + await context.changeDevice("audio", deviceId); + }, + [context.changeDevice] + ); + + const changeVideoDevice = useCallback( + async (deviceId: string) => { + await context.changeDevice("video", deviceId); + }, + [context.changeDevice] + ); + + // Participant helpers + const getParticipantById = useCallback( + (participantId: string) => { + return context.participants.get(participantId); + }, + [context.participants] + ); + + return { + // Connection state + isConnected: context.isConnected, + isConnecting: context.isConnecting, + isReconnecting, + connectionError: context.error, + + // Participants + self: context.self, + participants: participantsArray, + participantCount: participantsArray.length + (context.self ? 1 : 0), + dominantSpeaker, + pinnedParticipant, + + // Media state + localStream: context.localStream, + isMicrophoneEnabled, + isCameraEnabled, + isScreenShareEnabled, + + // Call actions + joinCall: context.joinCall, + leaveCall: context.leaveCall, + + // Media controls + toggleMicrophone: context.toggleMicrophone, + toggleCamera: context.toggleCamera, + startScreenShare: context.startScreenShare, + stopScreenShare: context.stopScreenShare, + + // Participant management + pinParticipant: context.pinParticipant, + unpinParticipant: context.unpinParticipant, + getParticipantById, + + // Device management + changeAudioDevice, + changeVideoDevice, + + // Call statistics + stats: context.stats, + + // Advanced + callClient: context.callClient, + }; +} diff --git a/packages/call-sdk/src/hooks/useMediaDevices.ts b/packages/call-sdk/src/hooks/useMediaDevices.ts new file mode 100644 index 00000000..a538980b --- /dev/null +++ b/packages/call-sdk/src/hooks/useMediaDevices.ts @@ -0,0 +1,169 @@ +import { useState, useEffect, useCallback } from "react"; + +export interface MediaDeviceState { + audioInputDevices: MediaDeviceInfo[]; + audioOutputDevices: MediaDeviceInfo[]; + videoInputDevices: MediaDeviceInfo[]; + selectedAudioInput: string | null; + selectedAudioOutput: string | null; + selectedVideoInput: string | null; + hasAudioPermission: boolean; + hasVideoPermission: boolean; + isLoading: boolean; + error: Error | null; +} + +const initialState: MediaDeviceState = { + audioInputDevices: [], + audioOutputDevices: [], + videoInputDevices: [], + selectedAudioInput: null, + selectedAudioOutput: null, + selectedVideoInput: null, + hasAudioPermission: false, + hasVideoPermission: false, + isLoading: true, + error: null, +}; + +export function useMediaDevices() { + const [state, setState] = useState(initialState); + + const updateDevices = useCallback(async () => { + try { + setState((prev) => ({ ...prev, isLoading: true, error: null })); + + const devices = await navigator.mediaDevices.enumerateDevices(); + const audioInputs = devices.filter( + (device) => device.kind === "audioinput" + ); + const audioOutputs = devices.filter( + (device) => device.kind === "audiooutput" + ); + const videoInputs = devices.filter( + (device) => device.kind === "videoinput" + ); + + setState((prev) => ({ + ...prev, + audioInputDevices: audioInputs, + audioOutputDevices: audioOutputs, + videoInputDevices: videoInputs, + selectedAudioInput: + prev.selectedAudioInput || audioInputs[0]?.deviceId || null, + selectedAudioOutput: + prev.selectedAudioOutput || audioOutputs[0]?.deviceId || null, + selectedVideoInput: + prev.selectedVideoInput || videoInputs[0]?.deviceId || null, + isLoading: false, + })); + } catch (error) { + setState((prev) => ({ + ...prev, + isLoading: false, + error: error as Error, + })); + } + }, []); + + const checkPermissions = useCallback(async () => { + try { + const audioStream = await navigator.mediaDevices.getUserMedia({ + audio: true, + }); + audioStream.getTracks().forEach((track) => track.stop()); + const videoStream = await navigator.mediaDevices.getUserMedia({ + video: true, + }); + videoStream.getTracks().forEach((track) => track.stop()); + + setState((prev) => ({ + ...prev, + hasAudioPermission: true, + hasVideoPermission: true, + })); + } catch (error) { + const permissionError = error as Error; + setState((prev) => ({ + ...prev, + hasAudioPermission: !permissionError.message.includes("audio"), + hasVideoPermission: !permissionError.message.includes("video"), + })); + } + }, []); + + useEffect(() => { + checkPermissions(); + updateDevices(); + + // Listen for device changes + navigator.mediaDevices.addEventListener("devicechange", updateDevices); + + return () => { + navigator.mediaDevices.removeEventListener("devicechange", updateDevices); + }; + }, [checkPermissions, updateDevices]); + + const setAudioInput = useCallback(async (deviceId: string) => { + try { + // Test if we can access the device + const stream = await navigator.mediaDevices.getUserMedia({ + audio: { deviceId: { exact: deviceId } }, + }); + stream.getTracks().forEach((track) => track.stop()); + + setState((prev) => ({ + ...prev, + selectedAudioInput: deviceId, + })); + } catch (error) { + setState((prev) => ({ + ...prev, + error: error as Error, + })); + throw error; + } + }, []); + + const setAudioOutput = useCallback((deviceId: string) => { + setState((prev) => ({ + ...prev, + selectedAudioOutput: deviceId, + })); + }, []); + + const setVideoInput = useCallback(async (deviceId: string) => { + try { + // Test if we can access the device + const stream = await navigator.mediaDevices.getUserMedia({ + video: { deviceId: { exact: deviceId } }, + }); + stream.getTracks().forEach((track) => track.stop()); + + setState((prev) => ({ + ...prev, + selectedVideoInput: deviceId, + })); + } catch (error) { + setState((prev) => ({ + ...prev, + error: error as Error, + })); + throw error; + } + }, []); + + const requestPermissions = useCallback(async () => { + await checkPermissions(); + await updateDevices(); + }, [checkPermissions, updateDevices]); + + return { + ...state, + setAudioInput, + setAudioOutput, + setVideoInput, + refreshDevices: updateDevices, + requestPermissions, + }; +} diff --git a/packages/call-sdk/src/index.ts b/packages/call-sdk/src/index.ts new file mode 100644 index 00000000..fadd4dbb --- /dev/null +++ b/packages/call-sdk/src/index.ts @@ -0,0 +1,45 @@ +// Core client and services +export { CallClient } from "./services/call-client"; +export { MediasoupService } from "./services/mediasoup-service"; +export { SignalingClient } from "./services/signaling-client"; +export { MediaManager } from "./services/media-manager"; +export { PeerManager } from "./services/peer-manager"; + +// Core provider and hooks +export { CallProvider } from "./providers/CallProvider"; +export { useCall } from "./hooks/useCall"; +export { useParticipants } from "./hooks/useParticipants"; +export { useMediaDevices } from "./hooks/useMediaDevices"; + +// Types +export type { + CallConfig, + CallState, + CallEvent, + CallStats, + MediaSettings, + RecordingOptions, + ProducerSource, +} from "./types/call"; + +export type { + Self, + Participant, + MediaState, + BaseParticipant, + MediaPermissions, +} from "./types/participant"; + +export { CallConnectionStatus } from "./types/call"; + +// Error handling +export { + CallError, + CallErrorType, + ErrorHandler, + errorHandler, + createCallError, + handleError, + onError, +} from "./utils/error-handler"; +export type { CallErrorDetails } from "./utils/error-handler"; diff --git a/packages/call-sdk/src/providers/CallProvider.tsx b/packages/call-sdk/src/providers/CallProvider.tsx new file mode 100644 index 00000000..134aadb0 --- /dev/null +++ b/packages/call-sdk/src/providers/CallProvider.tsx @@ -0,0 +1,370 @@ +import React, { + createContext, + useContext, + useEffect, + useState, + useCallback, + useRef, +} from "react"; +import { + type CallState, + type CallConfig, + type CallStats, + CallConnectionStatus, +} from "../types/call"; +import { CallClient } from "../services/call-client"; + +interface CallContextType { + // Core state + callState: CallState; + isConnected: boolean; + isConnecting: boolean; + localStream: MediaStream | null; + + // Expose CallState properties directly for easier access + self: CallState["self"]; + participants: CallState["participants"]; + dominantSpeakerId: CallState["dominantSpeakerId"]; + pinnedParticipantId: CallState["pinnedParticipantId"]; + + stats?: CallStats; + error?: Error; + + // Actions + joinCall: (config: CallConfig) => Promise; + leaveCall: () => Promise; + toggleMicrophone: () => Promise; + toggleCamera: () => Promise; + startScreenShare: () => Promise; + stopScreenShare: () => Promise; + changeDevice: (type: "audio" | "video", deviceId: string) => Promise; + pinParticipant: (participantId: string) => void; + unpinParticipant: () => void; + + // Device management + audioInputDevices: MediaDeviceInfo[]; + videoInputDevices: MediaDeviceInfo[]; + audioOutputDevices: MediaDeviceInfo[]; + selectedDevices: { + audioInput: string; + videoInput: string; + audioOutput: string; + }; + + // Call client instance (for advanced usage) + callClient: CallClient | null; +} + +const CallContext = createContext(undefined); + +interface CallProviderProps { + children: React.ReactNode; + signalingUrl: string; +} + +export function CallProvider({ children, signalingUrl }: CallProviderProps) { + const callClientRef = useRef(null); + const [callState, setCallState] = useState({ + connectionStatus: CallConnectionStatus.IDLE, + self: null, + participants: new Map(), + permissions: { + audio: false, + video: false, + screen: false, + }, + }); + + const [localStream, setLocalStream] = useState(null); + const [stats, setStats] = useState(); + const [error, setError] = useState(); + + // Device state + const [audioInputDevices, setAudioInputDevices] = useState( + [] + ); + const [videoInputDevices, setVideoInputDevices] = useState( + [] + ); + const [audioOutputDevices, setAudioOutputDevices] = useState< + MediaDeviceInfo[] + >([]); + const [selectedDevices, setSelectedDevices] = useState({ + audioInput: "", + videoInput: "", + audioOutput: "", + }); + + // Initialize CallClient + useEffect(() => { + if (!callClientRef.current) { + callClientRef.current = new CallClient(signalingUrl); + + const client = callClientRef.current; + + // Set up event listeners + client.on("connectionStatusChanged", (status) => { + setCallState((prev) => ({ ...prev, connectionStatus: status })); + if (status === CallConnectionStatus.DISCONNECTED) { + setLocalStream(null); + setCallState((prev) => ({ + ...prev, + participants: new Map(), + dominantSpeakerId: undefined, + pinnedParticipantId: undefined, + })); + setError(undefined); + } + }); + + client.on("participantJoined", (participant) => { + setCallState((prev) => { + const newParticipants = new Map(prev.participants); + newParticipants.set(participant.id, participant); + return { ...prev, participants: newParticipants }; + }); + }); + + client.on("participantLeft", (participantId) => { + setCallState((prev) => { + const newParticipants = new Map(prev.participants); + newParticipants.delete(participantId); + return { + ...prev, + participants: newParticipants, + dominantSpeakerId: + prev.dominantSpeakerId === participantId + ? undefined + : prev.dominantSpeakerId, + pinnedParticipantId: + prev.pinnedParticipantId === participantId + ? undefined + : prev.pinnedParticipantId, + }; + }); + }); + + client.on("participantUpdated", (participant) => { + setCallState((prev) => { + const newParticipants = new Map(prev.participants); + newParticipants.set(participant.id, participant); + return { ...prev, participants: newParticipants }; + }); + }); + + client.on("dominantSpeakerChanged", (speakerId) => { + setCallState((prev) => ({ ...prev, dominantSpeakerId: speakerId })); + }); + + client.on("localStreamChanged", (stream) => { + setLocalStream(stream); + }); + + client.on("error", (err) => { + setError(err); + }); + + client.on("statsUpdated", (callStats) => { + setStats(callStats); + }); + + // Update device lists + const updateDevices = () => { + const devices = client.getMediaDevices(); + setAudioInputDevices(devices.audioInputDevices); + setVideoInputDevices(devices.videoInputDevices); + setAudioOutputDevices(devices.audioOutputDevices); + + const settings = client.getMediaSettings(); + setSelectedDevices({ + audioInput: settings.audioInputDeviceId || "", + videoInput: settings.videoInputDeviceId || "", + audioOutput: settings.audioOutputDeviceId || "", + }); + }; + + // Initial device update + updateDevices(); + + // Listen for device changes + navigator.mediaDevices?.addEventListener("devicechange", updateDevices); + + return () => { + navigator.mediaDevices?.removeEventListener( + "devicechange", + updateDevices + ); + }; + } + }, [signalingUrl]); + + // Cleanup on unmount + useEffect(() => { + return () => { + if (callClientRef.current) { + callClientRef.current.destroy(); + callClientRef.current = null; + } + }; + }, []); + + // Actions + const joinCall = useCallback(async (config: CallConfig) => { + if (!callClientRef.current) return; + + try { + setError(undefined); + await callClientRef.current.joinCall(config); + setCallState(callClientRef.current.getState()); + } catch (err) { + setError(err as Error); + throw err; + } + }, []); + + const leaveCall = useCallback(async () => { + if (!callClientRef.current) return; + + try { + await callClientRef.current.leaveCall(); + setCallState(callClientRef.current.getState()); + } catch (err) { + setError(err as Error); + throw err; + } + }, []); + + const toggleMicrophone = useCallback(async () => { + if (!callClientRef.current) return false; + + try { + const isEnabled = await callClientRef.current.toggleMicrophone(); + setCallState(callClientRef.current.getState()); + return isEnabled; + } catch (err) { + setError(err as Error); + throw err; + } + }, []); + + const toggleCamera = useCallback(async () => { + if (!callClientRef.current) return false; + + try { + const isEnabled = await callClientRef.current.toggleCamera(); + setCallState(callClientRef.current.getState()); + return isEnabled; + } catch (err) { + setError(err as Error); + throw err; + } + }, []); + + const startScreenShare = useCallback(async () => { + if (!callClientRef.current) return; + + try { + await callClientRef.current.startScreenShare(); + setCallState(callClientRef.current.getState()); + } catch (err) { + setError(err as Error); + throw err; + } + }, []); + + const stopScreenShare = useCallback(async () => { + if (!callClientRef.current) return; + + try { + await callClientRef.current.stopScreenShare(); + setCallState(callClientRef.current.getState()); + } catch (err) { + setError(err as Error); + throw err; + } + }, []); + + const changeDevice = useCallback( + async (type: "audio" | "video", deviceId: string) => { + if (!callClientRef.current) return; + + try { + await callClientRef.current.changeDevice(type, deviceId); + + // Update selected devices + setSelectedDevices((prev) => ({ + ...prev, + [type === "audio" ? "audioInput" : "videoInput"]: deviceId, + })); + } catch (err) { + setError(err as Error); + throw err; + } + }, + [] + ); + + // Pin/unpin participant functions + const pinParticipant = useCallback((participantId: string) => { + setCallState((prev) => ({ ...prev, pinnedParticipantId: participantId })); + }, []); + + const unpinParticipant = useCallback(() => { + setCallState((prev) => ({ ...prev, pinnedParticipantId: undefined })); + }, []); + + // Computed values + const isConnected = + callState.connectionStatus === CallConnectionStatus.CONNECTED; + const isConnecting = + callState.connectionStatus === CallConnectionStatus.CONNECTING; + + const contextValue: CallContextType = { + // Core state + callState, + isConnected, + isConnecting, + localStream, + + // Expose CallState properties directly + self: callState.self, + participants: callState.participants, + dominantSpeakerId: callState.dominantSpeakerId, + pinnedParticipantId: callState.pinnedParticipantId, + + stats, + error, + + // Actions + joinCall, + leaveCall, + toggleMicrophone, + toggleCamera, + startScreenShare, + stopScreenShare, + changeDevice, + pinParticipant, + unpinParticipant, + + // Device management + audioInputDevices, + videoInputDevices, + audioOutputDevices, + selectedDevices, + + // Call client instance + callClient: callClientRef.current, + }; + + return ( + {children} + ); +} + +export function useCall() { + const context = useContext(CallContext); + if (context === undefined) { + throw new Error("useCall must be used within a CallProvider"); + } + return context; +} diff --git a/packages/call-sdk/src/services/call-client.ts b/packages/call-sdk/src/services/call-client.ts new file mode 100644 index 00000000..271cfd61 --- /dev/null +++ b/packages/call-sdk/src/services/call-client.ts @@ -0,0 +1,555 @@ +import { EventEmitter } from "events"; +import type { + CallConfig, + CallState, + CallStats, + MediaSettings, +} from "../types/call"; +import { CallConnectionStatus } from "../types/call"; +import type { Self, Participant, MediaPermissions } from "../types/participant"; +import { MediasoupService } from "./mediasoup-service"; +import { MediaManager } from "./media-manager"; +import { SignalingClient } from "./signaling-client"; + +export interface CallClientEvents { + connectionStatusChanged: (status: CallConnectionStatus) => void; + participantJoined: (participant: Participant) => void; + participantLeft: (participantId: string) => void; + participantUpdated: (participant: Participant) => void; + dominantSpeakerChanged: (participantId?: string) => void; + localStreamChanged: (stream: MediaStream | null) => void; + remoteStreamAdded: (stream: MediaStream, participantId: string) => void; + remoteStreamRemoved: (streamId: string, participantId: string) => void; + error: (error: Error) => void; + statsUpdated: (stats: CallStats) => void; +} + +export declare interface CallClient { + on( + event: U, + listener: CallClientEvents[U] + ): this; + emit( + event: U, + ...args: Parameters + ): boolean; +} + +/** + * Main CallClient class that orchestrates all call functionality + */ +export class CallClient extends EventEmitter { + private mediasoupService: MediasoupService; + private mediaManager: MediaManager; + private signalingClient: SignalingClient; + + private state: CallState; + private config: CallConfig | null = null; + private localStream: MediaStream | null = null; + private participants = new Map(); + private dominantSpeakerId?: string; + private statsInterval?: NodeJS.Timeout; + + constructor(signalingUrl: string) { + super(); + + this.mediasoupService = new MediasoupService(signalingUrl); + this.mediaManager = this.mediasoupService.getMediaManager(); + this.signalingClient = this.mediasoupService.getSignalingClient(); + + this.state = { + connectionStatus: CallConnectionStatus.IDLE, + self: null, + participants: new Map(), + permissions: { + audio: false, + video: false, + screen: false, + }, + }; + + this.setupEventListeners(); + } + + private setupEventListeners(): void { + // MediaSoup service events + this.mediasoupService.on("connectionStatusChanged", (status) => { + this.state.connectionStatus = status; + this.emit("connectionStatusChanged", status); + }); + + this.mediasoupService.on( + "newConsumer", + (consumer, peerId, displayName, source) => { + this.handleNewConsumer(consumer, peerId, displayName, source); + } + ); + + this.mediasoupService.on("consumerClosed", (consumerId) => { + this.handleConsumerClosed(consumerId); + }); + + this.mediasoupService.on("error", (error) => { + this.state.error = error; + this.emit("error", error); + }); + + // Signaling client events + this.signalingClient.on("peerJoined", (data) => { + this.handlePeerJoined(data); + }); + + this.signalingClient.on("peerLeft", (data) => { + this.handlePeerLeft(data); + }); + + this.signalingClient.on("audioLevel", (data) => { + this.handleAudioLevel(data); + }); + + // Media manager events + this.mediaManager.on("devicesChanged", () => { + // Emit device change event if needed + }); + + this.mediaManager.on("streamCreated", (stream, source) => { + if (source === "webcam") { + this.localStream = stream; + this.emit("localStreamChanged", stream); + } + }); + + this.mediaManager.on("streamEnded", (source) => { + if (source === "webcam") { + this.localStream = null; + this.emit("localStreamChanged", null); + } + }); + } + + /** + * Join a call with the specified configuration + */ + async joinCall(config: CallConfig): Promise { + try { + this.config = config; + + // Check media permissions + await this.checkMediaPermissions(); + + // Connect to MediaSoup server + await this.mediasoupService.connect(config); + + // Create local media stream if enabled + if (config.initialAudioEnabled || config.initialVideoEnabled) { + await this.enableLocalMedia({ + audio: config.initialAudioEnabled, + video: config.initialVideoEnabled, + }); + } + + // Create self participant + this.state.self = { + id: config.userId || crypto.randomUUID(), + displayName: config.displayName, + isLocal: true, + audioEnabled: config.initialAudioEnabled || false, + videoEnabled: config.initialVideoEnabled || false, + screenShareEnabled: false, + joinedAt: new Date(), + lastActiveAt: new Date(), + isSpeaking: false, + }; + + // Start stats collection + this.startStatsCollection(); + } catch (error) { + this.state.error = error as Error; + throw error; + } + } + + /** + * Leave the current call + */ + async leaveCall(): Promise { + try { + // Stop stats collection + this.stopStatsCollection(); + + // Stop all local media + this.mediaManager.stopAllStreams(); + + // Disconnect from MediaSoup server + await this.mediasoupService.disconnect(); + + // Reset state + this.state = { + connectionStatus: CallConnectionStatus.DISCONNECTED, + self: null, + participants: new Map(), + permissions: { + audio: false, + video: false, + screen: false, + }, + }; + + this.participants.clear(); + this.localStream = null; + this.dominantSpeakerId = undefined; + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Enable local media (camera and/or microphone) + */ + async enableLocalMedia( + options: { audio?: boolean; video?: boolean } = {} + ): Promise { + try { + const stream = await this.mediaManager.createUserMediaStream(options); + + // Produce the media stream + await this.mediasoupService.produceMedia(stream, "webcam"); + + // Update self state + if (this.state.self) { + this.state.self.audioEnabled = options.audio || false; + this.state.self.videoEnabled = options.video || false; + this.state.self.audioTrack = stream.getAudioTracks()[0]; + this.state.self.videoTrack = stream.getVideoTracks()[0]; + } + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Disable local media + */ + async disableLocalMedia( + options: { audio?: boolean; video?: boolean } = {} + ): Promise { + try { + if (options.audio) { + await this.mediasoupService.closeProducer("mic"); + if (this.state.self) { + this.state.self.audioEnabled = false; + this.state.self.audioTrack = undefined; + } + } + + if (options.video) { + await this.mediasoupService.closeProducer("webcam"); + if (this.state.self) { + this.state.self.videoEnabled = false; + this.state.self.videoTrack = undefined; + } + } + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Toggle microphone mute state + */ + async toggleMicrophone(): Promise { + if (!this.state.self) return false; + + try { + const newMutedState = !this.state.self.audioEnabled; + await this.mediasoupService.setProducerMuted("mic", newMutedState); + + this.state.self.audioEnabled = !newMutedState; + return this.state.self.audioEnabled; + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Toggle camera on/off state + */ + async toggleCamera(): Promise { + if (!this.state.self) return false; + + try { + if (this.state.self.videoEnabled) { + await this.disableLocalMedia({ video: true }); + } else { + await this.enableLocalMedia({ video: true }); + } + + return this.state.self.videoEnabled; + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Start screen sharing + */ + async startScreenShare(): Promise { + try { + const stream = await this.mediaManager.createDisplayMediaStream(); + await this.mediasoupService.produceMedia(stream, "screen"); + + if (this.state.self) { + this.state.self.screenShareEnabled = true; + this.state.self.screenShareTrack = stream.getVideoTracks()[0]; + } + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Stop screen sharing + */ + async stopScreenShare(): Promise { + try { + await this.mediasoupService.closeProducer("screen"); + this.mediaManager.stopStream("screen"); + + if (this.state.self) { + this.state.self.screenShareEnabled = false; + this.state.self.screenShareTrack = undefined; + } + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Change media device + */ + async changeDevice(type: "audio" | "video", deviceId: string): Promise { + try { + if (type === "audio") { + this.mediaManager.setAudioInputDevice(deviceId); + } else { + this.mediaManager.setVideoInputDevice(deviceId); + } + + // If we have an active stream, replace the track + if (this.localStream) { + await this.mediaManager.replaceTrack(this.localStream, type, deviceId); + } + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Get current call state + */ + getState(): CallState { + return { + ...this.state, + participants: new Map(this.participants), + }; + } + + /** + * Get available media devices + */ + getMediaDevices() { + return { + audioInputDevices: this.mediaManager.getAudioInputDevices(), + videoInputDevices: this.mediaManager.getVideoInputDevices(), + audioOutputDevices: this.mediaManager.getAudioOutputDevices(), + }; + } + + /** + * Get current media settings + */ + getMediaSettings(): MediaSettings { + const selectedDevices = this.mediaManager.getSelectedDevices(); + return { + audioInputDeviceId: selectedDevices.audioInput, + audioOutputDeviceId: selectedDevices.audioOutput, + videoInputDeviceId: selectedDevices.videoInput, + }; + } + + /** + * Get connection statistics + */ + async getStats(): Promise { + // This would need to be implemented based on MediaSoup stats API + return { + rtt: 0, + packetLoss: 0, + bitrate: 0, + duration: this.state.self + ? Date.now() - this.state.self.joinedAt.getTime() + : 0, + }; + } + + private async checkMediaPermissions(): Promise { + try { + // Check camera permission + try { + const videoStream = await navigator.mediaDevices.getUserMedia({ + video: true, + }); + videoStream.getTracks().forEach((track) => track.stop()); + this.state.permissions.video = true; + } catch { + this.state.permissions.video = false; + } + + // Check microphone permission + try { + const audioStream = await navigator.mediaDevices.getUserMedia({ + audio: true, + }); + audioStream.getTracks().forEach((track) => track.stop()); + this.state.permissions.audio = true; + } catch { + this.state.permissions.audio = false; + } + + // Screen sharing permission is checked when requested + this.state.permissions.screen = true; + } catch (error) { + console.warn("Error checking media permissions:", error); + } + } + + private handleNewConsumer( + consumer: any, + peerId: string, + displayName: string, + source: any + ): void { + let participant = this.participants.get(peerId); + + if (!participant) { + participant = { + id: peerId, + displayName, + isLocal: false, + audioEnabled: false, + videoEnabled: false, + screenShareEnabled: false, + joinedAt: new Date(), + lastActiveAt: new Date(), + isSpeaking: false, + connectionQuality: 1, + }; + this.participants.set(peerId, participant); + this.emit("participantJoined", participant); + } + + // Update participant based on consumer type + const stream = new MediaStream([consumer.track]); + + if (consumer.kind === "audio") { + participant.audioEnabled = true; + participant.audioTrack = consumer.track; + } else if (consumer.kind === "video") { + if (source === "webcam") { + participant.videoEnabled = true; + participant.videoTrack = consumer.track; + } else if (source === "screen") { + participant.screenShareEnabled = true; + participant.screenShareTrack = consumer.track; + } + } + + this.emit("remoteStreamAdded", stream, peerId); + this.emit("participantUpdated", participant); + } + + private handleConsumerClosed(consumerId: string): void { + // Find and update the participant who lost the consumer + for (const [peerId, participant] of this.participants) { + // This would need more sophisticated tracking of consumer IDs + this.emit("remoteStreamRemoved", consumerId, peerId); + this.emit("participantUpdated", participant); + } + } + + private handlePeerJoined(data: any): void { + const participant: Participant = { + id: data.peerId, + displayName: data.displayName, + isLocal: false, + audioEnabled: false, + videoEnabled: false, + screenShareEnabled: false, + joinedAt: new Date(), + lastActiveAt: new Date(), + isSpeaking: false, + connectionQuality: 1, + }; + + this.participants.set(data.peerId, participant); + this.emit("participantJoined", participant); + } + + private handlePeerLeft(data: any): void { + this.participants.delete(data.peerId); + this.emit("participantLeft", data.peerId); + } + + private handleAudioLevel(data: any): void { + const participant = this.participants.get(data.peerId); + if (participant) { + participant.isSpeaking = data.volume > -50; // Threshold for speaking + participant.lastActiveAt = new Date(); + if (participant.isSpeaking) { + participant.lastSpoke = new Date(); + } + this.emit("participantUpdated", participant); + } + + // Update dominant speaker + if (data.volume > -50 && this.dominantSpeakerId !== data.peerId) { + this.dominantSpeakerId = data.peerId; + this.emit("dominantSpeakerChanged", data.peerId); + } + } + + private startStatsCollection(): void { + this.statsInterval = setInterval(async () => { + try { + const stats = await this.getStats(); + this.emit("statsUpdated", stats); + } catch (error) { + console.warn("Error collecting stats:", error); + } + }, 5000); // Collect stats every 5 seconds + } + + private stopStatsCollection(): void { + if (this.statsInterval) { + clearInterval(this.statsInterval); + this.statsInterval = undefined; + } + } + + /** + * Cleanup resources + */ + destroy(): void { + this.stopStatsCollection(); + this.mediasoupService.destroy(); + this.removeAllListeners(); + } +} diff --git a/packages/call-sdk/src/services/media-manager.ts b/packages/call-sdk/src/services/media-manager.ts new file mode 100644 index 00000000..883fee32 --- /dev/null +++ b/packages/call-sdk/src/services/media-manager.ts @@ -0,0 +1,400 @@ +import { EventEmitter } from "events"; +import type { ProducerSource } from "../types/call"; + +// Use the native MediaDeviceInfo interface + +export interface MediaManagerEvents { + devicesChanged: (devices: MediaDeviceInfo[]) => void; + streamCreated: (stream: MediaStream, source: ProducerSource) => void; + streamEnded: (source: ProducerSource) => void; + error: (error: Error) => void; +} + +export declare interface MediaManager { + on( + event: U, + listener: MediaManagerEvents[U] + ): this; + emit( + event: U, + ...args: Parameters + ): boolean; +} + +/** + * Manages media devices and streams + */ +export class MediaManager extends EventEmitter { + private audioDevices: MediaDeviceInfo[] = []; + private videoDevices: MediaDeviceInfo[] = []; + private audioOutputDevices: MediaDeviceInfo[] = []; + private currentStreams = new Map(); + private selectedDevices = { + audioInput: "", + videoInput: "", + audioOutput: "", + }; + + constructor() { + super(); + this.initializeDeviceMonitoring(); + } + + /** + * Initialize device monitoring + */ + private async initializeDeviceMonitoring(): Promise { + try { + // Request initial permissions to get device labels + await navigator.mediaDevices.getUserMedia({ audio: true, video: true }); + + // Get initial device list + await this.updateDeviceList(); + + // Monitor device changes + navigator.mediaDevices.addEventListener("devicechange", () => { + this.updateDeviceList(); + }); + } catch (error) { + console.warn("Failed to initialize device monitoring:", error); + // Still try to get device list without labels + await this.updateDeviceList(); + } + } + + /** + * Update the list of available devices + */ + private async updateDeviceList(): Promise { + try { + const devices = await navigator.mediaDevices.enumerateDevices(); + + this.audioDevices = devices.filter( + (device) => device.kind === "audioinput" + ); + + this.videoDevices = devices.filter( + (device) => device.kind === "videoinput" + ); + + this.audioOutputDevices = devices.filter( + (device) => device.kind === "audiooutput" + ); + + // Set default devices if none selected + if (!this.selectedDevices.audioInput && this.audioDevices.length > 0) { + this.selectedDevices.audioInput = this.audioDevices[0]!.deviceId; + } + if (!this.selectedDevices.videoInput && this.videoDevices.length > 0) { + this.selectedDevices.videoInput = this.videoDevices[0]!.deviceId; + } + if ( + !this.selectedDevices.audioOutput && + this.audioOutputDevices.length > 0 + ) { + this.selectedDevices.audioOutput = this.audioOutputDevices[0]!.deviceId; + } + + this.emit("devicesChanged", [ + ...this.audioDevices, + ...this.videoDevices, + ...this.audioOutputDevices, + ]); + } catch (error) { + this.emit("error", error as Error); + } + } + + /** + * Get available audio input devices + */ + getAudioInputDevices(): MediaDeviceInfo[] { + return [...this.audioDevices]; + } + + /** + * Get available video input devices + */ + getVideoInputDevices(): MediaDeviceInfo[] { + return [...this.videoDevices]; + } + + /** + * Get available audio output devices + */ + getAudioOutputDevices(): MediaDeviceInfo[] { + return [...this.audioOutputDevices]; + } + + /** + * Set selected audio input device + */ + setAudioInputDevice(deviceId: string): void { + this.selectedDevices.audioInput = deviceId; + } + + /** + * Set selected video input device + */ + setVideoInputDevice(deviceId: string): void { + this.selectedDevices.videoInput = deviceId; + } + + /** + * Set selected audio output device + */ + setAudioOutputDevice(deviceId: string): void { + this.selectedDevices.audioOutput = deviceId; + } + + /** + * Get selected device IDs + */ + getSelectedDevices() { + return { ...this.selectedDevices }; + } + + /** + * Create user media stream for camera and microphone + */ + async createUserMediaStream( + options: { + audio?: boolean; + video?: boolean; + audioDeviceId?: string; + videoDeviceId?: string; + } = {} + ): Promise { + const { + audio = true, + video = true, + audioDeviceId = this.selectedDevices.audioInput, + videoDeviceId = this.selectedDevices.videoInput, + } = options; + + try { + const constraints: MediaStreamConstraints = {}; + + if (audio) { + constraints.audio = audioDeviceId + ? { + deviceId: { exact: audioDeviceId }, + echoCancellation: true, + noiseSuppression: true, + autoGainControl: true, + } + : { + echoCancellation: true, + noiseSuppression: true, + autoGainControl: true, + }; + } + + if (video) { + constraints.video = videoDeviceId + ? { + deviceId: { exact: videoDeviceId }, + width: { ideal: 1280 }, + height: { ideal: 720 }, + frameRate: { ideal: 30 }, + } + : { + width: { ideal: 1280 }, + height: { ideal: 720 }, + frameRate: { ideal: 30 }, + }; + } + + const stream = await navigator.mediaDevices.getUserMedia(constraints); + + // Store the stream + this.currentStreams.set("webcam", stream); + this.emit("streamCreated", stream, "webcam"); + + // Handle stream ending + stream.getTracks().forEach((track) => { + track.addEventListener("ended", () => { + this.handleStreamEnded("webcam"); + }); + }); + + return stream; + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Create display media stream for screen sharing + */ + async createDisplayMediaStream( + options: { + video?: boolean; + audio?: boolean; + } = {} + ): Promise { + const { video = true, audio = false } = options; + + try { + const constraints: MediaStreamConstraints = { + video: video + ? { + width: { ideal: 1920 }, + height: { ideal: 1080 }, + frameRate: { ideal: 30 }, + } + : false, + audio, + }; + + const stream = await navigator.mediaDevices.getDisplayMedia(constraints); + + // Store the stream + this.currentStreams.set("screen", stream); + this.emit("streamCreated", stream, "screen"); + + // Handle stream ending (user stops sharing) + stream.getVideoTracks().forEach((track) => { + track.addEventListener("ended", () => { + this.handleStreamEnded("screen"); + }); + }); + + return stream; + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Replace a track in an existing stream + */ + async replaceTrack( + stream: MediaStream, + kind: "audio" | "video", + deviceId?: string + ): Promise { + try { + const constraints: MediaStreamConstraints = {}; + + if (kind === "audio") { + constraints.audio = deviceId + ? { + deviceId: { exact: deviceId }, + echoCancellation: true, + noiseSuppression: true, + autoGainControl: true, + } + : { + echoCancellation: true, + noiseSuppression: true, + autoGainControl: true, + }; + } else { + constraints.video = deviceId + ? { + deviceId: { exact: deviceId }, + width: { ideal: 1280 }, + height: { ideal: 720 }, + frameRate: { ideal: 30 }, + } + : { + width: { ideal: 1280 }, + height: { ideal: 720 }, + frameRate: { ideal: 30 }, + }; + } + + const newStream = await navigator.mediaDevices.getUserMedia(constraints); + const newTrack = newStream + .getTracks() + .find((track) => track.kind === kind); + + if (!newTrack) { + throw new Error(`No ${kind} track found in new stream`); + } + + // Replace the old track + const oldTracks = + kind === "audio" ? stream.getAudioTracks() : stream.getVideoTracks(); + + if (oldTracks.length > 0) { + const oldTrack = oldTracks[0]; + if (oldTrack) { + stream.removeTrack(oldTrack); + oldTrack.stop(); + } + } + + stream.addTrack(newTrack); + return newTrack; + } catch (error) { + this.emit("error", error as Error); + throw error; + } + } + + /** + * Stop a stream by source + */ + stopStream(source: ProducerSource): void { + const stream = this.currentStreams.get(source); + if (stream) { + stream.getTracks().forEach((track) => { + track.stop(); + }); + this.currentStreams.delete(source); + this.emit("streamEnded", source); + } + } + + /** + * Stop all streams + */ + stopAllStreams(): void { + this.currentStreams.forEach((stream, source) => { + stream.getTracks().forEach((track) => { + track.stop(); + }); + this.emit("streamEnded", source); + }); + this.currentStreams.clear(); + } + + /** + * Get current stream by source + */ + getStream(source: ProducerSource): MediaStream | undefined { + return this.currentStreams.get(source); + } + + /** + * Get all current streams + */ + getAllStreams(): Map { + return new Map(this.currentStreams); + } + + /** + * Check if a stream is active + */ + isStreamActive(source: ProducerSource): boolean { + const stream = this.currentStreams.get(source); + return stream ? stream.active : false; + } + + private handleStreamEnded(source: ProducerSource): void { + this.currentStreams.delete(source); + this.emit("streamEnded", source); + } + + /** + * Cleanup resources + */ + destroy(): void { + this.stopAllStreams(); + this.removeAllListeners(); + } +} diff --git a/packages/call-sdk/src/services/mediasoup-service.ts b/packages/call-sdk/src/services/mediasoup-service.ts new file mode 100644 index 00000000..3dcc195c --- /dev/null +++ b/packages/call-sdk/src/services/mediasoup-service.ts @@ -0,0 +1,475 @@ +import { Device } from "mediasoup-client"; +import { EventEmitter } from "events"; +import type { CallConfig, ProducerSource } from "../types/call"; +import { CallConnectionStatus } from "../types/call"; +import { SignalingClient } from "./signaling-client"; +import { MediaManager } from "./media-manager"; + +export interface MediasoupServiceEvents { + connectionStatusChanged: (status: CallConnectionStatus) => void; + newConsumer: ( + consumer: any, + peerId: string, + displayName: string, + source: ProducerSource + ) => void; + consumerClosed: (consumerId: string) => void; + producerCreated: (producer: any, source: ProducerSource) => void; + producerClosed: (producerId: string, source: ProducerSource) => void; + error: (error: Error) => void; +} + +export declare interface MediasoupService { + on( + event: U, + listener: MediasoupServiceEvents[U] + ): this; + emit( + event: U, + ...args: Parameters + ): boolean; +} + +/** + * MediaSoup service that integrates with SignalingClient and MediaManager + */ +export class MediasoupService extends EventEmitter { + private device: Device; + private signalingClient: SignalingClient; + private mediaManager: MediaManager; + private sendTransport: any = null; + private recvTransport: any = null; + private producers = new Map(); + private consumers = new Map(); + private connectionStatus: CallConnectionStatus = CallConnectionStatus.IDLE; + private config: CallConfig | null = null; + + constructor(signalingUrl: string) { + super(); + this.device = new Device(); + this.signalingClient = new SignalingClient(signalingUrl); + this.mediaManager = new MediaManager(); + this.setupEventListeners(); + } + + private setupEventListeners(): void { + // Signaling client events + this.signalingClient.on("connected", () => { + this.setConnectionStatus(CallConnectionStatus.CONNECTED); + }); + + this.signalingClient.on("disconnected", () => { + this.setConnectionStatus(CallConnectionStatus.DISCONNECTED); + }); + + this.signalingClient.on("error", (error) => { + this.emit("error", error); + }); + + this.signalingClient.on("newProducer", async (data) => { + try { + await this.handleNewProducer(data); + } catch (error) { + this.emit("error", error as Error); + } + }); + + this.signalingClient.on("producerClosed", (data) => { + this.handleProducerClosed(data); + }); + + // Media manager events + this.mediaManager.on("error", (error) => { + this.emit("error", error); + }); + } + + /** + * Connect to the MediaSoup server + */ + async connect(config: CallConfig): Promise { + try { + this.config = config; + this.setConnectionStatus(CallConnectionStatus.CONNECTING); + + // Connect to signaling server + await this.signalingClient.connect(); + + // Join the room + const joinResponse = await this.signalingClient.joinRoom( + config.roomId, + config.userId || crypto.randomUUID(), + config.displayName + ); + + // Load MediaSoup device with RTP capabilities + await this.device.load({ + routerRtpCapabilities: joinResponse.rtpCapabilities, + }); + + // Create WebRTC transports + await this.createSendTransport(); + await this.createRecvTransport(); + + // Consume existing producers + for (const producer of joinResponse.producers) { + try { + await this.consumeProducer(producer.id); + } catch (error) { + console.warn( + "Failed to consume existing producer:", + producer.id, + error + ); + } + } + + this.setConnectionStatus(CallConnectionStatus.CONNECTED); + } catch (error) { + this.setConnectionStatus(CallConnectionStatus.FAILED); + throw error; + } + } + + /** + * Disconnect from the MediaSoup server + */ + async disconnect(): Promise { + // Close all producers + this.producers.forEach((producer) => { + producer.close(); + }); + this.producers.clear(); + + // Close all consumers + this.consumers.forEach((consumer) => { + consumer.close(); + }); + this.consumers.clear(); + + // Close transports + if (this.sendTransport) { + this.sendTransport.close(); + this.sendTransport = null; + } + if (this.recvTransport) { + this.recvTransport.close(); + this.recvTransport = null; + } + + // Stop all media streams + this.mediaManager.stopAllStreams(); + + // Disconnect signaling + this.signalingClient.disconnect(); + + this.setConnectionStatus(CallConnectionStatus.DISCONNECTED); + } + + /** + * Produce media from a stream + */ + async produceMedia( + stream: MediaStream, + source: ProducerSource = "webcam" + ): Promise { + if (!this.sendTransport) { + throw new Error("Send transport not available"); + } + + const producers: any[] = []; + + for (const track of stream.getTracks()) { + try { + const producer = await this.sendTransport.produce({ + track, + encodings: this.getEncodings(track.kind as "audio" | "video"), + codecOptions: this.getCodecOptions(track.kind as "audio" | "video"), + }); + + // Store producer + this.producers.set(source, producer); + + // Handle producer events + producer.on("transportclose", () => { + this.producers.delete(source); + this.emit("producerClosed", producer.id, source); + }); + + producer.on("trackended", () => { + this.closeProducer(source); + }); + + producers.push(producer); + this.emit("producerCreated", producer, source); + + console.log( + `Producer created: ${producer.id}, kind: ${track.kind}, source: ${source}` + ); + } catch (error) { + console.error(`Failed to produce ${track.kind} track:`, error); + throw error; + } + } + + return producers; + } + + /** + * Close a producer + */ + async closeProducer(source: ProducerSource): Promise { + const producer = this.producers.get(source); + if (producer) { + try { + await this.signalingClient.closeProducer(producer.id); + producer.close(); + this.producers.delete(source); + this.emit("producerClosed", producer.id, source); + } catch (error) { + console.error("Failed to close producer:", error); + throw error; + } + } + } + + /** + * Set producer muted state + */ + async setProducerMuted( + source: ProducerSource, + muted: boolean + ): Promise { + const producer = this.producers.get(source); + if (producer) { + try { + await this.signalingClient.setProducerMuted(producer.id, muted); + if (muted) { + producer.pause(); + } else { + producer.resume(); + } + } catch (error) { + console.error("Failed to set producer muted state:", error); + throw error; + } + } + } + + /** + * Get MediaManager instance + */ + getMediaManager(): MediaManager { + return this.mediaManager; + } + + /** + * Get SignalingClient instance + */ + getSignalingClient(): SignalingClient { + return this.signalingClient; + } + + /** + * Get current connection status + */ + getConnectionStatus(): CallConnectionStatus { + return this.connectionStatus; + } + + /** + * Get MediaSoup device + */ + getDevice(): Device { + return this.device; + } + + /** + * Get RTP capabilities + */ + getRtpCapabilities(): any { + return this.device.rtpCapabilities; + } + + private async createSendTransport(): Promise { + const transportData = + await this.signalingClient.createWebRtcTransport("send"); + + this.sendTransport = this.device.createSendTransport({ + id: transportData.id, + iceParameters: transportData.iceParameters, + iceCandidates: transportData.iceCandidates, + dtlsParameters: transportData.dtlsParameters, + }); + + this.sendTransport.on( + "connect", + async ({ dtlsParameters }: any, callback: any, errback: any) => { + try { + await this.signalingClient.connectWebRtcTransport( + "send", + dtlsParameters + ); + callback(); + } catch (error) { + errback(error as Error); + } + } + ); + + this.sendTransport.on( + "produce", + async ({ kind, rtpParameters }: any, callback: any, errback: any) => { + try { + const response = await this.signalingClient.produce( + kind as "audio" | "video", + rtpParameters + ); + callback({ id: response.id }); + } catch (error) { + errback(error as Error); + } + } + ); + } + + private async createRecvTransport(): Promise { + const transportData = + await this.signalingClient.createWebRtcTransport("recv"); + + this.recvTransport = this.device.createRecvTransport({ + id: transportData.id, + iceParameters: transportData.iceParameters, + iceCandidates: transportData.iceCandidates, + dtlsParameters: transportData.dtlsParameters, + }); + + this.recvTransport.on( + "connect", + async ({ dtlsParameters }: any, callback: any, errback: any) => { + try { + await this.signalingClient.connectWebRtcTransport( + "recv", + dtlsParameters + ); + callback(); + } catch (error) { + errback(error as Error); + } + } + ); + } + + private async handleNewProducer(data: any): Promise { + if (!this.recvTransport) { + throw new Error("Receive transport not available"); + } + + try { + await this.consumeProducer(data.id); + } catch (error) { + console.error("Failed to consume new producer:", error); + throw error; + } + } + + private async consumeProducer(producerId: string): Promise { + if (!this.recvTransport) { + throw new Error("Receive transport not available"); + } + + try { + const consumeResponse = await this.signalingClient.consume( + producerId, + this.device.rtpCapabilities + ); + + const consumer = await this.recvTransport.consume({ + id: consumeResponse.id, + producerId: consumeResponse.producerId, + kind: consumeResponse.kind as "audio" | "video", + rtpParameters: consumeResponse.rtpParameters, + }); + + this.consumers.set(consumer.id, consumer); + + // Handle consumer events + consumer.on("transportclose", () => { + this.consumers.delete(consumer.id); + this.emit("consumerClosed", consumer.id); + }); + + consumer.on("producerclose", () => { + this.consumers.delete(consumer.id); + this.emit("consumerClosed", consumer.id); + }); + + this.emit( + "newConsumer", + consumer, + consumeResponse.peerId, + consumeResponse.displayName, + consumeResponse.source + ); + + console.log( + `Consumer created: ${consumer.id} for producer: ${producerId}` + ); + } catch (error) { + console.error("Failed to consume producer:", error); + throw error; + } + } + + private handleProducerClosed(data: any): void { + const consumer = Array.from(this.consumers.values()).find( + (c) => (c as any).producerId === data.producerId + ); + + if (consumer) { + consumer.close(); + this.consumers.delete(consumer.id); + this.emit("consumerClosed", consumer.id); + } + } + + private getEncodings(kind: "audio" | "video"): any[] { + if (kind === "video") { + return [ + { maxBitrate: 100000 }, + { maxBitrate: 300000 }, + { maxBitrate: 900000 }, + ]; + } + return []; + } + + private getCodecOptions(kind: "audio" | "video"): any { + if (kind === "audio") { + return { + opusStereo: true, + opusDtx: true, + }; + } + if (kind === "video") { + return { + videoGoogleStartBitrate: 1000, + }; + } + return {}; + } + + private setConnectionStatus(status: CallConnectionStatus): void { + this.connectionStatus = status; + this.emit("connectionStatusChanged", status); + } + + /** + * Cleanup resources + */ + destroy(): void { + this.disconnect(); + this.mediaManager.destroy(); + this.removeAllListeners(); + } +} diff --git a/packages/call-sdk/src/services/peer-manager.ts b/packages/call-sdk/src/services/peer-manager.ts new file mode 100644 index 00000000..15e726f7 --- /dev/null +++ b/packages/call-sdk/src/services/peer-manager.ts @@ -0,0 +1,295 @@ +/** + * PeerManager handles participant management and peer-to-peer connections + */ + +import { EventEmitter } from "events"; +import type { Participant, Self } from "../types/participant"; +import type { CallState } from "../types/call"; + +export interface PeerManagerEvents { + participantJoined: (participant: Participant) => void; + participantLeft: (participantId: string) => void; + participantUpdated: (participant: Participant) => void; + dominantSpeakerChanged: (speakerId?: string) => void; + audioLevelChanged: (participantId: string, level: number) => void; +} + +export class PeerManager extends EventEmitter { + private participants = new Map(); + private self: Self | null = null; + private dominantSpeakerId?: string; + private pinnedParticipantId?: string; + private audioLevels = new Map(); + private dominantSpeakerTimer?: NodeJS.Timeout; + + constructor() { + super(); + } + + /** + * Get current call state + */ + getState(): Pick< + CallState, + "self" | "participants" | "dominantSpeakerId" | "pinnedParticipantId" + > { + return { + self: this.self, + participants: new Map(this.participants), + dominantSpeakerId: this.dominantSpeakerId, + pinnedParticipantId: this.pinnedParticipantId, + }; + } + + /** + * Set local participant (self) + */ + setSelf(self: Self): void { + this.self = self; + } + + /** + * Get local participant + */ + getSelf(): Self | null { + return this.self; + } + + /** + * Add a new participant + */ + addParticipant(participant: Participant): void { + this.participants.set(participant.id, participant); + this.emit("participantJoined", participant); + } + + /** + * Remove a participant + */ + removeParticipant(participantId: string): void { + const participant = this.participants.get(participantId); + if (participant) { + this.participants.delete(participantId); + this.audioLevels.delete(participantId); + + // Clear dominant speaker if it was this participant + if (this.dominantSpeakerId === participantId) { + this.setDominantSpeaker(undefined); + } + + // Clear pinned participant if it was this participant + if (this.pinnedParticipantId === participantId) { + this.pinnedParticipantId = undefined; + } + + this.emit("participantLeft", participantId); + } + } + + /** + * Update participant information + */ + updateParticipant( + participantUpdate: Partial & { id: string } + ): void { + const existing = this.participants.get(participantUpdate.id); + if (existing) { + const updated = { ...existing, ...participantUpdate }; + this.participants.set(participantUpdate.id, updated); + this.emit("participantUpdated", updated); + } + } + + /** + * Get a participant by ID + */ + getParticipant(participantId: string): Participant | undefined { + return this.participants.get(participantId); + } + + /** + * Get all participants as an array + */ + getParticipants(): Participant[] { + return Array.from(this.participants.values()); + } + + /** + * Get participants count + */ + getParticipantCount(): number { + return this.participants.size + (this.self ? 1 : 0); + } + + /** + * Set dominant speaker + */ + setDominantSpeaker(speakerId?: string): void { + if (this.dominantSpeakerId !== speakerId) { + this.dominantSpeakerId = speakerId; + this.emit("dominantSpeakerChanged", speakerId); + } + } + + /** + * Get current dominant speaker + */ + getDominantSpeaker(): string | undefined { + return this.dominantSpeakerId; + } + + /** + * Update audio level for a participant + */ + updateAudioLevel(participantId: string, level: number): void { + this.audioLevels.set(participantId, level); + this.emit("audioLevelChanged", participantId, level); + + // Auto-detect dominant speaker based on audio levels + this.updateDominantSpeakerFromAudioLevels(); + } + + /** + * Get audio level for a participant + */ + getAudioLevel(participantId: string): number { + return this.audioLevels.get(participantId) || 0; + } + + /** + * Pin a participant + */ + pinParticipant(participantId: string): void { + if ( + this.participants.has(participantId) || + participantId === this.self?.id + ) { + this.pinnedParticipantId = participantId; + } + } + + /** + * Unpin the currently pinned participant + */ + unpinParticipant(): void { + this.pinnedParticipantId = undefined; + } + + /** + * Get pinned participant ID + */ + getPinnedParticipant(): string | undefined { + return this.pinnedParticipantId; + } + + /** + * Check if a participant is currently speaking (has high audio level) + */ + isParticipantSpeaking(participantId: string): boolean { + const level = this.audioLevels.get(participantId) || 0; + return level > 0.1; // Threshold for considering someone as speaking + } + + /** + * Get participants sorted by activity (speaking, screen sharing, etc.) + */ + getSortedParticipants(): Participant[] { + const participants = this.getParticipants(); + + return participants.sort((a, b) => { + // Pinned participant first + if (a.id === this.pinnedParticipantId) return -1; + if (b.id === this.pinnedParticipantId) return 1; + + // Screen sharing participants next + if (a.screenShareEnabled && !b.screenShareEnabled) return -1; + if (!a.screenShareEnabled && b.screenShareEnabled) return 1; + + // Dominant speaker next + if (a.id === this.dominantSpeakerId) return -1; + if (b.id === this.dominantSpeakerId) return 1; + + // Speaking participants next + const aLevel = this.audioLevels.get(a.id) || 0; + const bLevel = this.audioLevels.get(b.id) || 0; + if (aLevel > 0.1 && bLevel <= 0.1) return -1; + if (aLevel <= 0.1 && bLevel > 0.1) return 1; + + // Sort by join time + return a.joinedAt.getTime() - b.joinedAt.getTime(); + }); + } + + /** + * Get active participants (speaking or sharing screen) + */ + getActiveParticipants(): Participant[] { + return this.getParticipants().filter( + (participant) => + participant.screenShareEnabled || + participant.id === this.dominantSpeakerId || + this.isParticipantSpeaking(participant.id) + ); + } + + /** + * Clear all participants (used when leaving call) + */ + clear(): void { + this.participants.clear(); + this.audioLevels.clear(); + this.self = null; + this.dominantSpeakerId = undefined; + this.pinnedParticipantId = undefined; + + if (this.dominantSpeakerTimer) { + clearTimeout(this.dominantSpeakerTimer); + this.dominantSpeakerTimer = undefined; + } + } + + /** + * Update dominant speaker based on audio levels + */ + private updateDominantSpeakerFromAudioLevels(): void { + // Clear existing timer + if (this.dominantSpeakerTimer) { + clearTimeout(this.dominantSpeakerTimer); + } + + // Find participant with highest audio level above threshold + let maxLevel = 0.1; // Minimum threshold + let newDominantSpeaker: string | undefined; + + for (const [participantId, level] of this.audioLevels) { + if (level > maxLevel) { + maxLevel = level; + newDominantSpeaker = participantId; + } + } + + // Set new dominant speaker if different + if (newDominantSpeaker !== this.dominantSpeakerId) { + this.setDominantSpeaker(newDominantSpeaker); + } + + // Clear dominant speaker after period of silence + if (newDominantSpeaker) { + this.dominantSpeakerTimer = setTimeout(() => { + // Check if still speaking + const currentLevel = this.audioLevels.get(newDominantSpeaker!) || 0; + if (currentLevel <= 0.1) { + this.setDominantSpeaker(undefined); + } + }, 2000); // 2 seconds of silence + } + } + + /** + * Destroy the peer manager + */ + destroy(): void { + this.clear(); + this.removeAllListeners(); + } +} diff --git a/packages/call-sdk/src/services/signaling-client.ts b/packages/call-sdk/src/services/signaling-client.ts new file mode 100644 index 00000000..62e9220b --- /dev/null +++ b/packages/call-sdk/src/services/signaling-client.ts @@ -0,0 +1,318 @@ +import { EventEmitter } from "events"; +import type { + ServerMessage, + JoinRoomResponse, + CreateTransportResponse, + ProduceResponse, + ConsumeResponse, + NewProducerNotification, + ProducerClosedNotification, + AudioLevelNotification, + PeerJoinedNotification, + PeerLeftNotification, +} from "../types/call"; + +export interface SignalingClientEvents { + connected: () => void; + disconnected: () => void; + error: (error: Error) => void; + newProducer: (data: NewProducerNotification) => void; + producerClosed: (data: ProducerClosedNotification) => void; + audioLevel: (data: AudioLevelNotification) => void; + peerJoined: (data: PeerJoinedNotification) => void; + peerLeft: (data: PeerLeftNotification) => void; + producerMuted: (data: { + peerId: string; + producerId: string; + muted: boolean; + }) => void; +} + +export declare interface SignalingClient { + on( + event: U, + listener: SignalingClientEvents[U] + ): this; + emit( + event: U, + ...args: Parameters + ): boolean; +} + +/** + * WebSocket signaling client that matches the MediaSoup server protocol + */ +export class SignalingClient extends EventEmitter { + private ws: WebSocket | null = null; + private url: string; + private pendingRequests = new Map< + string, + { + resolve: (value: any) => void; + reject: (error: Error) => void; + timeout: NodeJS.Timeout; + } + >(); + private reconnectAttempts = 0; + private maxReconnectAttempts = 5; + private reconnectDelay = 1000; + private isConnected = false; + + constructor(url: string) { + super(); + this.url = url; + } + + /** + * Connect to the WebSocket server + */ + async connect(): Promise { + return new Promise((resolve, reject) => { + try { + this.ws = new WebSocket(this.url); + + this.ws.onopen = () => { + this.isConnected = true; + this.reconnectAttempts = 0; + this.emit("connected"); + resolve(); + }; + + this.ws.onclose = () => { + this.isConnected = false; + this.emit("disconnected"); + this.handleReconnect(); + }; + + this.ws.onerror = (event) => { + const error = new Error("WebSocket connection error"); + this.emit("error", error); + reject(error); + }; + + this.ws.onmessage = (event) => { + this.handleMessage(event); + }; + } catch (error) { + reject(error as Error); + } + }); + } + + /** + * Disconnect from the WebSocket server + */ + disconnect(): void { + this.isConnected = false; + this.reconnectAttempts = this.maxReconnectAttempts; // Prevent reconnection + + // Reject all pending requests + this.pendingRequests.forEach(({ reject, timeout }) => { + clearTimeout(timeout); + reject(new Error("Connection closed")); + }); + this.pendingRequests.clear(); + + if (this.ws) { + this.ws.close(); + this.ws = null; + } + } + + /** + * Send a request and wait for response + */ + async sendRequest(type: string, data: any = {}): Promise { + if (!this.ws || this.ws.readyState !== WebSocket.OPEN) { + throw new Error("WebSocket not connected"); + } + + const reqId = this.generateRequestId(); + const message = { type, reqId, ...data }; + + return new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + this.pendingRequests.delete(reqId); + reject(new Error(`Request timeout for ${type}`)); + }, 10000); + + this.pendingRequests.set(reqId, { resolve, reject, timeout }); + this.ws!.send(JSON.stringify(message)); + }); + } + + /** + * Join a room + */ + async joinRoom( + roomId: string, + peerId: string, + displayName: string + ): Promise { + return this.sendRequest("joinRoom", { + roomId, + peerId, + displayName, + }); + } + + /** + * Create WebRTC transport + */ + async createWebRtcTransport( + direction: "send" | "recv" + ): Promise { + return this.sendRequest("createWebRtcTransport", { + direction, + }); + } + + /** + * Connect WebRTC transport + */ + async connectWebRtcTransport( + direction: "send" | "recv", + dtlsParameters: any + ): Promise { + return this.sendRequest("connectWebRtcTransport", { + direction, + dtlsParameters, + }); + } + + /** + * Produce media + */ + async produce( + kind: "audio" | "video", + rtpParameters: any, + source?: string + ): Promise { + return this.sendRequest("produce", { + kind, + rtpParameters, + source, + }); + } + + /** + * Consume media + */ + async consume( + producerId: string, + rtpCapabilities: any + ): Promise { + return this.sendRequest("consume", { + producerId, + rtpCapabilities, + }); + } + + /** + * Set producer muted state + */ + async setProducerMuted(producerId: string, muted: boolean): Promise { + return this.sendRequest("setProducerMuted", { + producerId, + muted, + }); + } + + /** + * Close producer + */ + async closeProducer(producerId: string): Promise { + return this.sendRequest("closeProducer", { + producerId, + }); + } + + /** + * Send chat message + */ + async sendChatMessage(message: string): Promise { + return this.sendRequest("chat", { + message, + }); + } + + private handleMessage(event: MessageEvent): void { + try { + const message: ServerMessage = JSON.parse(event.data); + + // Handle responses to requests + if (message.reqId && this.pendingRequests.has(message.reqId)) { + const { resolve, reject, timeout } = this.pendingRequests.get( + message.reqId + )!; + this.pendingRequests.delete(message.reqId); + clearTimeout(timeout); + + if (message.error) { + reject(new Error(message.error)); + } else { + resolve(message); + } + return; + } + + // Handle notifications + switch (message.type) { + case "newProducer": + this.emit("newProducer", message as NewProducerNotification); + break; + case "producerClosed": + this.emit("producerClosed", message as ProducerClosedNotification); + break; + case "audioLevel": + this.emit("audioLevel", message as AudioLevelNotification); + break; + case "peerJoined": + this.emit("peerJoined", message as PeerJoinedNotification); + break; + case "peerLeft": + this.emit("peerLeft", message as PeerLeftNotification); + break; + case "producerMuted": + this.emit("producerMuted", { + peerId: message.peerId, + producerId: message.producerId, + muted: message.muted, + }); + break; + case "chat": + // Handle chat messages if needed + break; + default: + console.warn("Unknown message type:", message.type); + } + } catch (error) { + console.error("Error parsing WebSocket message:", error); + } + } + + private handleReconnect(): void { + if (this.reconnectAttempts >= this.maxReconnectAttempts) { + return; + } + + this.reconnectAttempts++; + const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1); + + setTimeout(() => { + if (!this.isConnected) { + this.connect().catch((error) => { + console.error("Reconnection failed:", error); + }); + } + }, delay); + } + + private generateRequestId(): string { + return Math.random().toString(36).substring(2, 15); + } + + get connected(): boolean { + return this.isConnected; + } +} diff --git a/packages/call-sdk/src/types/call.ts b/packages/call-sdk/src/types/call.ts new file mode 100644 index 00000000..c74d639e --- /dev/null +++ b/packages/call-sdk/src/types/call.ts @@ -0,0 +1,327 @@ +/** + * Types for call management and state + */ + +import type { Participant, Self, MediaPermissions } from "./participant"; + +/** + * Supported media types in a call + */ +export type MediaType = "audio" | "video" | "screen"; + +/** + * Producer source types matching server implementation + */ +export type ProducerSource = "mic" | "webcam" | "screen"; + +/** + * Call connection status + */ +export enum CallConnectionStatus { + IDLE = "idle", + CONNECTING = "connecting", + CONNECTED = "connected", + RECONNECTING = "reconnecting", + DISCONNECTED = "disconnected", + FAILED = "failed", +} + +/** + * Configuration options for initializing a call + */ +export interface CallConfig { + /** + * Unique identifier for the room + */ + roomId: string; + + /** + * Initial display name for the local participant + */ + displayName: string; + + /** + * Optional user ID for the local participant + */ + userId?: string; + + /** + * Whether to join with audio enabled + * @default false + */ + initialAudioEnabled?: boolean; + + /** + * Whether to join with video enabled + * @default false + */ + initialVideoEnabled?: boolean; + + /** + * Maximum number of participants allowed in the call + * @default 16 + */ + maxParticipants?: number; + + /** + * WebRTC configuration options + */ + rtcConfig?: RTCConfiguration; +} + +/** + * Core call state + */ +export interface CallState { + /** + * Current connection status of the call + */ + connectionStatus: CallConnectionStatus; + + /** + * Local participant information + */ + self: Self | null; + + /** + * Map of remote participants indexed by their IDs + */ + participants: Map; + + /** + * ID of the currently dominant speaker + */ + dominantSpeakerId?: string; + + /** + * ID of the currently pinned participant + */ + pinnedParticipantId?: string; + + /** + * Current error state, if any + */ + error?: Error; + + /** + * Current media device permissions + */ + permissions: MediaPermissions; +} + +/** + * Call statistics and metrics + */ +export interface CallStats { + /** + * Round trip time in milliseconds + */ + rtt: number; + + /** + * Packet loss percentage + */ + packetLoss: number; + + /** + * Bitrate in kilobits per second + */ + bitrate: number; + + /** + * Call duration in seconds + */ + duration: number; +} + +/** + * Events that can be emitted during a call + */ +export enum CallEvent { + PARTICIPANT_JOINED = "participantJoined", + PARTICIPANT_LEFT = "participantLeft", + DOMINANT_SPEAKER_CHANGED = "dominantSpeakerChanged", + CONNECTION_STATUS_CHANGED = "connectionStatusChanged", + MEDIA_STATUS_CHANGED = "mediaStatusChanged", + ERROR = "error", +} + +/** + * Media device settings for the call + */ +export interface MediaSettings { + /** + * Selected audio input device ID + */ + audioInputDeviceId?: string; + + /** + * Selected audio output device ID + */ + audioOutputDeviceId?: string; + + /** + * Selected video input device ID + */ + videoInputDeviceId?: string; + + /** + * Audio constraints for the call + */ + audioConstraints?: MediaTrackConstraints; + + /** + * Video constraints for the call + */ + videoConstraints?: MediaTrackConstraints; +} + +/** + * Recording options for the call + */ +export interface RecordingOptions { + /** + * Whether to record audio + */ + audio: boolean; + + /** + * Whether to record video + */ + video: boolean; + + /** + * Recording format + */ + format: "webm" | "mp4"; + + /** + * Quality of the recording (0-1) + */ + quality?: number; +} + +/** + * Server message types matching MediaSoup server protocol + */ +export interface ServerMessage { + type: string; + reqId?: string; + [key: string]: any; +} + +export interface JoinRoomRequest extends ServerMessage { + type: "joinRoom"; + roomId: string; + peerId: string; + displayName: string; +} + +export interface JoinRoomResponse extends ServerMessage { + type: "joinRoomResponse"; + rtpCapabilities: any; + peers: Array<{ + id: string; + displayName: string; + connectionState: string; + }>; + producers: Array<{ + id: string; + peerId: string; + kind: "audio" | "video"; + source: ProducerSource; + displayName: string; + muted: boolean; + }>; +} + +export interface CreateTransportRequest extends ServerMessage { + type: "createWebRtcTransport"; + direction: "send" | "recv"; +} + +export interface CreateTransportResponse extends ServerMessage { + type: "createWebRtcTransportResponse"; + id: string; + iceParameters: any; + iceCandidates: any[]; + dtlsParameters: any; + sctpParameters?: any; +} + +export interface ConnectTransportRequest extends ServerMessage { + type: "connectWebRtcTransport"; + direction: "send" | "recv"; + dtlsParameters: any; +} + +export interface ProduceRequest extends ServerMessage { + type: "produce"; + kind: "audio" | "video"; + rtpParameters: any; + source?: ProducerSource; +} + +export interface ProduceResponse extends ServerMessage { + type: "produceResponse"; + id: string; +} + +export interface ConsumeRequest extends ServerMessage { + type: "consume"; + producerId: string; + rtpCapabilities: any; +} + +export interface ConsumeResponse extends ServerMessage { + type: "consumeResponse"; + id: string; + producerId: string; + kind: "audio" | "video"; + rtpParameters: any; + peerId: string; + displayName: string; + source: ProducerSource; + muted: boolean; +} + +export interface NewProducerNotification extends ServerMessage { + type: "newProducer"; + id: string; + peerId: string; + kind: "audio" | "video"; + source: ProducerSource; + displayName: string; + muted: boolean; +} + +export interface ProducerClosedNotification extends ServerMessage { + type: "producerClosed"; + peerId: string; + producerId: string; +} + +export interface SetProducerMutedRequest extends ServerMessage { + type: "setProducerMuted"; + producerId: string; + muted: boolean; +} + +export interface AudioLevelNotification extends ServerMessage { + type: "audioLevel"; + peerId: string; + volume: number; +} + +export interface PeerJoinedNotification extends ServerMessage { + type: "peerJoined"; + peerId: string; + displayName: string; + isCreator: boolean; +} + +export interface PeerLeftNotification extends ServerMessage { + type: "peerLeft"; + peerId: string; + displayName: string; +} diff --git a/packages/call-sdk/src/types/participant.ts b/packages/call-sdk/src/types/participant.ts new file mode 100644 index 00000000..b75305e5 --- /dev/null +++ b/packages/call-sdk/src/types/participant.ts @@ -0,0 +1,135 @@ +/** + * Represents the media capabilities and state of a participant + */ +export interface MediaState { + /** + * Whether the participant's audio is enabled + */ + audioEnabled: boolean; + + /** + * Whether the participant's video is enabled + */ + videoEnabled: boolean; + + /** + * Whether the participant is sharing their screen + */ + screenShareEnabled: boolean; + + /** + * The participant's audio track, if available + */ + audioTrack?: MediaStreamTrack; + + /** + * The participant's video track, if available + */ + videoTrack?: MediaStreamTrack; + + /** + * The participant's screen share track, if available + */ + screenShareTrack?: MediaStreamTrack; +} + +/** + * Base interface for both local and remote participants + */ +export interface BaseParticipant extends MediaState { + /** + * Unique identifier for the participant + */ + id: string; + + /** + * Display name of the participant + */ + displayName: string; + + /** + * Timestamp when the participant joined the call + */ + joinedAt: Date; + + /** + * Timestamp of the participant's last activity + */ + lastActiveAt: Date; + + /** + * Timestamp when the participant last spoke + */ + lastSpoke?: Date; + + /** + * Whether the participant is currently speaking + */ + isSpeaking: boolean; +} + +/** + * Represents the local participant (self) in the call + */ +export interface Self extends BaseParticipant { + /** + * Flag to identify local participant + */ + isLocal: true; +} + +/** + * Represents a remote participant in the call + */ +export interface Participant extends BaseParticipant { + /** + * Flag to identify remote participant + */ + isLocal: false; + + /** + * Connection quality metric (0-1) + */ + connectionQuality: number; +} + +/** + * Union type for any participant type + */ +export type AnyParticipant = Self | Participant; + +/** + * Type guard to check if a participant is the local participant + */ +export function isSelf(participant: AnyParticipant): participant is Self { + return participant.isLocal === true; +} + +/** + * Type guard to check if a participant is a remote participant + */ +export function isRemoteParticipant( + participant: AnyParticipant +): participant is Participant { + return participant.isLocal === false; +} + +/** + * Represents the connection status of a participant + */ +export enum ParticipantConnectionStatus { + CONNECTING = "connecting", + CONNECTED = "connected", + DISCONNECTED = "disconnected", + RECONNECTING = "reconnecting", + FAILED = "failed", +} + +/** + * Media device permissions status + */ +export interface MediaPermissions { + audio: boolean; + video: boolean; + screen: boolean; +} diff --git a/packages/call-sdk/src/utils/error-handler.ts b/packages/call-sdk/src/utils/error-handler.ts new file mode 100644 index 00000000..e4acc172 --- /dev/null +++ b/packages/call-sdk/src/utils/error-handler.ts @@ -0,0 +1,414 @@ +/** + * Comprehensive error handling and recovery utilities for the Call SDK + */ + +export enum CallErrorType { + // Connection errors + CONNECTION_FAILED = "CONNECTION_FAILED", + CONNECTION_LOST = "CONNECTION_LOST", + RECONNECTION_FAILED = "RECONNECTION_FAILED", + WEBSOCKET_ERROR = "WEBSOCKET_ERROR", + + // Media errors + MEDIA_DEVICE_ERROR = "MEDIA_DEVICE_ERROR", + MEDIA_PERMISSION_DENIED = "MEDIA_PERMISSION_DENIED", + MEDIA_STREAM_ERROR = "MEDIA_STREAM_ERROR", + SCREEN_SHARE_ERROR = "SCREEN_SHARE_ERROR", + + // MediaSoup errors + TRANSPORT_ERROR = "TRANSPORT_ERROR", + PRODUCER_ERROR = "PRODUCER_ERROR", + CONSUMER_ERROR = "CONSUMER_ERROR", + RTP_CAPABILITIES_ERROR = "RTP_CAPABILITIES_ERROR", + + // Room/Call errors + ROOM_NOT_FOUND = "ROOM_NOT_FOUND", + ROOM_FULL = "ROOM_FULL", + PARTICIPANT_LIMIT_EXCEEDED = "PARTICIPANT_LIMIT_EXCEEDED", + INVALID_ROOM_ID = "INVALID_ROOM_ID", + + // Authentication errors + UNAUTHORIZED = "UNAUTHORIZED", + TOKEN_EXPIRED = "TOKEN_EXPIRED", + INVALID_CREDENTIALS = "INVALID_CREDENTIALS", + + // General errors + UNKNOWN_ERROR = "UNKNOWN_ERROR", + TIMEOUT_ERROR = "TIMEOUT_ERROR", + NETWORK_ERROR = "NETWORK_ERROR", +} + +export interface CallErrorDetails { + type: CallErrorType; + message: string; + originalError?: Error; + context?: Record; + timestamp: Date; + recoverable: boolean; + retryable: boolean; +} + +export class CallError extends Error { + public readonly type: CallErrorType; + public readonly originalError?: Error; + public readonly context?: Record; + public readonly timestamp: Date; + public readonly recoverable: boolean; + public readonly retryable: boolean; + + constructor(details: CallErrorDetails) { + super(details.message); + this.name = "CallError"; + this.type = details.type; + this.originalError = details.originalError; + this.context = details.context; + this.timestamp = details.timestamp; + this.recoverable = details.recoverable; + this.retryable = details.retryable; + } + + toJSON() { + return { + name: this.name, + type: this.type, + message: this.message, + context: this.context, + timestamp: this.timestamp, + recoverable: this.recoverable, + retryable: this.retryable, + stack: this.stack, + }; + } +} + +export class ErrorHandler { + private static instance: ErrorHandler; + private errorListeners: Array<(error: CallError) => void> = []; + private retryAttempts = new Map(); + private maxRetryAttempts = 3; + private retryDelay = 1000; // Base delay in ms + + static getInstance(): ErrorHandler { + if (!ErrorHandler.instance) { + ErrorHandler.instance = new ErrorHandler(); + } + return ErrorHandler.instance; + } + + /** + * Add an error listener + */ + onError(listener: (error: CallError) => void): () => void { + this.errorListeners.push(listener); + return () => { + const index = this.errorListeners.indexOf(listener); + if (index > -1) { + this.errorListeners.splice(index, 1); + } + }; + } + + /** + * Handle an error with automatic recovery if possible + */ + async handleError( + error: Error | CallError, + context?: Record + ): Promise { + const callError = + error instanceof CallError ? error : this.createCallError(error, context); + + // Notify listeners + this.errorListeners.forEach((listener) => { + try { + listener(callError); + } catch (err) { + console.error("Error in error listener:", err); + } + }); + + // Attempt recovery if the error is recoverable + if (callError.recoverable) { + await this.attemptRecovery(callError); + } + } + + /** + * Create a CallError from a generic Error + */ + createCallError(error: Error, context?: Record): CallError { + const type = this.categorizeError(error); + const { recoverable, retryable } = this.getErrorProperties(type); + + return new CallError({ + type, + message: error.message || "An unknown error occurred", + originalError: error, + context, + timestamp: new Date(), + recoverable, + retryable, + }); + } + + /** + * Categorize an error based on its properties + */ + private categorizeError(error: Error): CallErrorType { + const message = error.message.toLowerCase(); + + // Connection errors + if (message.includes("websocket") || message.includes("connection")) { + if (message.includes("failed") || message.includes("refused")) { + return CallErrorType.CONNECTION_FAILED; + } + if (message.includes("lost") || message.includes("closed")) { + return CallErrorType.CONNECTION_LOST; + } + return CallErrorType.WEBSOCKET_ERROR; + } + + // Media errors + if (message.includes("permission") || message.includes("denied")) { + return CallErrorType.MEDIA_PERMISSION_DENIED; + } + if ( + message.includes("device") || + message.includes("microphone") || + message.includes("camera") + ) { + return CallErrorType.MEDIA_DEVICE_ERROR; + } + if (message.includes("screen") || message.includes("display")) { + return CallErrorType.SCREEN_SHARE_ERROR; + } + if (message.includes("stream") || message.includes("track")) { + return CallErrorType.MEDIA_STREAM_ERROR; + } + + // MediaSoup errors + if (message.includes("transport")) { + return CallErrorType.TRANSPORT_ERROR; + } + if (message.includes("producer")) { + return CallErrorType.PRODUCER_ERROR; + } + if (message.includes("consumer")) { + return CallErrorType.CONSUMER_ERROR; + } + if (message.includes("rtp") || message.includes("capabilities")) { + return CallErrorType.RTP_CAPABILITIES_ERROR; + } + + // Room errors + if (message.includes("room not found") || message.includes("404")) { + return CallErrorType.ROOM_NOT_FOUND; + } + if (message.includes("room full") || message.includes("capacity")) { + return CallErrorType.ROOM_FULL; + } + if (message.includes("participant limit")) { + return CallErrorType.PARTICIPANT_LIMIT_EXCEEDED; + } + + // Auth errors + if (message.includes("unauthorized") || message.includes("401")) { + return CallErrorType.UNAUTHORIZED; + } + if (message.includes("token") || message.includes("expired")) { + return CallErrorType.TOKEN_EXPIRED; + } + + // Network errors + if (message.includes("network") || message.includes("timeout")) { + return CallErrorType.NETWORK_ERROR; + } + + return CallErrorType.UNKNOWN_ERROR; + } + + /** + * Get error properties based on error type + */ + private getErrorProperties(type: CallErrorType): { + recoverable: boolean; + retryable: boolean; + } { + switch (type) { + case CallErrorType.CONNECTION_LOST: + case CallErrorType.WEBSOCKET_ERROR: + case CallErrorType.TRANSPORT_ERROR: + case CallErrorType.NETWORK_ERROR: + return { recoverable: true, retryable: true }; + + case CallErrorType.CONNECTION_FAILED: + case CallErrorType.PRODUCER_ERROR: + case CallErrorType.CONSUMER_ERROR: + return { recoverable: true, retryable: true }; + + case CallErrorType.MEDIA_DEVICE_ERROR: + case CallErrorType.MEDIA_STREAM_ERROR: + return { recoverable: true, retryable: false }; + + case CallErrorType.MEDIA_PERMISSION_DENIED: + case CallErrorType.UNAUTHORIZED: + case CallErrorType.TOKEN_EXPIRED: + case CallErrorType.ROOM_NOT_FOUND: + case CallErrorType.ROOM_FULL: + case CallErrorType.PARTICIPANT_LIMIT_EXCEEDED: + return { recoverable: false, retryable: false }; + + default: + return { recoverable: false, retryable: true }; + } + } + + /** + * Attempt to recover from an error + */ + private async attemptRecovery(error: CallError): Promise { + const recoveryKey = `${error.type}_${error.context?.roomId || "global"}`; + const attempts = this.retryAttempts.get(recoveryKey) || 0; + + if (!error.retryable || attempts >= this.maxRetryAttempts) { + this.retryAttempts.delete(recoveryKey); + return; + } + + this.retryAttempts.set(recoveryKey, attempts + 1); + + // Exponential backoff + const delay = this.retryDelay * Math.pow(2, attempts); + await new Promise((resolve) => setTimeout(resolve, delay)); + + try { + await this.executeRecovery(error); + this.retryAttempts.delete(recoveryKey); // Success, reset attempts + } catch (recoveryError) { + console.error("Recovery attempt failed:", recoveryError); + // Will retry on next error if retryable + } + } + + /** + * Execute recovery based on error type + */ + private async executeRecovery(error: CallError): Promise { + switch (error.type) { + case CallErrorType.CONNECTION_LOST: + case CallErrorType.WEBSOCKET_ERROR: + // Trigger reconnection + if ( + error.context?.reconnect && + typeof error.context.reconnect === "function" + ) { + await error.context.reconnect(); + } + break; + + case CallErrorType.TRANSPORT_ERROR: + // Recreate transport + if ( + error.context?.recreateTransport && + typeof error.context.recreateTransport === "function" + ) { + await error.context.recreateTransport(); + } + break; + + case CallErrorType.PRODUCER_ERROR: + // Recreate producer + if ( + error.context?.recreateProducer && + typeof error.context.recreateProducer === "function" + ) { + await error.context.recreateProducer(); + } + break; + + case CallErrorType.CONSUMER_ERROR: + // Recreate consumer + if ( + error.context?.recreateConsumer && + typeof error.context.recreateConsumer === "function" + ) { + await error.context.recreateConsumer(); + } + break; + + case CallErrorType.MEDIA_DEVICE_ERROR: + case CallErrorType.MEDIA_STREAM_ERROR: + // Reinitialize media + if ( + error.context?.reinitializeMedia && + typeof error.context.reinitializeMedia === "function" + ) { + await error.context.reinitializeMedia(); + } + break; + + default: + console.warn(`No recovery strategy for error type: ${error.type}`); + } + } + + /** + * Reset retry attempts for a specific key + */ + resetRetryAttempts(key?: string): void { + if (key) { + this.retryAttempts.delete(key); + } else { + this.retryAttempts.clear(); + } + } + + /** + * Configure retry settings + */ + configure(options: { maxRetryAttempts?: number; retryDelay?: number }): void { + if (options.maxRetryAttempts !== undefined) { + this.maxRetryAttempts = options.maxRetryAttempts; + } + if (options.retryDelay !== undefined) { + this.retryDelay = options.retryDelay; + } + } +} + +// Convenience functions +export const errorHandler = ErrorHandler.getInstance(); + +export function createCallError( + type: CallErrorType, + message: string, + options?: { + originalError?: Error; + context?: Record; + recoverable?: boolean; + retryable?: boolean; + } +): CallError { + const { recoverable, retryable } = errorHandler["getErrorProperties"](type); + + return new CallError({ + type, + message, + originalError: options?.originalError, + context: options?.context, + timestamp: new Date(), + recoverable: options?.recoverable ?? recoverable, + retryable: options?.retryable ?? retryable, + }); +} + +export function handleError( + error: Error | CallError, + context?: Record +): Promise { + return errorHandler.handleError(error, context); +} + +export function onError(listener: (error: CallError) => void): () => void { + return errorHandler.onError(listener); +} diff --git a/packages/call-sdk/tsconfig.json b/packages/call-sdk/tsconfig.json new file mode 100644 index 00000000..c4f6597e --- /dev/null +++ b/packages/call-sdk/tsconfig.json @@ -0,0 +1,14 @@ +{ + "extends": "@call/typescript-config/react-library", + "compilerOptions": { + "incremental": false, + "module": "ESNext", + "target": "ES2022", + "baseUrl": ".", + "paths": { + "@call/sdk/*": ["./src/*"] + } + }, + "include": ["."], + "exclude": ["node_modules", "dist"] +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 6a7bf24b..e0d5b9bc 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -13,13 +13,13 @@ importers: version: 1.4.0 '@geist-ui/icons': specifier: ^1.0.2 - version: 1.0.2(@geist-ui/core@2.3.8(react-dom@19.0.0(react@19.0.0))(react@19.0.0))(react@19.0.0) + version: 1.0.2(@geist-ui/core@2.3.8(react-dom@19.1.1(react@19.1.1))(react@19.1.1))(react@19.1.1) '@radix-ui/react-select': specifier: ^2.2.5 - version: 2.2.5(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0) + version: 2.2.5(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) '@radix-ui/react-tabs': specifier: ^1.1.12 - version: 1.1.12(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0) + version: 1.1.12(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) chalk: specifier: ^5.4.1 version: 5.4.1 @@ -34,7 +34,7 @@ importers: version: 3.12.5 react-icons: specifier: ^5.5.0 - version: 5.5.0(react@19.0.0) + version: 5.5.0(react@19.1.1) zod: specifier: ^3.25.67 version: 3.25.67 @@ -137,7 +137,7 @@ importers: version: 7.1.1 resend: specifier: ^4.6.0 - version: 4.6.0(react-dom@19.0.0(react@19.0.0))(react@19.0.0) + version: 4.6.0(react-dom@19.1.1(react@19.1.1))(react@19.1.1) ws: specifier: ^8.18.3 version: 8.18.3 @@ -325,6 +325,52 @@ importers: specifier: ^8.5.0 version: 8.5.0(jiti@2.4.2)(postcss@8.5.3)(tsx@4.20.3)(typescript@5.7.3)(yaml@2.8.0) + packages/call-sdk: + dependencies: + mediasoup-client: + specifier: ^3.14.0 + version: 3.14.0 + react: + specifier: ^19.1.1 + version: 19.1.1 + react-dom: + specifier: ^19.1.1 + version: 19.1.1(react@19.1.1) + devDependencies: + '@types/react': + specifier: ^19.1.9 + version: 19.1.9 + '@types/react-dom': + specifier: ^19.1.7 + version: 19.1.7(@types/react@19.1.9) + '@typescript-eslint/eslint-plugin': + specifier: ^8.38.0 + version: 8.38.0(@typescript-eslint/parser@8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2))(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2) + '@typescript-eslint/parser': + specifier: ^8.38.0 + version: 8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2) + eslint: + specifier: ^9.32.0 + version: 9.32.0(jiti@2.4.2) + eslint-config-prettier: + specifier: ^10.1.8 + version: 10.1.8(eslint@9.32.0(jiti@2.4.2)) + eslint-plugin-prettier: + specifier: ^5.5.3 + version: 5.5.3(eslint-config-prettier@10.1.8(eslint@9.32.0(jiti@2.4.2)))(eslint@9.32.0(jiti@2.4.2))(prettier@3.6.2) + jest: + specifier: ^30.0.5 + version: 30.0.5(@types/node@20.17.19)(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)) + prettier: + specifier: ^3.6.2 + version: 3.6.2 + tsup: + specifier: ^8.5.0 + version: 8.5.0(jiti@2.4.2)(postcss@8.5.3)(tsx@4.20.3)(typescript@5.9.2)(yaml@2.8.0) + typescript: + specifier: ^5.9.2 + version: 5.9.2 + packages/db: dependencies: dotenv: @@ -524,14 +570,160 @@ packages: resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==} engines: {node: '>=10'} + '@ampproject/remapping@2.3.0': + resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} + engines: {node: '>=6.0.0'} + '@babel/code-frame@7.27.1': resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==} engines: {node: '>=6.9.0'} + '@babel/compat-data@7.28.0': + resolution: {integrity: sha512-60X7qkglvrap8mn1lh2ebxXdZYtUcpd7gsmy9kLaBJ4i/WdY8PqTSdxyA8qraikqKQK5C1KRBKXqznrVapyNaw==} + engines: {node: '>=6.9.0'} + + '@babel/core@7.28.0': + resolution: {integrity: sha512-UlLAnTPrFdNGoFtbSXwcGFQBtQZJCNjaN6hQNP3UPvuNXT1i82N26KL3dZeIpNalWywr9IuQuncaAfUaS1g6sQ==} + engines: {node: '>=6.9.0'} + + '@babel/generator@7.28.0': + resolution: {integrity: sha512-lJjzvrbEeWrhB4P3QBsH7tey117PjLZnDbLiQEKjQ/fNJTjuq4HSqgFA+UNSwZT8D7dxxbnuSBMsa1lrWzKlQg==} + engines: {node: '>=6.9.0'} + + '@babel/helper-compilation-targets@7.27.2': + resolution: {integrity: sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==} + engines: {node: '>=6.9.0'} + + '@babel/helper-globals@7.28.0': + resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==} + engines: {node: '>=6.9.0'} + + '@babel/helper-module-imports@7.27.1': + resolution: {integrity: sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==} + engines: {node: '>=6.9.0'} + + '@babel/helper-module-transforms@7.27.3': + resolution: {integrity: sha512-dSOvYwvyLsWBeIRyOeHXp5vPj5l1I011r52FM1+r1jCERv+aFXYk4whgQccYEGYxK2H3ZAIA8nuPkQ0HaUo3qg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/helper-plugin-utils@7.27.1': + resolution: {integrity: sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==} + engines: {node: '>=6.9.0'} + + '@babel/helper-string-parser@7.27.1': + resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==} + engines: {node: '>=6.9.0'} + '@babel/helper-validator-identifier@7.27.1': resolution: {integrity: sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==} engines: {node: '>=6.9.0'} + '@babel/helper-validator-option@7.27.1': + resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==} + engines: {node: '>=6.9.0'} + + '@babel/helpers@7.28.2': + resolution: {integrity: sha512-/V9771t+EgXz62aCcyofnQhGM8DQACbRhvzKFsXKC9QM+5MadF8ZmIm0crDMaz3+o0h0zXfJnd4EhbYbxsrcFw==} + engines: {node: '>=6.9.0'} + + '@babel/parser@7.28.0': + resolution: {integrity: sha512-jVZGvOxOuNSsuQuLRTh13nU0AogFlw32w/MT+LV6D3sP5WdbW61E77RnkbaO2dUvmPAYrBDJXGn5gGS6tH4j8g==} + engines: {node: '>=6.0.0'} + hasBin: true + + '@babel/plugin-syntax-async-generators@7.8.4': + resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-bigint@7.8.3': + resolution: {integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-class-properties@7.12.13': + resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-class-static-block@7.14.5': + resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-import-attributes@7.27.1': + resolution: {integrity: sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-import-meta@7.10.4': + resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-json-strings@7.8.3': + resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-jsx@7.27.1': + resolution: {integrity: sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-logical-assignment-operators@7.10.4': + resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3': + resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-numeric-separator@7.10.4': + resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-object-rest-spread@7.8.3': + resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-optional-catch-binding@7.8.3': + resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-optional-chaining@7.8.3': + resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-private-property-in-object@7.14.5': + resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-top-level-await@7.14.5': + resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-syntax-typescript@7.27.1': + resolution: {integrity: sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + '@babel/runtime-corejs3@7.26.9': resolution: {integrity: sha512-5EVjbTegqN7RSJle6hMWYxO4voo4rI+9krITk+DWR+diJgGrjZjrIBnJhjrHYYQsFgI7j1w1QnrvV7YSKBfYGg==} engines: {node: '>=6.9.0'} @@ -540,6 +732,21 @@ packages: resolution: {integrity: sha512-vbavdySgbTTrmFE+EsiqUTzlOr5bzlnJtUv9PynGCAKvfQqjIXbvFdumPM/GxMDfyuGMJaJAU6TO4zc1Jf1i8Q==} engines: {node: '>=6.9.0'} + '@babel/template@7.27.2': + resolution: {integrity: sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==} + engines: {node: '>=6.9.0'} + + '@babel/traverse@7.28.0': + resolution: {integrity: sha512-mGe7UK5wWyh0bKRfupsUchrQGqvDbZDbKJw+kcRGSmdHVYrv+ltd0pnpDTVpiTqnaBru9iEvA8pz8W46v0Amwg==} + engines: {node: '>=6.9.0'} + + '@babel/types@7.28.2': + resolution: {integrity: sha512-ruv7Ae4J5dUYULmeXw1gmb7rYRz57OWCPM57pHojnLq/3Z1CK2lNSLTCVjxVk1F/TZHwOZZrOWi0ur95BbLxNQ==} + engines: {node: '>=6.9.0'} + + '@bcoe/v8-coverage@0.2.3': + resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==} + '@better-auth/utils@0.2.5': resolution: {integrity: sha512-uI2+/8h/zVsH8RrYdG8eUErbuGBk16rZKQfz8CjxQOyCE6v7BqFYEbFwvOkvl1KbUdxhqOnXp78+uE5h8qVEgQ==} @@ -628,9 +835,18 @@ packages: '@drizzle-team/brocli@0.10.2': resolution: {integrity: sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w==} + '@emnapi/core@1.4.5': + resolution: {integrity: sha512-XsLw1dEOpkSX/WucdqUhPWP7hDxSvZiY+fsUC14h+FtQ2Ifni4znbBt8punRX+Uj2JG/uDb8nEHVKvrVlvdZ5Q==} + '@emnapi/runtime@1.3.1': resolution: {integrity: sha512-kEBmG8KyqtxJZv+ygbEim+KCGtIq1fC22Ms3S4ziXmYKm8uyoLX0MHONVKwp+9opg390VaKRNt4a7A9NwmpNhw==} + '@emnapi/runtime@1.4.5': + resolution: {integrity: sha512-++LApOtY0pEEz1zrd9vy1/zXVaVJJ/EbAF3u0fXIzPJEDtnITsBGbbK0EkM72amhl/R5b+5xx0Y/QhcVOpuulg==} + + '@emnapi/wasi-threads@1.0.4': + resolution: {integrity: sha512-PJR+bOmMOPH8AtcTGAyYNiuJ3/Fcoj2XN/gBEWzDIKh254XO+mM9XoXHk5GNEhodxeMznbg7BlRojVbKN+gC6g==} + '@esbuild-kit/core-utils@3.3.2': resolution: {integrity: sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ==} deprecated: 'Merged into tsx: https://tsx.is' @@ -927,6 +1143,12 @@ packages: peerDependencies: eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + '@eslint-community/eslint-utils@4.7.0': + resolution: {integrity: sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + '@eslint-community/regexpp@4.12.1': resolution: {integrity: sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==} engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} @@ -935,6 +1157,14 @@ packages: resolution: {integrity: sha512-GNKqxfHG2ySmJOBSHg7LxeUx4xpuCoFjacmlCoYWEbaPXLwvfIjixRI12xCQZeULksQb23uiA8F40w5TojpV7w==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/config-array@0.21.0': + resolution: {integrity: sha512-ENIdc4iLu0d93HeYirvKmrzshzofPw6VkZRKQGe9Nv46ZnWUzcF1xV01dcvEg/1wXUR61OmmlSfyeyO7EvjLxQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/config-helpers@0.3.0': + resolution: {integrity: sha512-ViuymvFmcJi04qdZeDc2whTHryouGcDlaxPqarTD0ZE10ISpxGUVZGZDx4w01upyIynL3iu6IXH2bS1NhclQMw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/core@0.11.0': resolution: {integrity: sha512-DWUB2pksgNEb6Bz2fggIy1wh6fGgZP4Xyy/Mt0QZPiloKKXerbqq9D3SBQTlCRYOrcRPu4vuz+CGjwdfqxnoWA==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -943,10 +1173,18 @@ packages: resolution: {integrity: sha512-cmrR6pytBuSMTaBweKoGMwu3EiHiEC+DoyupPmlZ0HxBJBtIxwe+j/E4XPIKNx+Q74c8lXKPwYawBf5glsTkHg==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/core@0.15.1': + resolution: {integrity: sha512-bkOp+iumZCCbt1K1CmWf0R9pM5yKpDv+ZXtvSyQpudrI9kuFLp+bM2WOPXImuD/ceQuaa8f5pj93Y7zyECIGNA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/eslintrc@3.2.0': resolution: {integrity: sha512-grOjVNN8P3hjJn/eIETF1wwd12DdnwFDoyceUJLYYdkpbwq3nLi+4fqrTAONx7XDALqlL220wC/RHSC/QTI/0w==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/eslintrc@3.3.1': + resolution: {integrity: sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/js@9.20.0': resolution: {integrity: sha512-iZA07H9io9Wn836aVTytRaNqh00Sad+EamwOVJT12GTLw1VGMFV/4JaME+JjLtr9fiGaoWgYnS54wrfWsSs4oQ==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -955,6 +1193,10 @@ packages: resolution: {integrity: sha512-3PIF4cBw/y+1u2EazflInpV+lYsSG0aByVIQzAgb1m1MhHFSbqTyNqtBKHgWf/9Ykud+DhILS9EGkmekVhbKoQ==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/js@9.32.0': + resolution: {integrity: sha512-BBpRFZK3eX6uMLKz8WxFOBIFFcGFJ/g8XuwjTHCqHROSIsopI+ddn/d5Cfh36+7+e5edVS8dbSHnBNhrLEX0zg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/object-schema@2.1.6': resolution: {integrity: sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -963,6 +1205,10 @@ packages: resolution: {integrity: sha512-JubJ5B2pJ4k4yGxaNLdbjrnk9d/iDz6/q8wOilpIowd6PJPgaxCuHBnBszq7Ce2TyMrywm5r4PnKm6V3iiZF+g==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/plugin-kit@0.3.4': + resolution: {integrity: sha512-Ul5l+lHEcw3L5+k8POx6r74mxEYKG5kOb6Xpy2gCRW6zweT6TEhAf8vhxGgjhqrd/VO/Dirhsb+1hNpD1ue9hw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@floating-ui/core@1.7.2': resolution: {integrity: sha512-wNB5ooIKHQc+Kui96jE/n69rHFWAVoxn5CAzL1Xdd8FG03cgY3MLO+GF9U3W737fYDSgPWA6MReKhBQBop6Pcw==} @@ -1154,6 +1400,99 @@ packages: resolution: {integrity: sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==} engines: {node: '>=18.0.0'} +<<<<<<< HEAD +======= + '@istanbuljs/load-nyc-config@1.1.0': + resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==} + engines: {node: '>=8'} + + '@istanbuljs/schema@0.1.3': + resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} + engines: {node: '>=8'} + + '@jest/console@30.0.5': + resolution: {integrity: sha512-xY6b0XiL0Nav3ReresUarwl2oIz1gTnxGbGpho9/rbUWsLH0f1OD/VT84xs8c7VmH7MChnLb0pag6PhZhAdDiA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/core@30.0.5': + resolution: {integrity: sha512-fKD0OulvRsXF1hmaFgHhVJzczWzA1RXMMo9LTPuFXo9q/alDbME3JIyWYqovWsUBWSoBcsHaGPSLF9rz4l9Qeg==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + + '@jest/diff-sequences@30.0.1': + resolution: {integrity: sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/environment@30.0.5': + resolution: {integrity: sha512-aRX7WoaWx1oaOkDQvCWImVQ8XNtdv5sEWgk4gxR6NXb7WBUnL5sRak4WRzIQRZ1VTWPvV4VI4mgGjNL9TeKMYA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/expect-utils@30.0.5': + resolution: {integrity: sha512-F3lmTT7CXWYywoVUGTCmom0vXq3HTTkaZyTAzIy+bXSBizB7o5qzlC9VCtq0arOa8GqmNsbg/cE9C6HLn7Szew==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/expect@30.0.5': + resolution: {integrity: sha512-6udac8KKrtTtC+AXZ2iUN/R7dp7Ydry+Fo6FPFnDG54wjVMnb6vW/XNlf7Xj8UDjAE3aAVAsR4KFyKk3TCXmTA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/fake-timers@30.0.5': + resolution: {integrity: sha512-ZO5DHfNV+kgEAeP3gK3XlpJLL4U3Sz6ebl/n68Uwt64qFFs5bv4bfEEjyRGK5uM0C90ewooNgFuKMdkbEoMEXw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/get-type@30.0.1': + resolution: {integrity: sha512-AyYdemXCptSRFirI5EPazNxyPwAL0jXt3zceFjaj8NFiKP9pOi0bfXonf6qkf82z2t3QWPeLCWWw4stPBzctLw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/globals@30.0.5': + resolution: {integrity: sha512-7oEJT19WW4oe6HR7oLRvHxwlJk2gev0U9px3ufs8sX9PoD1Eza68KF0/tlN7X0dq/WVsBScXQGgCldA1V9Y/jA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/pattern@30.0.1': + resolution: {integrity: sha512-gWp7NfQW27LaBQz3TITS8L7ZCQ0TLvtmI//4OwlQRx4rnWxcPNIYjxZpDcN4+UlGxgm3jS5QPz8IPTCkb59wZA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/reporters@30.0.5': + resolution: {integrity: sha512-mafft7VBX4jzED1FwGC1o/9QUM2xebzavImZMeqnsklgcyxBto8mV4HzNSzUrryJ+8R9MFOM3HgYuDradWR+4g==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + + '@jest/schemas@30.0.5': + resolution: {integrity: sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/snapshot-utils@30.0.5': + resolution: {integrity: sha512-XcCQ5qWHLvi29UUrowgDFvV4t7ETxX91CbDczMnoqXPOIcZOxyNdSjm6kV5XMc8+HkxfRegU/MUmnTbJRzGrUQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/source-map@30.0.1': + resolution: {integrity: sha512-MIRWMUUR3sdbP36oyNyhbThLHyJ2eEDClPCiHVbrYAe5g3CHRArIVpBw7cdSB5fr+ofSfIb2Tnsw8iEHL0PYQg==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/test-result@30.0.5': + resolution: {integrity: sha512-wPyztnK0gbDMQAJZ43tdMro+qblDHH1Ru/ylzUo21TBKqt88ZqnKKK2m30LKmLLoKtR2lxdpCC/P3g1vfKcawQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/test-sequencer@30.0.5': + resolution: {integrity: sha512-Aea/G1egWoIIozmDD7PBXUOxkekXl7ueGzrsGGi1SbeKgQqCYCIf+wfbflEbf2LiPxL8j2JZGLyrzZagjvW4YQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/transform@30.0.5': + resolution: {integrity: sha512-Vk8amLQCmuZyy6GbBht1Jfo9RSdBtg7Lks+B0PecnjI8J+PCLQPGh7uI8Q/2wwpW2gLdiAfiHNsmekKlywULqg==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + '@jest/types@30.0.5': + resolution: {integrity: sha512-aREYa3aku9SSnea4aX6bhKn4bgv3AXkgijoQgbYV3yvbiGt6z+MQ85+6mIhx9DsKW2BuB/cLR/A+tcMThx+KLQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) '@jridgewell/gen-mapping@0.3.12': resolution: {integrity: sha512-OuLGC46TjB5BbN1dH8JULVVZY4WTdkF7tV9Ys6wLL1rubZnCMstOhNHueU5bLCrnRuDhKPDM4g6sw4Bel5Gzqg==} @@ -1203,6 +1542,9 @@ packages: '@livekit/protocol@1.39.2': resolution: {integrity: sha512-kYbIO/JlC6cylSxd4WJrBps9+zoZ9gifL7t3iW9whT8rbo5jHx03I4dwBLhzOonVyX+memSEO90m/ymNoT+aAw==} + '@napi-rs/wasm-runtime@0.2.12': + resolution: {integrity: sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==} + '@next/env@15.2.3': resolution: {integrity: sha512-a26KnbW9DFEUsSxAxKBORR/uD9THoYoKbkpFywMN/AFvboTt94b8+g/07T8J6ACsdLag8/PDU60ov4rPxRAixw==} @@ -1304,6 +1646,13 @@ packages: resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==} engines: {node: '>=14'} +<<<<<<< HEAD +======= + '@pkgr/core@0.2.9': + resolution: {integrity: sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==} + engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) '@radix-ui/number@1.1.1': resolution: {integrity: sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==} @@ -1772,6 +2121,7 @@ packages: react: ^18.0 || ^19.0 || ^19.0.0-rc react-dom: ^18.0 || ^19.0 || ^19.0.0-rc +<<<<<<< HEAD '@rollup/rollup-android-arm-eabi@4.46.1': resolution: {integrity: sha512-oENme6QxtLCqjChRUUo3S6X8hjCXnWmJWnedD7VbGML5GUtaOtAyx+fEEXnBXVf0CBZApMQU0Idwi0FmyxzQhw==} cpu: [arm] @@ -1869,6 +2219,105 @@ packages: '@rollup/rollup-win32-x64-msvc@4.46.1': resolution: {integrity: sha512-7GVB4luhFmGUNXXJhH2jJwZCFB3pIOixv2E3s17GQHBFUOQaISlt7aGcQgqvCaDSxTZJUzlK/QJ1FN8S94MrzQ==} +======= + '@rollup/rollup-android-arm-eabi@4.46.2': + resolution: {integrity: sha512-Zj3Hl6sN34xJtMv7Anwb5Gu01yujyE/cLBDB2gnHTAHaWS1Z38L7kuSG+oAh0giZMqG060f/YBStXtMH6FvPMA==} + cpu: [arm] + os: [android] + + '@rollup/rollup-android-arm64@4.46.2': + resolution: {integrity: sha512-nTeCWY83kN64oQ5MGz3CgtPx8NSOhC5lWtsjTs+8JAJNLcP3QbLCtDDgUKQc/Ro/frpMq4SHUaHN6AMltcEoLQ==} + cpu: [arm64] + os: [android] + + '@rollup/rollup-darwin-arm64@4.46.2': + resolution: {integrity: sha512-HV7bW2Fb/F5KPdM/9bApunQh68YVDU8sO8BvcW9OngQVN3HHHkw99wFupuUJfGR9pYLLAjcAOA6iO+evsbBaPQ==} + cpu: [arm64] + os: [darwin] + + '@rollup/rollup-darwin-x64@4.46.2': + resolution: {integrity: sha512-SSj8TlYV5nJixSsm/y3QXfhspSiLYP11zpfwp6G/YDXctf3Xkdnk4woJIF5VQe0of2OjzTt8EsxnJDCdHd2xMA==} + cpu: [x64] + os: [darwin] + + '@rollup/rollup-freebsd-arm64@4.46.2': + resolution: {integrity: sha512-ZyrsG4TIT9xnOlLsSSi9w/X29tCbK1yegE49RYm3tu3wF1L/B6LVMqnEWyDB26d9Ecx9zrmXCiPmIabVuLmNSg==} + cpu: [arm64] + os: [freebsd] + + '@rollup/rollup-freebsd-x64@4.46.2': + resolution: {integrity: sha512-pCgHFoOECwVCJ5GFq8+gR8SBKnMO+xe5UEqbemxBpCKYQddRQMgomv1104RnLSg7nNvgKy05sLsY51+OVRyiVw==} + cpu: [x64] + os: [freebsd] + + '@rollup/rollup-linux-arm-gnueabihf@4.46.2': + resolution: {integrity: sha512-EtP8aquZ0xQg0ETFcxUbU71MZlHaw9MChwrQzatiE8U/bvi5uv/oChExXC4mWhjiqK7azGJBqU0tt5H123SzVA==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm-musleabihf@4.46.2': + resolution: {integrity: sha512-qO7F7U3u1nfxYRPM8HqFtLd+raev2K137dsV08q/LRKRLEc7RsiDWihUnrINdsWQxPR9jqZ8DIIZ1zJJAm5PjQ==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm64-gnu@4.46.2': + resolution: {integrity: sha512-3dRaqLfcOXYsfvw5xMrxAk9Lb1f395gkoBYzSFcc/scgRFptRXL9DOaDpMiehf9CO8ZDRJW2z45b6fpU5nwjng==} + cpu: [arm64] + os: [linux] + + '@rollup/rollup-linux-arm64-musl@4.46.2': + resolution: {integrity: sha512-fhHFTutA7SM+IrR6lIfiHskxmpmPTJUXpWIsBXpeEwNgZzZZSg/q4i6FU4J8qOGyJ0TR+wXBwx/L7Ho9z0+uDg==} + cpu: [arm64] + os: [linux] + + '@rollup/rollup-linux-loongarch64-gnu@4.46.2': + resolution: {integrity: sha512-i7wfGFXu8x4+FRqPymzjD+Hyav8l95UIZ773j7J7zRYc3Xsxy2wIn4x+llpunexXe6laaO72iEjeeGyUFmjKeA==} + cpu: [loong64] + os: [linux] + + '@rollup/rollup-linux-ppc64-gnu@4.46.2': + resolution: {integrity: sha512-B/l0dFcHVUnqcGZWKcWBSV2PF01YUt0Rvlurci5P+neqY/yMKchGU8ullZvIv5e8Y1C6wOn+U03mrDylP5q9Yw==} + cpu: [ppc64] + os: [linux] + + '@rollup/rollup-linux-riscv64-gnu@4.46.2': + resolution: {integrity: sha512-32k4ENb5ygtkMwPMucAb8MtV8olkPT03oiTxJbgkJa7lJ7dZMr0GCFJlyvy+K8iq7F/iuOr41ZdUHaOiqyR3iQ==} + cpu: [riscv64] + os: [linux] + + '@rollup/rollup-linux-riscv64-musl@4.46.2': + resolution: {integrity: sha512-t5B2loThlFEauloaQkZg9gxV05BYeITLvLkWOkRXogP4qHXLkWSbSHKM9S6H1schf/0YGP/qNKtiISlxvfmmZw==} + cpu: [riscv64] + os: [linux] + + '@rollup/rollup-linux-s390x-gnu@4.46.2': + resolution: {integrity: sha512-YKjekwTEKgbB7n17gmODSmJVUIvj8CX7q5442/CK80L8nqOUbMtf8b01QkG3jOqyr1rotrAnW6B/qiHwfcuWQA==} + cpu: [s390x] + os: [linux] + + '@rollup/rollup-linux-x64-gnu@4.46.2': + resolution: {integrity: sha512-Jj5a9RUoe5ra+MEyERkDKLwTXVu6s3aACP51nkfnK9wJTraCC8IMe3snOfALkrjTYd2G1ViE1hICj0fZ7ALBPA==} + cpu: [x64] + os: [linux] + + '@rollup/rollup-linux-x64-musl@4.46.2': + resolution: {integrity: sha512-7kX69DIrBeD7yNp4A5b81izs8BqoZkCIaxQaOpumcJ1S/kmqNFjPhDu1LHeVXv0SexfHQv5cqHsxLOjETuqDuA==} + cpu: [x64] + os: [linux] + + '@rollup/rollup-win32-arm64-msvc@4.46.2': + resolution: {integrity: sha512-wiJWMIpeaak/jsbaq2HMh/rzZxHVW1rU6coyeNNpMwk5isiPjSTx0a4YLSlYDwBH/WBvLz+EtsNqQScZTLJy3g==} + cpu: [arm64] + os: [win32] + + '@rollup/rollup-win32-ia32-msvc@4.46.2': + resolution: {integrity: sha512-gBgaUDESVzMgWZhcyjfs9QFK16D8K6QZpwAaVNJxYDLHWayOta4ZMjGm/vsAEy3hvlS2GosVFlBlP9/Wb85DqQ==} + cpu: [ia32] + os: [win32] + + '@rollup/rollup-win32-x64-msvc@4.46.2': + resolution: {integrity: sha512-CvUo2ixeIQGtF6WvuB87XWqPQkoFAFqW+HUo/WzHwuHDvIwZCtjdWXoYCcr06iKGydiqTclC4jU/TNObC/xKZg==} +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) cpu: [x64] os: [win32] @@ -1886,6 +2335,15 @@ packages: resolution: {integrity: sha512-1hsLpRHfSuMB9ee2aAdh0Htza/X3f4djhYISrggqGe3xopNjOcePiSDkDDoPzDYaaMCrbqGP1H2TYU7bgL9PmA==} engines: {node: '>=20.0.0'} + '@sinclair/typebox@0.34.38': + resolution: {integrity: sha512-HpkxMmc2XmZKhvaKIZZThlHmx1L0I/V1hWK1NubtlFnr6ZqdiOpV72TKudZUNQjZNsyDBay72qFEhEvb+bcwcA==} + + '@sinonjs/commons@3.0.1': + resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==} + + '@sinonjs/fake-timers@13.0.5': + resolution: {integrity: sha512-36/hTbH2uaWuGVERyC6da9YwGWnzUZXuPro/F2LfsdOsLnCojz/iSH8MxUt/FD2S5XBSVPhmArFUXcpCQ2Hkiw==} + '@socket.io/component-emitter@3.1.2': resolution: {integrity: sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==} @@ -2052,6 +2510,21 @@ packages: resolution: {integrity: sha512-HdXoW7LxCL+cvoEx8SBdg98o7DupN48hEvoEeUJ08R0ud8cLHCO8/2heyG/X/Y60pY9uxhpwjsmn9l5Dx75uMA==} hasBin: true + '@tybys/wasm-util@0.10.0': + resolution: {integrity: sha512-VyyPYFlOMNylG45GoAe0xDoLwWuowvf92F9kySqzYh8vmYm7D2u4iUJKa1tOUpS70Ku13ASrOkS4ScXFsTaCNQ==} + + '@types/babel__core@7.20.5': + resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==} + + '@types/babel__generator@7.27.0': + resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==} + + '@types/babel__template@7.4.4': + resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==} + + '@types/babel__traverse@7.28.0': + resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==} + '@types/canvas-confetti@1.9.0': resolution: {integrity: sha512-aBGj/dULrimR1XDZLtG9JwxX1b4HPRF6CX9Yfwh3NvstZEm1ZL7RBnel4keCPSqs1ANRu1u2Aoz9R+VmtjYuTg==} @@ -2082,6 +2555,15 @@ packages: '@types/inquirer@6.5.0': resolution: {integrity: sha512-rjaYQ9b9y/VFGOpqBEXRavc3jh0a+e6evAbI31tMda8VlPaSy0AZJfXsvmIe3wklc7W6C3zCSfleuMXR7NOyXw==} + '@types/istanbul-lib-coverage@2.0.6': + resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} + + '@types/istanbul-lib-report@3.0.3': + resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==} + + '@types/istanbul-reports@3.0.4': + resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==} + '@types/json-schema@7.0.15': resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} @@ -2108,9 +2590,20 @@ packages: peerDependencies: '@types/react': ^19.0.0 + '@types/react-dom@19.1.7': + resolution: {integrity: sha512-i5ZzwYpqjmrKenzkoLM2Ibzt6mAsM7pxB6BCIouEVVmgiqaMj1TjaK7hnA36hbW5aZv20kx7Lw6hWzPWg0Rurw==} + peerDependencies: + '@types/react': ^19.0.0 + '@types/react@19.0.10': resolution: {integrity: sha512-JuRQ9KXLEjaUNjTWpzuR231Z2WpIwczOkBEIvbHNCzQefFIT0L8IqE6NV6ULLyC1SI/i234JnDoMkfg+RjQj2g==} + '@types/react@19.1.9': + resolution: {integrity: sha512-WmdoynAX8Stew/36uTSVMcLJJ1KRh6L3IZRx1PZ7qJtBqT3dYTgyDTx8H1qoRghErydW7xw9mSJ3wS//tCRpFA==} + + '@types/stack-utils@2.0.3': + resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==} + '@types/through@0.0.33': resolution: {integrity: sha512-HsJ+z3QuETzP3cswwtzt2vEIiHBk/dCcHGhbmG5X3ecnwFD/lPrMpliGXxSCg03L9AhrdwA4Oz/qfspkDW+xGQ==} @@ -2120,6 +2613,12 @@ packages: '@types/ws@8.18.1': resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==} + '@types/yargs-parser@21.0.3': + resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==} + + '@types/yargs@17.0.33': + resolution: {integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==} + '@typescript-eslint/eslint-plugin@8.24.1': resolution: {integrity: sha512-ll1StnKtBigWIGqvYDVuDmXJHVH4zLVot1yQ4fJtLpL7qacwkxJc1T0bptqw+miBQ/QfUbhl1TcQ4accW5KUyA==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -2128,6 +2627,14 @@ packages: eslint: ^8.57.0 || ^9.0.0 typescript: '>=4.8.4 <5.8.0' + '@typescript-eslint/eslint-plugin@8.38.0': + resolution: {integrity: sha512-CPoznzpuAnIOl4nhj4tRr4gIPj5AfKgkiJmGQDaq+fQnRJTYlcBjbX3wbciGmpoPf8DREufuPRe1tNMZnGdanA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + '@typescript-eslint/parser': ^8.38.0 + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <5.9.0' + '@typescript-eslint/parser@8.24.1': resolution: {integrity: sha512-Tqoa05bu+t5s8CTZFaGpCH2ub3QeT9YDkXbPd3uQ4SfsLoh1/vv2GEYAioPoxCWJJNsenXlC88tRjwoHNts1oQ==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -2135,10 +2642,33 @@ packages: eslint: ^8.57.0 || ^9.0.0 typescript: '>=4.8.4 <5.8.0' + '@typescript-eslint/parser@8.38.0': + resolution: {integrity: sha512-Zhy8HCvBUEfBECzIl1PKqF4p11+d0aUJS1GeUiuqK9WmOug8YCmC4h4bjyBvMyAMI9sbRczmrYL5lKg/YMbrcQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <5.9.0' + + '@typescript-eslint/project-service@8.38.0': + resolution: {integrity: sha512-dbK7Jvqcb8c9QfH01YB6pORpqX1mn5gDZc9n63Ak/+jD67oWXn3Gs0M6vddAN+eDXBCS5EmNWzbSxsn9SzFWWg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <5.9.0' + '@typescript-eslint/scope-manager@8.24.1': resolution: {integrity: sha512-OdQr6BNBzwRjNEXMQyaGyZzgg7wzjYKfX2ZBV3E04hUCBDv3GQCHiz9RpqdUIiVrMgJGkXm3tcEh4vFSHreS2Q==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@typescript-eslint/scope-manager@8.38.0': + resolution: {integrity: sha512-WJw3AVlFFcdT9Ri1xs/lg8LwDqgekWXWhH3iAF+1ZM+QPd7oxQ6jvtW/JPwzAScxitILUIFs0/AnQ/UWHzbATQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@typescript-eslint/tsconfig-utils@8.38.0': + resolution: {integrity: sha512-Lum9RtSE3EroKk/bYns+sPOodqb2Fv50XOl/gMviMKNvanETUuUcC9ObRbzrJ4VSd2JalPqgSAavwrPiPvnAiQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <5.9.0' + '@typescript-eslint/type-utils@8.24.1': resolution: {integrity: sha512-/Do9fmNgCsQ+K4rCz0STI7lYB4phTtEXqqCAs3gZW0pnK7lWNkvWd5iW545GSmApm4AzmQXmSqXPO565B4WVrw==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -2146,16 +2676,33 @@ packages: eslint: ^8.57.0 || ^9.0.0 typescript: '>=4.8.4 <5.8.0' + '@typescript-eslint/type-utils@8.38.0': + resolution: {integrity: sha512-c7jAvGEZVf0ao2z+nnz8BUaHZD09Agbh+DY7qvBQqLiz8uJzRgVPj5YvOh8I8uEiH8oIUGIfHzMwUcGVco/SJg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <5.9.0' + '@typescript-eslint/types@8.24.1': resolution: {integrity: sha512-9kqJ+2DkUXiuhoiYIUvIYjGcwle8pcPpdlfkemGvTObzgmYfJ5d0Qm6jwb4NBXP9W1I5tss0VIAnWFumz3mC5A==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@typescript-eslint/types@8.38.0': + resolution: {integrity: sha512-wzkUfX3plUqij4YwWaJyqhiPE5UCRVlFpKn1oCRn2O1bJ592XxWJj8ROQ3JD5MYXLORW84063z3tZTb/cs4Tyw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@typescript-eslint/typescript-estree@8.24.1': resolution: {integrity: sha512-UPyy4MJ/0RE648DSKQe9g0VDSehPINiejjA6ElqnFaFIhI6ZEiZAkUI0D5MCk0bQcTf/LVqZStvQ6K4lPn/BRg==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} peerDependencies: typescript: '>=4.8.4 <5.8.0' + '@typescript-eslint/typescript-estree@8.38.0': + resolution: {integrity: sha512-fooELKcAKzxux6fA6pxOflpNS0jc+nOQEEOipXFNjSlBS6fqrJOVY/whSn70SScHrcJ2LDsxWrneFoWYSVfqhQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <5.9.0' + '@typescript-eslint/utils@8.24.1': resolution: {integrity: sha512-OOcg3PMMQx9EXspId5iktsI3eMaXVwlhC8BvNnX6B5w9a4dVgpkQZuU8Hy67TolKcl+iFWq0XX+jbDGN4xWxjQ==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -2163,21 +2710,130 @@ packages: eslint: ^8.57.0 || ^9.0.0 typescript: '>=4.8.4 <5.8.0' + '@typescript-eslint/utils@8.38.0': + resolution: {integrity: sha512-hHcMA86Hgt+ijJlrD8fX0j1j8w4C92zue/8LOPAFioIno+W0+L7KqE8QZKCcPGc/92Vs9x36w/4MPTJhqXdyvg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <5.9.0' + '@typescript-eslint/visitor-keys@8.24.1': resolution: {integrity: sha512-EwVHlp5l+2vp8CoqJm9KikPZgi3gbdZAtabKT9KPShGeOcJhsv4Zdo3oc8T8I0uKEmYoU4ItyxbptjF08enaxg==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} - JSONStream@1.3.5: - resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==} - hasBin: true + '@typescript-eslint/visitor-keys@8.38.0': + resolution: {integrity: sha512-pWrTcoFNWuwHlA9CvlfSsGWs14JxfN1TH25zM5L7o0pRLhsoZkDnTsXfQRJBEWJoV5DL0jf+Z+sxiud+K0mq1g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} - acorn-jsx@5.3.2: - resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} - peerDependencies: - acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + '@ungap/structured-clone@1.3.0': + resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==} - acorn-walk@8.3.4: - resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==} + '@unrs/resolver-binding-android-arm-eabi@1.11.1': + resolution: {integrity: sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==} + cpu: [arm] + os: [android] + + '@unrs/resolver-binding-android-arm64@1.11.1': + resolution: {integrity: sha512-lCxkVtb4wp1v+EoN+HjIG9cIIzPkX5OtM03pQYkG+U5O/wL53LC4QbIeazgiKqluGeVEeBlZahHalCaBvU1a2g==} + cpu: [arm64] + os: [android] + + '@unrs/resolver-binding-darwin-arm64@1.11.1': + resolution: {integrity: sha512-gPVA1UjRu1Y/IsB/dQEsp2V1pm44Of6+LWvbLc9SDk1c2KhhDRDBUkQCYVWe6f26uJb3fOK8saWMgtX8IrMk3g==} + cpu: [arm64] + os: [darwin] + + '@unrs/resolver-binding-darwin-x64@1.11.1': + resolution: {integrity: sha512-cFzP7rWKd3lZaCsDze07QX1SC24lO8mPty9vdP+YVa3MGdVgPmFc59317b2ioXtgCMKGiCLxJ4HQs62oz6GfRQ==} + cpu: [x64] + os: [darwin] + + '@unrs/resolver-binding-freebsd-x64@1.11.1': + resolution: {integrity: sha512-fqtGgak3zX4DCB6PFpsH5+Kmt/8CIi4Bry4rb1ho6Av2QHTREM+47y282Uqiu3ZRF5IQioJQ5qWRV6jduA+iGw==} + cpu: [x64] + os: [freebsd] + + '@unrs/resolver-binding-linux-arm-gnueabihf@1.11.1': + resolution: {integrity: sha512-u92mvlcYtp9MRKmP+ZvMmtPN34+/3lMHlyMj7wXJDeXxuM0Vgzz0+PPJNsro1m3IZPYChIkn944wW8TYgGKFHw==} + cpu: [arm] + os: [linux] + + '@unrs/resolver-binding-linux-arm-musleabihf@1.11.1': + resolution: {integrity: sha512-cINaoY2z7LVCrfHkIcmvj7osTOtm6VVT16b5oQdS4beibX2SYBwgYLmqhBjA1t51CarSaBuX5YNsWLjsqfW5Cw==} + cpu: [arm] + os: [linux] + + '@unrs/resolver-binding-linux-arm64-gnu@1.11.1': + resolution: {integrity: sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==} + cpu: [arm64] + os: [linux] + + '@unrs/resolver-binding-linux-arm64-musl@1.11.1': + resolution: {integrity: sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==} + cpu: [arm64] + os: [linux] + + '@unrs/resolver-binding-linux-ppc64-gnu@1.11.1': + resolution: {integrity: sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==} + cpu: [ppc64] + os: [linux] + + '@unrs/resolver-binding-linux-riscv64-gnu@1.11.1': + resolution: {integrity: sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==} + cpu: [riscv64] + os: [linux] + + '@unrs/resolver-binding-linux-riscv64-musl@1.11.1': + resolution: {integrity: sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==} + cpu: [riscv64] + os: [linux] + + '@unrs/resolver-binding-linux-s390x-gnu@1.11.1': + resolution: {integrity: sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==} + cpu: [s390x] + os: [linux] + + '@unrs/resolver-binding-linux-x64-gnu@1.11.1': + resolution: {integrity: sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==} + cpu: [x64] + os: [linux] + + '@unrs/resolver-binding-linux-x64-musl@1.11.1': + resolution: {integrity: sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==} + cpu: [x64] + os: [linux] + + '@unrs/resolver-binding-wasm32-wasi@1.11.1': + resolution: {integrity: sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==} + engines: {node: '>=14.0.0'} + cpu: [wasm32] + + '@unrs/resolver-binding-win32-arm64-msvc@1.11.1': + resolution: {integrity: sha512-nRcz5Il4ln0kMhfL8S3hLkxI85BXs3o8EYoattsJNdsX4YUU89iOkVn7g0VHSRxFuVMdM4Q1jEpIId1Ihim/Uw==} + cpu: [arm64] + os: [win32] + + '@unrs/resolver-binding-win32-ia32-msvc@1.11.1': + resolution: {integrity: sha512-DCEI6t5i1NmAZp6pFonpD5m7i6aFrpofcp4LA2i8IIq60Jyo28hamKBxNrZcyOwVOZkgsRp9O2sXWBWP8MnvIQ==} + cpu: [ia32] + os: [win32] + + '@unrs/resolver-binding-win32-x64-msvc@1.11.1': + resolution: {integrity: sha512-lrW200hZdbfRtztbygyaq/6jP6AKE8qQN2KvPcJ+x7wiD038YtnYtZ82IMNJ69GJibV7bwL3y9FgK+5w/pYt6g==} + cpu: [x64] + os: [win32] + + JSONStream@1.3.5: + resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==} + hasBin: true + + acorn-jsx@5.3.2: + resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + + acorn-walk@8.3.4: + resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==} engines: {node: '>=0.4.0'} acorn@8.14.0: @@ -2185,6 +2841,11 @@ packages: engines: {node: '>=0.4.0'} hasBin: true + acorn@8.15.0: + resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==} + engines: {node: '>=0.4.0'} + hasBin: true + agent-base@7.1.3: resolution: {integrity: sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==} engines: {node: '>= 14'} @@ -2223,6 +2884,10 @@ packages: resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} engines: {node: '>=8'} + ansi-styles@5.2.0: + resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} + engines: {node: '>=10'} + ansi-styles@6.2.1: resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==} engines: {node: '>=12'} @@ -2237,6 +2902,9 @@ packages: arg@4.1.3: resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} + argparse@1.0.10: + resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} + argparse@2.0.1: resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} @@ -2305,6 +2973,31 @@ packages: axios@1.10.0: resolution: {integrity: sha512-/1xYAC4MP/HEG+3duIhFr4ZQXR4sQXOIe+o6sdqzeykGLx6Upp/1p8MHqhINOvGeP7xyNHe7tsiJByc4SSVUxw==} + babel-jest@30.0.5: + resolution: {integrity: sha512-mRijnKimhGDMsizTvBTWotwNpzrkHr+VvZUQBof2AufXKB8NXrL1W69TG20EvOz7aevx6FTJIaBuBkYxS8zolg==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + peerDependencies: + '@babel/core': ^7.11.0 + + babel-plugin-istanbul@7.0.0: + resolution: {integrity: sha512-C5OzENSx/A+gt7t4VH1I2XsflxyPUmXRFPKBxt33xncdOmq7oROVM3bZv9Ysjjkv8OJYDMa+tKuKMvqU/H3xdw==} + engines: {node: '>=12'} + + babel-plugin-jest-hoist@30.0.1: + resolution: {integrity: sha512-zTPME3pI50NsFW8ZBaVIOeAxzEY7XHlmWeXXu9srI+9kNfzCUTy8MFan46xOGZY8NZThMqq+e3qZUKsvXbasnQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + babel-preset-current-node-syntax@1.2.0: + resolution: {integrity: sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==} + peerDependencies: + '@babel/core': ^7.0.0 || ^8.0.0-0 + + babel-preset-jest@30.0.1: + resolution: {integrity: sha512-+YHejD5iTWI46cZmcc/YtX4gaKBtdqCHCVfuVinizVpbmyjO3zYmeuyFdfA8duRqQZfgCAMlsfmkVbJ+e2MAJw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + peerDependencies: + '@babel/core': ^7.11.0 + balanced-match@1.0.2: resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} @@ -2341,6 +3034,14 @@ packages: resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} engines: {node: '>=8'} + browserslist@4.25.1: + resolution: {integrity: sha512-KGj0KoOMXLpSNkkEI6Z6mShmQy0bc1I+T7K9N81k4WWMrfz+6fQ6es80B/YLAeRoKvjYE1YSHHOW1qe9xIVzHw==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + hasBin: true + + bser@2.1.1: + resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==} + buffer-from@1.1.2: resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} @@ -2387,6 +3088,14 @@ packages: resolution: {integrity: sha512-Rircqi9ch8AnZscQcsA1C47NFdaO3wukpmIRzYcDOrmvgt78hM/sj5pZhZNec2NM12uk5vTwRHZ4anGcrC4ZTg==} engines: {node: '>=16'} + camelcase@5.3.1: + resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} + engines: {node: '>=6'} + + camelcase@6.3.0: + resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} + engines: {node: '>=10'} + camelcase@8.0.0: resolution: {integrity: sha512-8WB3Jcas3swSvjIeA2yvCJ+Miyz5l1ZmB6HFb9R1317dt9LCQoswg/BGrmAmkWVEszSrrg4RwmO46qIm2OEnSA==} engines: {node: '>=16'} @@ -2394,6 +3103,9 @@ packages: caniuse-lite@1.0.30001707: resolution: {integrity: sha512-3qtRjw/HQSMlDWf+X79N206fepf4SOOU6SQLMaq/0KkZLmSjPxAkBOQQ+FxbHKfHmYLZFfdWsO3KA90ceHPSnw==} + caniuse-lite@1.0.30001731: + resolution: {integrity: sha512-lDdp2/wrOmTRWuoB5DpfNkC0rJDU8DqRa6nYL6HK6sytw70QMopt/NIc/9SM7ylItlBWfACXk0tEn37UWM/+mg==} + canvas-confetti@1.9.3: resolution: {integrity: sha512-rFfTURMvmVEX1gyXFgn5QMn81bYk70qa0HLzcIOSVEyl57n6o9ItHeBtUSWdvKAPY0xlvBHno4/v3QPrT83q9g==} @@ -2420,6 +3132,10 @@ packages: change-case@3.1.0: resolution: {integrity: sha512-2AZp7uJZbYEzRPsFoa+ijKdvp9zsrnnt6+yFokfwEpeJm0xuJDVoxiRCAaTzyJND8GJkofo2IcKWaUZ/OECVzw==} + char-regex@1.0.2: + resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==} + engines: {node: '>=10'} + chardet@0.7.0: resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==} @@ -2435,6 +3151,13 @@ packages: resolution: {integrity: sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==} engines: {node: '>=18'} + ci-info@4.3.0: + resolution: {integrity: sha512-l+2bNRMiQgcfILUi33labAZYIWlH1kWDp+ecNo5iisRKrbm0xcRyCww71/YU0Fkw0mAFpz9bJayXPjey6vkmaQ==} + engines: {node: '>=8'} + + cjs-module-lexer@2.1.0: + resolution: {integrity: sha512-UX0OwmYRYQQetfrLEZeewIFFI+wSTofC+pMBLNuH3RUuu/xzG1oz84UCEDOSoQlN3fZ4+AzmV50ZYvGqkMh9yA==} + class-variance-authority@0.7.1: resolution: {integrity: sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==} @@ -2485,6 +3208,13 @@ packages: resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==} engines: {node: '>=0.10.0'} + co@4.6.0: + resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} + engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} + + collect-v8-coverage@1.0.2: + resolution: {integrity: sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==} + color-convert@1.9.3: resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==} @@ -2553,6 +3283,9 @@ packages: engines: {node: '>=16'} hasBin: true + convert-source-map@2.0.0: + resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + core-js-pure@3.40.0: resolution: {integrity: sha512-AtDzVIgRrmRKQai62yuSIN5vNiQjcJakJb4fbhVw3ehxx7Lohphvw9SGNWKhLFqSxC4ilD0g/L1huAYFQU3Q6A==} @@ -2637,6 +3370,14 @@ packages: supports-color: optional: true + dedent@1.6.0: + resolution: {integrity: sha512-F1Z+5UCFpmQUzJa11agbyPVMbpgT/qA3/SKyJ1jyBgm7dUcUEa8v9JwDkerSQXfakBwFljIxhOJqGkjUwZ9FSA==} + peerDependencies: + babel-plugin-macros: ^3.1.0 + peerDependenciesMeta: + babel-plugin-macros: + optional: true + deep-extend@0.6.0: resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} engines: {node: '>=4.0.0'} @@ -2690,6 +3431,10 @@ packages: resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==} engines: {node: '>=8'} + detect-newline@3.1.0: + resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==} + engines: {node: '>=8'} + detect-node-es@1.1.0: resolution: {integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==} @@ -2844,6 +3589,16 @@ packages: eastasianwidth@0.2.0: resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} +<<<<<<< HEAD +======= + electron-to-chromium@1.5.194: + resolution: {integrity: sha512-SdnWJwSUot04UR51I2oPD8kuP2VI37/CADR1OHsFOUzZIvfWJBO6q11k5P/uKNyTT3cdOsnyjkrZ+DDShqYqJA==} + + emittery@0.13.1: + resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==} + engines: {node: '>=12'} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) emoji-regex@10.4.0: resolution: {integrity: sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==} @@ -2934,6 +3689,10 @@ packages: resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==} engines: {node: '>=0.8.0'} + escape-string-regexp@2.0.0: + resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} + engines: {node: '>=8'} + escape-string-regexp@4.0.0: resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} engines: {node: '>=10'} @@ -2943,6 +3702,12 @@ packages: engines: {node: '>=6.0'} hasBin: true + eslint-config-prettier@10.1.8: + resolution: {integrity: sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==} + hasBin: true + peerDependencies: + eslint: '>=7.0.0' + eslint-config-prettier@9.1.0: resolution: {integrity: sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==} hasBin: true @@ -2953,6 +3718,20 @@ packages: resolution: {integrity: sha512-2tktqUAT+Q3hCAU0iSf4xAN1k9zOpjK5WO8104mB0rT/dGhOa09582HN5HlbxNbPRZ0THV7nLGvzugcNOSjzfA==} engines: {node: '>=6'} + eslint-plugin-prettier@5.5.3: + resolution: {integrity: sha512-NAdMYww51ehKfDyDhv59/eIItUVzU0Io9H2E8nHNGKEeeqlnci+1gCvrHib6EmZdf6GxF+LCV5K7UC65Ezvw7w==} + engines: {node: ^14.18.0 || >=16.0.0} + peerDependencies: + '@types/eslint': '>=8.0.0' + eslint: '>=8.0.0' + eslint-config-prettier: '>= 7.0.0 <10.0.0 || >=10.1.0' + prettier: '>=3.0.0' + peerDependenciesMeta: + '@types/eslint': + optional: true + eslint-config-prettier: + optional: true + eslint-plugin-react-hooks@5.1.0: resolution: {integrity: sha512-mpJRtPgHN2tNAvZ35AMfqeB3Xqeo273QxrHJsbBEPWODRM4r0yB6jfoROqKEYrOn27UtRPpcpHc2UqyBSuUNTw==} engines: {node: '>=10'} @@ -2975,6 +3754,10 @@ packages: resolution: {integrity: sha512-PHlWUfG6lvPc3yvP5A4PNyBL1W8fkDUccmI21JUu/+GKZBoH/W5u6usENXUrWFRsyoW5ACUjFGgAFQp5gUlb/A==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + eslint-scope@8.4.0: + resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + eslint-visitor-keys@3.4.3: resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -2983,6 +3766,10 @@ packages: resolution: {integrity: sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + eslint-visitor-keys@4.2.1: + resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + eslint@9.20.1: resolution: {integrity: sha512-m1mM33o6dBUjxl2qb6wv6nGNwCAsns1eKtaQ4l/NPHeTvhiUPbtdfMyktxN4B3fgHIgsYh1VT3V9txblpQHq+g==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -2993,6 +3780,16 @@ packages: jiti: optional: true + eslint@9.32.0: + resolution: {integrity: sha512-LSehfdpgMeWcTZkWZVIJl+tkZ2nuSkyyB9C27MZqFWXuph7DvaowgcTvKqxvpLW1JZIk8PN7hFY3Rj9LQ7m7lg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + hasBin: true + peerDependencies: + jiti: '*' + peerDependenciesMeta: + jiti: + optional: true + esm-env@1.2.2: resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==} @@ -3000,6 +3797,10 @@ packages: resolution: {integrity: sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + espree@10.4.0: + resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + esprima@4.0.1: resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} engines: {node: '>=4'} @@ -3036,6 +3837,14 @@ packages: resolution: {integrity: sha512-UduyVP7TLB5IcAQl+OzLyLcS/l32W/GLg+AhHJ+ow40FOk2U3SAllPwR44v4vmdFwIWqpdwxxpQbF1n5ta9seA==} engines: {node: ^14.18.0 || ^16.14.0 || >=18.0.0} + exit-x@0.2.2: + resolution: {integrity: sha512-+I6B/IkJc1o/2tiURyz/ivu/O0nKNEArIUB5O7zBrlDVJr22SCLH3xTeEry428LvFhRzIA1g8izguxJ/gbNcVQ==} + engines: {node: '>= 0.8.0'} + + expect@30.0.5: + resolution: {integrity: sha512-P0te2pt+hHI5qLJkIR+iMvS+lYUZml8rKKsohVHAGY+uClp9XVbdyYNJOIjSRpHVp8s8YqxJCiHUkSYZGr8rtQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + external-editor@3.1.0: resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==} engines: {node: '>=4'} @@ -3050,6 +3859,9 @@ packages: fast-deep-equal@3.1.3: resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + fast-diff@1.3.0: + resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==} + fast-glob@3.3.1: resolution: {integrity: sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg==} engines: {node: '>=8.6.0'} @@ -3070,6 +3882,12 @@ packages: fastq@1.19.0: resolution: {integrity: sha512-7SFSRCNjBQIZH/xZR3iy5iQYR8aGBE0h3VG6/cwlbrpdciNYBMotQav8c1XI3HjHH+NikUpP53nPdlZSdWmFzA==} +<<<<<<< HEAD +======= + fb-watchman@2.0.2: + resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) fdir@6.4.6: resolution: {integrity: sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==} peerDependencies: @@ -3094,6 +3912,10 @@ packages: resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} engines: {node: '>=8'} + find-up@4.1.0: + resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} + engines: {node: '>=8'} + find-up@5.0.0: resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} engines: {node: '>=10'} @@ -3180,6 +4002,10 @@ packages: functions-have-names@1.2.3: resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} + gensync@1.0.0-beta.2: + resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} + engines: {node: '>=6.9.0'} + get-caller-file@2.0.5: resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} engines: {node: 6.* || 8.* || >= 10.*} @@ -3196,6 +4022,10 @@ packages: resolution: {integrity: sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==} engines: {node: '>=6'} + get-package-type@0.1.0: + resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} + engines: {node: '>=8.0.0'} + get-proto@1.0.1: resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} engines: {node: '>= 0.4'} @@ -3317,6 +4147,9 @@ packages: resolution: {integrity: sha512-hM+1RIn9PK1I6SiTNS6/y7O1mvg88awYLFEuEtoiMtRyT3SD2iu9pSFgbBXT3b1Ua4IwzvSTLvwO0SEhDxCi4w==} engines: {node: '>=16.9.0'} + html-escaper@2.0.2: + resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + html-to-text@9.0.5: resolution: {integrity: sha512-qY60FjREgVZL03vJU6IfMV4GDjGBIoOyvuFdpBDIX9yTlDw0TjxVBQp+P8NvpdIXNJvfWBTNul7fsAQJq2FNpg==} engines: {node: '>=14'} @@ -3359,10 +4192,19 @@ packages: resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} engines: {node: '>= 4'} + ignore@7.0.5: + resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==} + engines: {node: '>= 4'} + import-fresh@3.3.1: resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} engines: {node: '>=6'} + import-local@3.2.0: + resolution: {integrity: sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==} + engines: {node: '>=8'} + hasBin: true + import-meta-resolve@4.1.0: resolution: {integrity: sha512-I6fiaX09Xivtk+THaMfAwnA3MVA5Big1WHF1Dfx9hFuvNIWpXnorlkzhcQf6ehrqQiiZECRt1poOAkPmer3ruw==} @@ -3480,6 +4322,10 @@ packages: resolution: {integrity: sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA==} engines: {node: '>=18'} + is-generator-fn@2.1.0: + resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==} + engines: {node: '>=6'} + is-generator-function@1.1.0: resolution: {integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==} engines: {node: '>= 0.4'} @@ -3600,6 +4446,26 @@ packages: peerDependencies: ws: '*' + istanbul-lib-coverage@3.2.2: + resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} + engines: {node: '>=8'} + + istanbul-lib-instrument@6.0.3: + resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==} + engines: {node: '>=10'} + + istanbul-lib-report@3.0.1: + resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} + engines: {node: '>=10'} + + istanbul-lib-source-maps@5.0.6: + resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==} + engines: {node: '>=10'} + + istanbul-reports@3.1.7: + resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} + engines: {node: '>=8'} + iterator.prototype@1.1.5: resolution: {integrity: sha512-H0dkQoCa3b2VEeKQBOxFph+JAbcrQdE7KC0UkqwpLmv2EC4P41QXP+rqo9wYodACiG5/WM5s9oDApTU8utwj9g==} engines: {node: '>= 0.4'} @@ -3607,6 +4473,137 @@ packages: jackspeak@3.4.3: resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} +<<<<<<< HEAD +======= + jest-changed-files@30.0.5: + resolution: {integrity: sha512-bGl2Ntdx0eAwXuGpdLdVYVr5YQHnSZlQ0y9HVDu565lCUAe9sj6JOtBbMmBBikGIegne9piDDIOeiLVoqTkz4A==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-circus@30.0.5: + resolution: {integrity: sha512-h/sjXEs4GS+NFFfqBDYT7y5Msfxh04EwWLhQi0F8kuWpe+J/7tICSlswU8qvBqumR3kFgHbfu7vU6qruWWBPug==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-cli@30.0.5: + resolution: {integrity: sha512-Sa45PGMkBZzF94HMrlX4kUyPOwUpdZasaliKN3mifvDmkhLYqLLg8HQTzn6gq7vJGahFYMQjXgyJWfYImKZzOw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + hasBin: true + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + + jest-config@30.0.5: + resolution: {integrity: sha512-aIVh+JNOOpzUgzUnPn5FLtyVnqc3TQHVMupYtyeURSb//iLColiMIR8TxCIDKyx9ZgjKnXGucuW68hCxgbrwmA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + peerDependencies: + '@types/node': '*' + esbuild-register: '>=3.4.0' + ts-node: '>=9.0.0' + peerDependenciesMeta: + '@types/node': + optional: true + esbuild-register: + optional: true + ts-node: + optional: true + + jest-diff@30.0.5: + resolution: {integrity: sha512-1UIqE9PoEKaHcIKvq2vbibrCog4Y8G0zmOxgQUVEiTqwR5hJVMCoDsN1vFvI5JvwD37hjueZ1C4l2FyGnfpE0A==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-docblock@30.0.1: + resolution: {integrity: sha512-/vF78qn3DYphAaIc3jy4gA7XSAz167n9Bm/wn/1XhTLW7tTBIzXtCJpb/vcmc73NIIeeohCbdL94JasyXUZsGA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-each@30.0.5: + resolution: {integrity: sha512-dKjRsx1uZ96TVyejD3/aAWcNKy6ajMaN531CwWIsrazIqIoXI9TnnpPlkrEYku/8rkS3dh2rbH+kMOyiEIv0xQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-environment-node@30.0.5: + resolution: {integrity: sha512-ppYizXdLMSvciGsRsMEnv/5EFpvOdXBaXRBzFUDPWrsfmog4kYrOGWXarLllz6AXan6ZAA/kYokgDWuos1IKDA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-haste-map@30.0.5: + resolution: {integrity: sha512-dkmlWNlsTSR0nH3nRfW5BKbqHefLZv0/6LCccG0xFCTWcJu8TuEwG+5Cm75iBfjVoockmO6J35o5gxtFSn5xeg==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-leak-detector@30.0.5: + resolution: {integrity: sha512-3Uxr5uP8jmHMcsOtYMRB/zf1gXN3yUIc+iPorhNETG54gErFIiUhLvyY/OggYpSMOEYqsmRxmuU4ZOoX5jpRFg==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-matcher-utils@30.0.5: + resolution: {integrity: sha512-uQgGWt7GOrRLP1P7IwNWwK1WAQbq+m//ZY0yXygyfWp0rJlksMSLQAA4wYQC3b6wl3zfnchyTx+k3HZ5aPtCbQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-message-util@30.0.5: + resolution: {integrity: sha512-NAiDOhsK3V7RU0Aa/HnrQo+E4JlbarbmI3q6Pi4KcxicdtjV82gcIUrejOtczChtVQR4kddu1E1EJlW6EN9IyA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-mock@30.0.5: + resolution: {integrity: sha512-Od7TyasAAQX/6S+QCbN6vZoWOMwlTtzzGuxJku1GhGanAjz9y+QsQkpScDmETvdc9aSXyJ/Op4rhpMYBWW91wQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-pnp-resolver@1.2.3: + resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==} + engines: {node: '>=6'} + peerDependencies: + jest-resolve: '*' + peerDependenciesMeta: + jest-resolve: + optional: true + + jest-regex-util@30.0.1: + resolution: {integrity: sha512-jHEQgBXAgc+Gh4g0p3bCevgRCVRkB4VB70zhoAE48gxeSr1hfUOsM/C2WoJgVL7Eyg//hudYENbm3Ne+/dRVVA==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-resolve-dependencies@30.0.5: + resolution: {integrity: sha512-/xMvBR4MpwkrHW4ikZIWRttBBRZgWK4d6xt3xW1iRDSKt4tXzYkMkyPfBnSCgv96cpkrctfXs6gexeqMYqdEpw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-resolve@30.0.5: + resolution: {integrity: sha512-d+DjBQ1tIhdz91B79mywH5yYu76bZuE96sSbxj8MkjWVx5WNdt1deEFRONVL4UkKLSrAbMkdhb24XN691yDRHg==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-runner@30.0.5: + resolution: {integrity: sha512-JcCOucZmgp+YuGgLAXHNy7ualBx4wYSgJVWrYMRBnb79j9PD0Jxh0EHvR5Cx/r0Ce+ZBC4hCdz2AzFFLl9hCiw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-runtime@30.0.5: + resolution: {integrity: sha512-7oySNDkqpe4xpX5PPiJTe5vEa+Ak/NnNz2bGYZrA1ftG3RL3EFlHaUkA1Cjx+R8IhK0Vg43RML5mJedGTPNz3A==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-snapshot@30.0.5: + resolution: {integrity: sha512-T00dWU/Ek3LqTp4+DcW6PraVxjk28WY5Ua/s+3zUKSERZSNyxTqhDXCWKG5p2HAJ+crVQ3WJ2P9YVHpj1tkW+g==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-util@30.0.5: + resolution: {integrity: sha512-pvyPWssDZR0FlfMxCBoc0tvM8iUEskaRFALUtGQYzVEAqisAztmy+R8LnU14KT4XA0H/a5HMVTXat1jLne010g==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-validate@30.0.5: + resolution: {integrity: sha512-ouTm6VFHaS2boyl+k4u+Qip4TSH7Uld5tyD8psQ8abGgt2uYYB8VwVfAHWHjHc0NWmGGbwO5h0sCPOGHHevefw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-watcher@30.0.5: + resolution: {integrity: sha512-z9slj/0vOwBDBjN3L4z4ZYaA+pG56d6p3kTUhFRYGvXbXMWhXmb/FIxREZCD06DYUwDKKnj2T80+Pb71CQ0KEg==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest-worker@30.0.5: + resolution: {integrity: sha512-ojRXsWzEP16NdUuBw/4H/zkZdHOa7MMYCk4E430l+8fELeLg/mqmMlRhjL7UNZvQrDmnovWZV4DxX03fZF48fQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + + jest@30.0.5: + resolution: {integrity: sha512-y2mfcJywuTUkvLm2Lp1/pFX8kTgMO5yyQGq/Sk/n2mN7XWYp4JsCZ/QXW34M8YScgk8bPZlREH04f6blPnoHnQ==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + hasBin: true + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) jiti@2.4.2: resolution: {integrity: sha512-rg9zJN+G4n2nfJl5MW3BMygZX56zKPNVEYYqq7adpmMh4Jn2QNEwhvQlFy6jPVdcod7txZtKHWnyZiA3a0zP7A==} hasBin: true @@ -3621,6 +4618,10 @@ packages: js-tokens@4.0.0: resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + js-yaml@3.14.1: + resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} + hasBin: true + js-yaml@4.1.0: resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} hasBin: true @@ -3628,6 +4629,11 @@ packages: jsbn@1.1.0: resolution: {integrity: sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==} + jsesc@3.1.0: + resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==} + engines: {node: '>=6'} + hasBin: true + json-buffer@3.0.1: resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} @@ -3643,6 +4649,11 @@ packages: json-stable-stringify-without-jsonify@1.0.1: resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} + json5@2.2.3: + resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} + engines: {node: '>=6'} + hasBin: true + jsonfile@6.1.0: resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} @@ -3668,6 +4679,10 @@ packages: leac@0.6.0: resolution: {integrity: sha512-y+SqErxb8h7nE/fiEX07jsbuhrpO9lL8eca7/Y1nuWV2moNlXhyd59iDGcRf6moVyDMbmTNzL40SUyrFU/yDpg==} + leven@3.1.0: + resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} + engines: {node: '>=6'} + levn@0.4.1: resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} engines: {node: '>= 0.8.0'} @@ -3766,6 +4781,13 @@ packages: resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} +<<<<<<< HEAD +======= + locate-path@5.0.0: + resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} + engines: {node: '>=8'} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) locate-path@6.0.0: resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} engines: {node: '>=10'} @@ -3857,6 +4879,12 @@ packages: lru-cache@10.4.3: resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==} +<<<<<<< HEAD +======= + lru-cache@5.1.1: + resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) lru-cache@7.18.3: resolution: {integrity: sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==} engines: {node: '>=12'} @@ -3869,9 +4897,19 @@ packages: magic-string@0.30.17: resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==} +<<<<<<< HEAD +======= + make-dir@4.0.0: + resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} + engines: {node: '>=10'} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) make-error@1.3.6: resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==} + makeerror@1.0.12: + resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==} + map-obj@5.0.0: resolution: {integrity: sha512-2L3MIgJynYrZ3TYMriLDLWocz15okFakV6J12HXvMXDHui2x/zgChzg1u9mFFGbbGWE+GsLpQByt4POb9Or+uA==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} @@ -3884,6 +4922,10 @@ packages: resolution: {integrity: sha512-fwPx8DaUei6IYHw6bIh/5tjcaaWyE1HWdBXX+k/YOL+OOpGz3PAdzT3s85n9hzE0r03I72ljoLQWvL6TfJpeYA==} engines: {node: '>=18'} + mediasoup-client@3.14.0: + resolution: {integrity: sha512-CKIcGrD8wXV40m/rUOehwkLPdAsF5DjqqWZPXUjxsyiDQ4K146g6R76XwXuFsJtYRcqdT2zhJtuGISKnMcaF6Q==} + engines: {node: '>=18'} + mediasoup@3.16.7: resolution: {integrity: sha512-1Hd9FI7jDwtZY/usaxG15p4L8k5spPGBZU2emZEqecXi26cGciStuK6XjJ/dLdGv+XEBPmcXmlekNeQLow4rTQ==} engines: {node: '>=20'} @@ -4000,6 +5042,11 @@ packages: resolution: {integrity: sha512-k1oiVNN4hDK8NcNERSZLQiMfRzEGtfnvZvdBvey3SQbgn8Dcrk0h1I6vpxApjb10PFUflZrgJ2WEZyJQ+5v7YQ==} engines: {node: ^18.0.0 || >=20.0.0} + napi-postinstall@0.3.2: + resolution: {integrity: sha512-tWVJxJHmBWLy69PvO96TZMZDrzmw5KeiZBz3RHmiM2XZ9grBJ2WgMAFVVg25nqp3ZjTFUs2Ftw1JhscL3Teliw==} + engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0} + hasBin: true + natural-compare@1.4.0: resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} @@ -4058,10 +5105,16 @@ packages: resolution: {integrity: sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + node-int64@0.4.0: + resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==} + node-plop@0.26.3: resolution: {integrity: sha512-Cov028YhBZ5aB7MdMWJEmwyBig43aGL5WT4vdoB28Oitau1zZAcHUn8Sgfk9HM33TqhtLJ9PlM/O0Mv+QpV/4Q==} engines: {node: '>=8.9.4'} + node-releases@2.0.19: + resolution: {integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==} + nodemon@3.1.10: resolution: {integrity: sha512-WDjw3pJ0/0jMFmyNDp3gvY2YizjLmmOUQo6DEBY+JgdvW/yQ9mEeSw6H5ythl5Ny2ytb7f9C2nIbjSxMNzbJXw==} engines: {node: '>=10'} @@ -4149,6 +5202,10 @@ packages: resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==} engines: {node: '>= 0.4'} + p-limit@2.3.0: + resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} + engines: {node: '>=6'} + p-limit@3.1.0: resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} engines: {node: '>=10'} @@ -4157,6 +5214,10 @@ packages: resolution: {integrity: sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + p-locate@4.1.0: + resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} + engines: {node: '>=8'} + p-locate@5.0.0: resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} engines: {node: '>=10'} @@ -4169,6 +5230,10 @@ packages: resolution: {integrity: sha512-d3qXVTF/s+W+CdJ5A29wywV2n8CQQYahlgz2bFiA+4eVNJbHJodPZ+/gXwPGh0bOqA+j8S+6+ckmvLGPk1QpxQ==} engines: {node: '>=8'} + p-try@2.2.0: + resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} + engines: {node: '>=6'} + pac-proxy-agent@7.2.0: resolution: {integrity: sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==} engines: {node: '>= 14'} @@ -4294,6 +5359,13 @@ packages: resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==} engines: {node: '>= 6'} +<<<<<<< HEAD +======= + pkg-dir@4.2.0: + resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} + engines: {node: '>=8'} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) pkg-types@1.3.1: resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==} @@ -4351,6 +5423,10 @@ packages: resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} engines: {node: '>= 0.8.0'} + prettier-linter-helpers@1.0.0: + resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==} + engines: {node: '>=6.0.0'} + prettier-plugin-tailwindcss@0.6.14: resolution: {integrity: sha512-pi2e/+ZygeIqntN+vC573BcW5Cve8zUB0SSAGxqpB4f96boZF4M3phPVoOFCeypwkpRYdi7+jQ5YJJUwrkGUAg==} engines: {node: '>=14.21.3'} @@ -4422,6 +5498,15 @@ packages: engines: {node: '>=14'} hasBin: true + prettier@3.6.2: + resolution: {integrity: sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==} + engines: {node: '>=14'} + hasBin: true + + pretty-format@30.0.5: + resolution: {integrity: sha512-D1tKtYvByrBkFLe2wHJl2bwMJIiT8rW+XA+TiataH79/FszLQMrpGEvzUVkzPau7OCO0Qnrhpe87PqtOAIB8Yw==} + engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0} + prompts@2.4.2: resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} engines: {node: '>= 6'} @@ -4443,6 +5528,9 @@ packages: resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} engines: {node: '>=6'} + pure-rand@7.0.1: + resolution: {integrity: sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==} + pvtsutils@1.3.6: resolution: {integrity: sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==} @@ -4469,6 +5557,11 @@ packages: peerDependencies: react: ^19.0.0 + react-dom@19.1.1: + resolution: {integrity: sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw==} + peerDependencies: + react: ^19.1.1 + react-hook-form@7.58.1: resolution: {integrity: sha512-Lml/KZYEEFfPhUVgE0RdCVpnC4yhW+PndRhbiTtdvSlQTL8IfVR+iQkBjLIvmmc6+GGoVeM11z37ktKFPAb0FA==} engines: {node: '>=18.0.0'} @@ -4483,6 +5576,9 @@ packages: react-is@16.13.1: resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==} + react-is@18.3.1: + resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} + react-promise-suspense@0.3.4: resolution: {integrity: sha512-I42jl7L3Ze6kZaq+7zXWSunBa3b1on5yfvUW6Eo/3fFOj6dZ5Bqmcd264nJbTK/gn1HjjILAjSwnZbV4RpSaNQ==} @@ -4520,6 +5616,10 @@ packages: resolution: {integrity: sha512-V8AVnmPIICiWpGfm6GLzCR/W5FXLchHop40W4nXBmdlEceh16rCN8O8LNWm5bh5XUX91fh7KpA+W0TgMKmgTpQ==} engines: {node: '>=0.10.0'} + react@19.1.1: + resolution: {integrity: sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ==} + engines: {node: '>=0.10.0'} + readable-stream@3.6.2: resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} engines: {node: '>= 6'} @@ -4570,6 +5670,10 @@ packages: resolution: {integrity: sha512-D5T2I82FvEUYFlrHzaDvVtr5ADHdhuoLaXgLFGABKyNtQgPWIuz0Vp2L2Evx779qjK37aF4kcw1yXJDHhA2JnQ==} engines: {node: '>=18'} + resolve-cwd@3.0.0: + resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==} + engines: {node: '>=8'} + resolve-from@4.0.0: resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} engines: {node: '>=4'} @@ -4614,8 +5718,13 @@ packages: deprecated: Rimraf versions prior to v4 are no longer supported hasBin: true +<<<<<<< HEAD rollup@4.46.1: resolution: {integrity: sha512-33xGNBsDJAkzt0PvninskHlWnTIPgDtTwhg0U38CUoNP/7H6wI2Cz6dUeoNPbjdTdsYTGuiFFASuUOWovH0SyQ==} +======= + rollup@4.46.2: + resolution: {integrity: sha512-WMmLFI+Boh6xbop+OAGo9cQ3OgX9MIg7xOQjn+pTCwOkk+FNDAeAemXkJ3HzDJrVXleLOFVa1ipuc1AmEx1Dwg==} +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) engines: {node: '>=18.0.0', npm: '>=8.0.0'} hasBin: true @@ -4660,6 +5769,9 @@ packages: scheduler@0.25.0: resolution: {integrity: sha512-xFVuu11jh+xcO7JOAGJNOXld8/TcEHK/4CituBUeUb5hqxJLj9YuemAEuvm9gQ/+pgXYfbQuqAkiYu+u7YEsNA==} + scheduler@0.26.0: + resolution: {integrity: sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==} + sdp-transform@2.15.0: resolution: {integrity: sha512-KrOH82c/W+GYQ0LHqtr3caRpM3ITglq3ljGUIb8LTki7ByacJZ9z+piSGiwZDsRyhQbYBOBJgr2k6X4BZXi3Kw==} hasBin: true @@ -4684,6 +5796,11 @@ packages: engines: {node: '>=10'} hasBin: true + semver@7.7.2: + resolution: {integrity: sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==} + engines: {node: '>=10'} + hasBin: true + sentence-case@2.1.1: resolution: {integrity: sha512-ENl7cYHaK/Ktwk5OTD+aDbQ3uC8IByu/6Bkg+HDv8Mm+XnBnppVNalcfJTNsp1ibstKh030/JKQQWglDvtKwEQ==} @@ -4792,6 +5909,9 @@ packages: resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} engines: {node: '>=0.10.0'} + source-map-support@0.5.13: + resolution: {integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==} + source-map-support@0.5.21: resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} @@ -4808,9 +5928,16 @@ packages: resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==} engines: {node: '>= 10.x'} + sprintf-js@1.0.3: + resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} + sprintf-js@1.1.3: resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==} + stack-utils@2.0.6: + resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==} + engines: {node: '>=10'} + standard-as-callback@2.1.0: resolution: {integrity: sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==} @@ -4826,6 +5953,10 @@ packages: resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==} engines: {node: '>=0.6.19'} + string-length@4.0.2: + resolution: {integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==} + engines: {node: '>=10'} + string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} @@ -4868,6 +5999,10 @@ packages: resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==} engines: {node: '>=12'} + strip-bom@4.0.0: + resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} + engines: {node: '>=8'} + strip-final-newline@2.0.0: resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==} engines: {node: '>=6'} @@ -4914,6 +6049,10 @@ packages: resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} engines: {node: '>=8'} + supports-color@8.1.1: + resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} + engines: {node: '>=10'} + supports-preserve-symlinks-flag@1.0.0: resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} engines: {node: '>= 0.4'} @@ -4921,6 +6060,10 @@ packages: swap-case@1.1.2: resolution: {integrity: sha512-BAmWG6/bx8syfc6qXPprof3Mn5vQgf5dwdUNJhsNqU9WdPt5P+ES/wQ5bxfijy8zwZgZZHslC3iAsxsuQMCzJQ==} + synckit@0.11.11: + resolution: {integrity: sha512-MeQTA1r0litLUf0Rp/iisCaL8761lKAZHaimlbGK4j0HysC4PLfqygQj9srcs0m2RdtDYnF8UuYyKpbjHYp7Jw==} + engines: {node: ^14.18.0 || >=16.0.0} + tailwind-merge@3.0.1: resolution: {integrity: sha512-AvzE8FmSoXC7nC+oU5GlQJbip2UO7tmOhOfQyOmPhrStOGXHU08j8mZEHZ4BmCqY5dWTCo4ClWkNyRNx1wpT0g==} @@ -4935,6 +6078,10 @@ packages: resolution: {integrity: sha512-5S7Va8hKfV7W5U6g3aYxXmlPoZVAwUMy9AOKyF2fVuZa2UD3qZjg578OrLRt8PcNN1PleVaL/5/yYATNL0ICUw==} engines: {node: '>=18'} + test-exclude@6.0.0: + resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} + engines: {node: '>=8'} + text-extensions@2.4.0: resolution: {integrity: sha512-te/NtwBwfiNRLf9Ijqx3T0nlqZiQ2XrrtBvu+cLL8ZRrGkO0NHTug8MYFKyoSrv/sHTaSKfilUkizV6XhxMJ3g==} engines: {node: '>=8'} @@ -4972,6 +6119,9 @@ packages: resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} engines: {node: '>=0.6.0'} + tmpl@1.0.5: + resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==} + to-regex-range@5.0.1: resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} engines: {node: '>=8.0'} @@ -4996,6 +6146,12 @@ packages: peerDependencies: typescript: '>=4.8.4' + ts-api-utils@2.1.0: + resolution: {integrity: sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==} + engines: {node: '>=18.12'} + peerDependencies: + typescript: '>=4.8.4' + ts-debounce@4.0.0: resolution: {integrity: sha512-+1iDGY6NmOGidq7i7xZGA4cm8DAa6fqdYcvO5Z6yBevH++Bdo9Qt/mN0TzHUgcCcKv1gmh9+W5dHqz8pMWbCbg==} @@ -5087,6 +6243,10 @@ packages: resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} engines: {node: '>= 0.8.0'} + type-detect@4.0.8: + resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} + engines: {node: '>=4'} + type-fest@0.21.3: resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} engines: {node: '>=10'} @@ -5131,6 +6291,11 @@ packages: engines: {node: '>=14.17'} hasBin: true + typescript@5.9.2: + resolution: {integrity: sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==} + engines: {node: '>=14.17'} + hasBin: true + ua-is-frozen@0.1.2: resolution: {integrity: sha512-RwKDW2p3iyWn4UbaxpP2+VxwqXh0jpvdxsYpZ5j/MLLiQOfbsV5shpgQiw93+KMYQPcteeMQ289MaAFzs3G9pw==} @@ -5167,6 +6332,15 @@ packages: resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} engines: {node: '>= 10.0.0'} + unrs-resolver@1.11.1: + resolution: {integrity: sha512-bSjt9pjaEBnNiGgc9rUiHGKv5l4/TGzDmYw3RhnkJGtLhbnnA/5qJj7x3dNDCRx/PJxu774LlH8lCOlB4hEfKg==} + + update-browserslist-db@1.1.3: + resolution: {integrity: sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==} + hasBin: true + peerDependencies: + browserslist: '>= 4.21.0' + update-check@1.5.4: resolution: {integrity: sha512-5YHsflzHP4t1G+8WGPlvKbJEbAJGCgw+Em+dGR1KmBUbr1J36SJBqlHLjR7oob7sco5hWHGQVcr9B2poIVDDTQ==} @@ -5220,10 +6394,17 @@ packages: v8-compile-cache-lib@3.0.1: resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} + v8-to-istanbul@9.3.0: + resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==} + engines: {node: '>=10.12.0'} + validate-npm-package-name@5.0.1: resolution: {integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + walker@1.0.8: + resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==} + wcwidth@1.0.1: resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==} @@ -5294,6 +6475,10 @@ packages: wrappy@1.0.2: resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + write-file-atomic@5.0.1: + resolution: {integrity: sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + ws@8.17.1: resolution: {integrity: sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==} engines: {node: '>=10.0.0'} @@ -5330,6 +6515,9 @@ packages: resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} engines: {node: '>=10'} + yallist@3.1.1: + resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} + yallist@5.0.0: resolution: {integrity: sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==} engines: {node: '>=18'} @@ -5384,14 +6572,175 @@ snapshots: '@alloc/quick-lru@5.2.0': {} + '@ampproject/remapping@2.3.0': + dependencies: + '@jridgewell/gen-mapping': 0.3.12 + '@jridgewell/trace-mapping': 0.3.29 + '@babel/code-frame@7.27.1': dependencies: '@babel/helper-validator-identifier': 7.27.1 js-tokens: 4.0.0 picocolors: 1.1.1 + '@babel/compat-data@7.28.0': {} + + '@babel/core@7.28.0': + dependencies: + '@ampproject/remapping': 2.3.0 + '@babel/code-frame': 7.27.1 + '@babel/generator': 7.28.0 + '@babel/helper-compilation-targets': 7.27.2 + '@babel/helper-module-transforms': 7.27.3(@babel/core@7.28.0) + '@babel/helpers': 7.28.2 + '@babel/parser': 7.28.0 + '@babel/template': 7.27.2 + '@babel/traverse': 7.28.0 + '@babel/types': 7.28.2 + convert-source-map: 2.0.0 + debug: 4.4.1 + gensync: 1.0.0-beta.2 + json5: 2.2.3 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + + '@babel/generator@7.28.0': + dependencies: + '@babel/parser': 7.28.0 + '@babel/types': 7.28.2 + '@jridgewell/gen-mapping': 0.3.12 + '@jridgewell/trace-mapping': 0.3.29 + jsesc: 3.1.0 + + '@babel/helper-compilation-targets@7.27.2': + dependencies: + '@babel/compat-data': 7.28.0 + '@babel/helper-validator-option': 7.27.1 + browserslist: 4.25.1 + lru-cache: 5.1.1 + semver: 6.3.1 + + '@babel/helper-globals@7.28.0': {} + + '@babel/helper-module-imports@7.27.1': + dependencies: + '@babel/traverse': 7.28.0 + '@babel/types': 7.28.2 + transitivePeerDependencies: + - supports-color + + '@babel/helper-module-transforms@7.27.3(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-module-imports': 7.27.1 + '@babel/helper-validator-identifier': 7.27.1 + '@babel/traverse': 7.28.0 + transitivePeerDependencies: + - supports-color + + '@babel/helper-plugin-utils@7.27.1': {} + + '@babel/helper-string-parser@7.27.1': {} + '@babel/helper-validator-identifier@7.27.1': {} + '@babel/helper-validator-option@7.27.1': {} + + '@babel/helpers@7.28.2': + dependencies: + '@babel/template': 7.27.2 + '@babel/types': 7.28.2 + + '@babel/parser@7.28.0': + dependencies: + '@babel/types': 7.28.2 + + '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-import-attributes@7.27.1(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-jsx@7.27.1(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + + '@babel/plugin-syntax-typescript@7.27.1(@babel/core@7.28.0)': + dependencies: + '@babel/core': 7.28.0 + '@babel/helper-plugin-utils': 7.27.1 + '@babel/runtime-corejs3@7.26.9': dependencies: core-js-pure: 3.40.0 @@ -5399,6 +6748,31 @@ snapshots: '@babel/runtime@7.27.6': {} + '@babel/template@7.27.2': + dependencies: + '@babel/code-frame': 7.27.1 + '@babel/parser': 7.28.0 + '@babel/types': 7.28.2 + + '@babel/traverse@7.28.0': + dependencies: + '@babel/code-frame': 7.27.1 + '@babel/generator': 7.28.0 + '@babel/helper-globals': 7.28.0 + '@babel/parser': 7.28.0 + '@babel/template': 7.27.2 + '@babel/types': 7.28.2 + debug: 4.4.1 + transitivePeerDependencies: + - supports-color + + '@babel/types@7.28.2': + dependencies: + '@babel/helper-string-parser': 7.27.1 + '@babel/helper-validator-identifier': 7.27.1 + + '@bcoe/v8-coverage@0.2.3': {} + '@better-auth/utils@0.2.5': dependencies: typescript: 5.8.3 @@ -5526,11 +6900,27 @@ snapshots: '@drizzle-team/brocli@0.10.2': {} + '@emnapi/core@1.4.5': + dependencies: + '@emnapi/wasi-threads': 1.0.4 + tslib: 2.8.1 + optional: true + '@emnapi/runtime@1.3.1': dependencies: tslib: 2.8.1 optional: true + '@emnapi/runtime@1.4.5': + dependencies: + tslib: 2.8.1 + optional: true + + '@emnapi/wasi-threads@1.0.4': + dependencies: + tslib: 2.8.1 + optional: true + '@esbuild-kit/core-utils@3.3.2': dependencies: esbuild: 0.18.20 @@ -5687,6 +7077,16 @@ snapshots: eslint: 9.20.1(jiti@2.4.2) eslint-visitor-keys: 3.4.3 + '@eslint-community/eslint-utils@4.4.1(eslint@9.32.0(jiti@2.4.2))': + dependencies: + eslint: 9.32.0(jiti@2.4.2) + eslint-visitor-keys: 3.4.3 + + '@eslint-community/eslint-utils@4.7.0(eslint@9.32.0(jiti@2.4.2))': + dependencies: + eslint: 9.32.0(jiti@2.4.2) + eslint-visitor-keys: 3.4.3 + '@eslint-community/regexpp@4.12.1': {} '@eslint/config-array@0.19.2': @@ -5697,6 +7097,16 @@ snapshots: transitivePeerDependencies: - supports-color + '@eslint/config-array@0.21.0': + dependencies: + '@eslint/object-schema': 2.1.6 + debug: 4.4.1 + minimatch: 3.1.2 + transitivePeerDependencies: + - supports-color + + '@eslint/config-helpers@0.3.0': {} + '@eslint/core@0.11.0': dependencies: '@types/json-schema': 7.0.15 @@ -5705,6 +7115,10 @@ snapshots: dependencies: '@types/json-schema': 7.0.15 + '@eslint/core@0.15.1': + dependencies: + '@types/json-schema': 7.0.15 + '@eslint/eslintrc@3.2.0': dependencies: ajv: 6.12.6 @@ -5719,10 +7133,26 @@ snapshots: transitivePeerDependencies: - supports-color + '@eslint/eslintrc@3.3.1': + dependencies: + ajv: 6.12.6 + debug: 4.4.1 + espree: 10.4.0 + globals: 14.0.0 + ignore: 5.3.2 + import-fresh: 3.3.1 + js-yaml: 4.1.0 + minimatch: 3.1.2 + strip-json-comments: 3.1.1 + transitivePeerDependencies: + - supports-color + '@eslint/js@9.20.0': {} '@eslint/js@9.29.0': {} + '@eslint/js@9.32.0': {} + '@eslint/object-schema@2.1.6': {} '@eslint/plugin-kit@0.2.7': @@ -5730,6 +7160,11 @@ snapshots: '@eslint/core': 0.12.0 levn: 0.4.1 + '@eslint/plugin-kit@0.3.4': + dependencies: + '@eslint/core': 0.15.1 + levn: 0.4.1 + '@floating-ui/core@1.7.2': dependencies: '@floating-ui/utils': 0.2.10 @@ -5750,18 +7185,24 @@ snapshots: react: 19.0.0 react-dom: 19.0.0(react@19.0.0) + '@floating-ui/react-dom@2.1.4(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@floating-ui/dom': 1.7.2 + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + '@floating-ui/utils@0.2.10': {} - '@geist-ui/core@2.3.8(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': + '@geist-ui/core@2.3.8(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': dependencies: '@babel/runtime': 7.27.6 - react: 19.0.0 - react-dom: 19.0.0(react@19.0.0) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) - '@geist-ui/icons@1.0.2(@geist-ui/core@2.3.8(react-dom@19.0.0(react@19.0.0))(react@19.0.0))(react@19.0.0)': + '@geist-ui/icons@1.0.2(@geist-ui/core@2.3.8(react-dom@19.1.1(react@19.1.1))(react@19.1.1))(react@19.1.1)': dependencies: - '@geist-ui/core': 2.3.8(react-dom@19.0.0(react@19.0.0))(react@19.0.0) - react: 19.0.0 + '@geist-ui/core': 2.3.8(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + react: 19.1.1 '@heroicons/react@2.2.0(react@19.0.0)': dependencies: @@ -5886,6 +7327,198 @@ snapshots: dependencies: minipass: 7.1.2 +<<<<<<< HEAD +======= + '@istanbuljs/load-nyc-config@1.1.0': + dependencies: + camelcase: 5.3.1 + find-up: 4.1.0 + get-package-type: 0.1.0 + js-yaml: 3.14.1 + resolve-from: 5.0.0 + + '@istanbuljs/schema@0.1.3': {} + + '@jest/console@30.0.5': + dependencies: + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + chalk: 4.1.2 + jest-message-util: 30.0.5 + jest-util: 30.0.5 + slash: 3.0.0 + + '@jest/core@30.0.5(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2))': + dependencies: + '@jest/console': 30.0.5 + '@jest/pattern': 30.0.1 + '@jest/reporters': 30.0.5 + '@jest/test-result': 30.0.5 + '@jest/transform': 30.0.5 + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + ansi-escapes: 4.3.2 + chalk: 4.1.2 + ci-info: 4.3.0 + exit-x: 0.2.2 + graceful-fs: 4.2.11 + jest-changed-files: 30.0.5 + jest-config: 30.0.5(@types/node@20.17.19)(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)) + jest-haste-map: 30.0.5 + jest-message-util: 30.0.5 + jest-regex-util: 30.0.1 + jest-resolve: 30.0.5 + jest-resolve-dependencies: 30.0.5 + jest-runner: 30.0.5 + jest-runtime: 30.0.5 + jest-snapshot: 30.0.5 + jest-util: 30.0.5 + jest-validate: 30.0.5 + jest-watcher: 30.0.5 + micromatch: 4.0.8 + pretty-format: 30.0.5 + slash: 3.0.0 + transitivePeerDependencies: + - babel-plugin-macros + - esbuild-register + - supports-color + - ts-node + + '@jest/diff-sequences@30.0.1': {} + + '@jest/environment@30.0.5': + dependencies: + '@jest/fake-timers': 30.0.5 + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + jest-mock: 30.0.5 + + '@jest/expect-utils@30.0.5': + dependencies: + '@jest/get-type': 30.0.1 + + '@jest/expect@30.0.5': + dependencies: + expect: 30.0.5 + jest-snapshot: 30.0.5 + transitivePeerDependencies: + - supports-color + + '@jest/fake-timers@30.0.5': + dependencies: + '@jest/types': 30.0.5 + '@sinonjs/fake-timers': 13.0.5 + '@types/node': 20.17.19 + jest-message-util: 30.0.5 + jest-mock: 30.0.5 + jest-util: 30.0.5 + + '@jest/get-type@30.0.1': {} + + '@jest/globals@30.0.5': + dependencies: + '@jest/environment': 30.0.5 + '@jest/expect': 30.0.5 + '@jest/types': 30.0.5 + jest-mock: 30.0.5 + transitivePeerDependencies: + - supports-color + + '@jest/pattern@30.0.1': + dependencies: + '@types/node': 20.17.19 + jest-regex-util: 30.0.1 + + '@jest/reporters@30.0.5': + dependencies: + '@bcoe/v8-coverage': 0.2.3 + '@jest/console': 30.0.5 + '@jest/test-result': 30.0.5 + '@jest/transform': 30.0.5 + '@jest/types': 30.0.5 + '@jridgewell/trace-mapping': 0.3.29 + '@types/node': 20.17.19 + chalk: 4.1.2 + collect-v8-coverage: 1.0.2 + exit-x: 0.2.2 + glob: 10.4.5 + graceful-fs: 4.2.11 + istanbul-lib-coverage: 3.2.2 + istanbul-lib-instrument: 6.0.3 + istanbul-lib-report: 3.0.1 + istanbul-lib-source-maps: 5.0.6 + istanbul-reports: 3.1.7 + jest-message-util: 30.0.5 + jest-util: 30.0.5 + jest-worker: 30.0.5 + slash: 3.0.0 + string-length: 4.0.2 + v8-to-istanbul: 9.3.0 + transitivePeerDependencies: + - supports-color + + '@jest/schemas@30.0.5': + dependencies: + '@sinclair/typebox': 0.34.38 + + '@jest/snapshot-utils@30.0.5': + dependencies: + '@jest/types': 30.0.5 + chalk: 4.1.2 + graceful-fs: 4.2.11 + natural-compare: 1.4.0 + + '@jest/source-map@30.0.1': + dependencies: + '@jridgewell/trace-mapping': 0.3.29 + callsites: 3.1.0 + graceful-fs: 4.2.11 + + '@jest/test-result@30.0.5': + dependencies: + '@jest/console': 30.0.5 + '@jest/types': 30.0.5 + '@types/istanbul-lib-coverage': 2.0.6 + collect-v8-coverage: 1.0.2 + + '@jest/test-sequencer@30.0.5': + dependencies: + '@jest/test-result': 30.0.5 + graceful-fs: 4.2.11 + jest-haste-map: 30.0.5 + slash: 3.0.0 + + '@jest/transform@30.0.5': + dependencies: + '@babel/core': 7.28.0 + '@jest/types': 30.0.5 + '@jridgewell/trace-mapping': 0.3.29 + babel-plugin-istanbul: 7.0.0 + chalk: 4.1.2 + convert-source-map: 2.0.0 + fast-json-stable-stringify: 2.1.0 + graceful-fs: 4.2.11 + jest-haste-map: 30.0.5 + jest-regex-util: 30.0.1 + jest-util: 30.0.5 + micromatch: 4.0.8 + pirates: 4.0.7 + slash: 3.0.0 + write-file-atomic: 5.0.1 + transitivePeerDependencies: + - supports-color + + '@jest/types@30.0.5': + dependencies: + '@jest/pattern': 30.0.1 + '@jest/schemas': 30.0.5 + '@types/istanbul-lib-coverage': 2.0.6 + '@types/istanbul-reports': 3.0.4 + '@types/node': 20.17.19 + '@types/yargs': 17.0.33 + chalk: 4.1.2 + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) '@jridgewell/gen-mapping@0.3.12': dependencies: '@jridgewell/sourcemap-codec': 1.5.0 @@ -5933,6 +7566,13 @@ snapshots: dependencies: '@bufbuild/protobuf': 1.10.1 + '@napi-rs/wasm-runtime@0.2.12': + dependencies: + '@emnapi/core': 1.4.5 + '@emnapi/runtime': 1.4.5 + '@tybys/wasm-util': 0.10.0 + optional: true + '@next/env@15.2.3': {} '@next/eslint-plugin-next@15.1.7': @@ -6026,6 +7666,11 @@ snapshots: '@pkgjs/parseargs@0.11.0': optional: true +<<<<<<< HEAD +======= + '@pkgr/core@0.2.9': {} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) '@radix-ui/number@1.1.1': {} '@radix-ui/primitive@1.1.2': {} @@ -6053,9 +7698,18 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) - '@radix-ui/react-avatar@1.1.10(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': + '@radix-ui/react-arrow@1.1.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': dependencies: - '@radix-ui/react-context': 1.1.2(@types/react@19.0.10)(react@19.0.0) + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + + '@radix-ui/react-avatar@1.1.10(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': + dependencies: + '@radix-ui/react-context': 1.1.2(@types/react@19.0.10)(react@19.0.0) '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0) '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.0.10)(react@19.0.0) '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.0.10)(react@19.0.0) @@ -6110,6 +7764,18 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-collection@1.1.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-context': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-slot': 1.2.3(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-compose-refs@1.1.1(@types/react@19.0.10)(react@19.0.0)': dependencies: react: 19.0.0 @@ -6122,12 +7788,24 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-compose-refs@1.1.2(@types/react@19.1.9)(react@19.1.1)': + dependencies: + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-context@1.1.2(@types/react@19.0.10)(react@19.0.0)': dependencies: react: 19.0.0 optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-context@1.1.2(@types/react@19.1.9)(react@19.1.1)': + dependencies: + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-dialog@1.1.14(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/primitive': 1.1.2 @@ -6156,6 +7834,12 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-direction@1.1.1(@types/react@19.1.9)(react@19.1.1)': + dependencies: + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-dismissable-layer@1.1.10(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/primitive': 1.1.2 @@ -6169,6 +7853,19 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-dismissable-layer@1.1.10(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/primitive': 1.1.2 + '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-escape-keydown': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-dropdown-menu@2.1.15(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/primitive': 1.1.2 @@ -6190,6 +7887,12 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-focus-guards@1.1.2(@types/react@19.1.9)(react@19.1.1)': + dependencies: + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-focus-scope@1.1.7(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.0.10)(react@19.0.0) @@ -6201,6 +7904,17 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-focus-scope@1.1.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-id@1.1.1(@types/react@19.0.10)(react@19.0.0)': dependencies: '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.0.10)(react@19.0.0) @@ -6208,6 +7922,13 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-id@1.1.1(@types/react@19.1.9)(react@19.1.1)': + dependencies: + '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-label@2.1.7(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0) @@ -6261,6 +7982,24 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-popper@1.2.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@floating-ui/react-dom': 2.1.4(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-arrow': 1.1.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-context': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-rect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-size': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/rect': 1.1.1 + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-portal@1.1.9(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0) @@ -6271,6 +8010,16 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-portal@1.1.9(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-presence@1.1.4(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.0.10)(react@19.0.0) @@ -6281,6 +8030,16 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-presence@1.1.4(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-primitive@2.1.3(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/react-slot': 1.2.3(@types/react@19.0.10)(react@19.0.0) @@ -6290,6 +8049,15 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-primitive@2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/react-slot': 1.2.3(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-roving-focus@1.1.10(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/primitive': 1.1.2 @@ -6307,6 +8075,23 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-roving-focus@1.1.10(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/primitive': 1.1.2 + '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-context': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-direction': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-id': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-scroll-area@1.2.9(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/number': 1.1.1 @@ -6353,6 +8138,35 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-select@2.2.5(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/number': 1.1.1 + '@radix-ui/primitive': 1.1.2 + '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-context': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-direction': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-dismissable-layer': 1.1.10(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-focus-guards': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-id': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-popper': 1.2.7(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-slot': 1.2.3(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-previous': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + aria-hidden: 1.2.6 + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + react-remove-scroll: 2.7.1(@types/react@19.1.9)(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-separator@1.1.7(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0) @@ -6376,6 +8190,13 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-slot@1.2.3(@types/react@19.1.9)(react@19.1.1)': + dependencies: + '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-tabs@1.1.12(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/primitive': 1.1.2 @@ -6392,6 +8213,22 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-tabs@1.1.12(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/primitive': 1.1.2 + '@radix-ui/react-context': 1.1.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-direction': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-id': 1.1.1(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-presence': 1.1.4(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-roving-focus': 1.1.10(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/react-tooltip@1.2.7(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/primitive': 1.1.2 @@ -6418,6 +8255,12 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-use-callback-ref@1.1.1(@types/react@19.1.9)(react@19.1.1)': + dependencies: + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-use-controllable-state@1.2.2(@types/react@19.0.10)(react@19.0.0)': dependencies: '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.0.10)(react@19.0.0) @@ -6426,6 +8269,14 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-use-controllable-state@1.2.2(@types/react@19.1.9)(react@19.1.1)': + dependencies: + '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.1.9)(react@19.1.1) + '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-use-effect-event@0.0.2(@types/react@19.0.10)(react@19.0.0)': dependencies: '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.0.10)(react@19.0.0) @@ -6433,6 +8284,13 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-use-effect-event@0.0.2(@types/react@19.1.9)(react@19.1.1)': + dependencies: + '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-use-escape-keydown@1.1.1(@types/react@19.0.10)(react@19.0.0)': dependencies: '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.0.10)(react@19.0.0) @@ -6440,6 +8298,13 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-use-escape-keydown@1.1.1(@types/react@19.1.9)(react@19.1.1)': + dependencies: + '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-use-is-hydrated@0.1.0(@types/react@19.0.10)(react@19.0.0)': dependencies: react: 19.0.0 @@ -6453,12 +8318,24 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-use-layout-effect@1.1.1(@types/react@19.1.9)(react@19.1.1)': + dependencies: + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-use-previous@1.1.1(@types/react@19.0.10)(react@19.0.0)': dependencies: react: 19.0.0 optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-use-previous@1.1.1(@types/react@19.1.9)(react@19.1.1)': + dependencies: + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-use-rect@1.1.1(@types/react@19.0.10)(react@19.0.0)': dependencies: '@radix-ui/rect': 1.1.1 @@ -6466,6 +8343,13 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-use-rect@1.1.1(@types/react@19.1.9)(react@19.1.1)': + dependencies: + '@radix-ui/rect': 1.1.1 + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-use-size@1.1.1(@types/react@19.0.10)(react@19.0.0)': dependencies: '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.0.10)(react@19.0.0) @@ -6473,6 +8357,13 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + '@radix-ui/react-use-size@1.1.1(@types/react@19.1.9)(react@19.1.1)': + dependencies: + '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.1.9)(react@19.1.1) + react: 19.1.1 + optionalDependencies: + '@types/react': 19.1.9 + '@radix-ui/react-visually-hidden@1.2.3(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': dependencies: '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.0.4(@types/react@19.0.10))(@types/react@19.0.10)(react-dom@19.0.0(react@19.0.0))(react@19.0.0) @@ -6482,16 +8373,26 @@ snapshots: '@types/react': 19.0.10 '@types/react-dom': 19.0.4(@types/react@19.0.10) + '@radix-ui/react-visually-hidden@1.2.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': + dependencies: + '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.1.7(@types/react@19.1.9))(@types/react@19.1.9)(react-dom@19.1.1(react@19.1.1))(react@19.1.1) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + '@types/react-dom': 19.1.7(@types/react@19.1.9) + '@radix-ui/rect@1.1.1': {} - '@react-email/render@1.1.2(react-dom@19.0.0(react@19.0.0))(react@19.0.0)': + '@react-email/render@1.1.2(react-dom@19.1.1(react@19.1.1))(react@19.1.1)': dependencies: html-to-text: 9.0.5 prettier: 3.6.0 - react: 19.0.0 - react-dom: 19.0.0(react@19.0.0) + react: 19.1.1 + react-dom: 19.1.1(react@19.1.1) react-promise-suspense: 0.3.4 +<<<<<<< HEAD '@rollup/rollup-android-arm-eabi@4.46.1': optional: true @@ -6550,6 +8451,66 @@ snapshots: optional: true '@rollup/rollup-win32-x64-msvc@4.46.1': +======= + '@rollup/rollup-android-arm-eabi@4.46.2': + optional: true + + '@rollup/rollup-android-arm64@4.46.2': + optional: true + + '@rollup/rollup-darwin-arm64@4.46.2': + optional: true + + '@rollup/rollup-darwin-x64@4.46.2': + optional: true + + '@rollup/rollup-freebsd-arm64@4.46.2': + optional: true + + '@rollup/rollup-freebsd-x64@4.46.2': + optional: true + + '@rollup/rollup-linux-arm-gnueabihf@4.46.2': + optional: true + + '@rollup/rollup-linux-arm-musleabihf@4.46.2': + optional: true + + '@rollup/rollup-linux-arm64-gnu@4.46.2': + optional: true + + '@rollup/rollup-linux-arm64-musl@4.46.2': + optional: true + + '@rollup/rollup-linux-loongarch64-gnu@4.46.2': + optional: true + + '@rollup/rollup-linux-ppc64-gnu@4.46.2': + optional: true + + '@rollup/rollup-linux-riscv64-gnu@4.46.2': + optional: true + + '@rollup/rollup-linux-riscv64-musl@4.46.2': + optional: true + + '@rollup/rollup-linux-s390x-gnu@4.46.2': + optional: true + + '@rollup/rollup-linux-x64-gnu@4.46.2': + optional: true + + '@rollup/rollup-linux-x64-musl@4.46.2': + optional: true + + '@rollup/rollup-win32-arm64-msvc@4.46.2': + optional: true + + '@rollup/rollup-win32-ia32-msvc@4.46.2': + optional: true + + '@rollup/rollup-win32-x64-msvc@4.46.2': +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) optional: true '@selderee/plugin-htmlparser2@0.11.0': @@ -6580,6 +8541,16 @@ snapshots: '@peculiar/asn1-schema': 2.3.15 '@peculiar/asn1-x509': 2.3.15 + '@sinclair/typebox@0.34.38': {} + + '@sinonjs/commons@3.0.1': + dependencies: + type-detect: 4.0.8 + + '@sinonjs/fake-timers@13.0.5': + dependencies: + '@sinonjs/commons': 3.0.1 + '@socket.io/component-emitter@3.1.2': {} '@standard-schema/utils@0.3.0': {} @@ -6758,6 +8729,32 @@ snapshots: semver: 7.6.2 update-check: 1.5.4 + '@tybys/wasm-util@0.10.0': + dependencies: + tslib: 2.8.1 + optional: true + + '@types/babel__core@7.20.5': + dependencies: + '@babel/parser': 7.28.0 + '@babel/types': 7.28.2 + '@types/babel__generator': 7.27.0 + '@types/babel__template': 7.4.4 + '@types/babel__traverse': 7.28.0 + + '@types/babel__generator@7.27.0': + dependencies: + '@babel/types': 7.28.2 + + '@types/babel__template@7.4.4': + dependencies: + '@babel/parser': 7.28.0 + '@babel/types': 7.28.2 + + '@types/babel__traverse@7.28.0': + dependencies: + '@babel/types': 7.28.2 + '@types/canvas-confetti@1.9.0': {} '@types/conventional-commits-parser@5.0.1': @@ -6788,6 +8785,16 @@ snapshots: '@types/through': 0.0.33 rxjs: 6.6.7 + '@types/istanbul-lib-coverage@2.0.6': {} + + '@types/istanbul-lib-report@3.0.3': + dependencies: + '@types/istanbul-lib-coverage': 2.0.6 + + '@types/istanbul-reports@3.0.4': + dependencies: + '@types/istanbul-lib-report': 3.0.3 + '@types/json-schema@7.0.15': {} '@types/minimatch@5.1.2': {} @@ -6815,10 +8822,20 @@ snapshots: dependencies: '@types/react': 19.0.10 + '@types/react-dom@19.1.7(@types/react@19.1.9)': + dependencies: + '@types/react': 19.1.9 + '@types/react@19.0.10': dependencies: csstype: 3.1.3 + '@types/react@19.1.9': + dependencies: + csstype: 3.1.3 + + '@types/stack-utils@2.0.3': {} + '@types/through@0.0.33': dependencies: '@types/node': 20.17.19 @@ -6829,6 +8846,12 @@ snapshots: dependencies: '@types/node': 20.17.19 + '@types/yargs-parser@21.0.3': {} + + '@types/yargs@17.0.33': + dependencies: + '@types/yargs-parser': 21.0.3 + '@typescript-eslint/eslint-plugin@8.24.1(@typescript-eslint/parser@8.24.1(eslint@9.20.1(jiti@2.4.2))(typescript@5.7.3))(eslint@9.20.1(jiti@2.4.2))(typescript@5.7.3)': dependencies: '@eslint-community/regexpp': 4.12.1 @@ -6846,6 +8869,23 @@ snapshots: transitivePeerDependencies: - supports-color + '@typescript-eslint/eslint-plugin@8.38.0(@typescript-eslint/parser@8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2))(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2)': + dependencies: + '@eslint-community/regexpp': 4.12.1 + '@typescript-eslint/parser': 8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2) + '@typescript-eslint/scope-manager': 8.38.0 + '@typescript-eslint/type-utils': 8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2) + '@typescript-eslint/utils': 8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2) + '@typescript-eslint/visitor-keys': 8.38.0 + eslint: 9.32.0(jiti@2.4.2) + graphemer: 1.4.0 + ignore: 7.0.5 + natural-compare: 1.4.0 + ts-api-utils: 2.1.0(typescript@5.9.2) + typescript: 5.9.2 + transitivePeerDependencies: + - supports-color + '@typescript-eslint/parser@8.24.1(eslint@9.20.1(jiti@2.4.2))(typescript@5.7.3)': dependencies: '@typescript-eslint/scope-manager': 8.24.1 @@ -6858,11 +8898,41 @@ snapshots: transitivePeerDependencies: - supports-color + '@typescript-eslint/parser@8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2)': + dependencies: + '@typescript-eslint/scope-manager': 8.38.0 + '@typescript-eslint/types': 8.38.0 + '@typescript-eslint/typescript-estree': 8.38.0(typescript@5.9.2) + '@typescript-eslint/visitor-keys': 8.38.0 + debug: 4.4.1 + eslint: 9.32.0(jiti@2.4.2) + typescript: 5.9.2 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/project-service@8.38.0(typescript@5.9.2)': + dependencies: + '@typescript-eslint/tsconfig-utils': 8.38.0(typescript@5.9.2) + '@typescript-eslint/types': 8.38.0 + debug: 4.4.1 + typescript: 5.9.2 + transitivePeerDependencies: + - supports-color + '@typescript-eslint/scope-manager@8.24.1': dependencies: '@typescript-eslint/types': 8.24.1 '@typescript-eslint/visitor-keys': 8.24.1 + '@typescript-eslint/scope-manager@8.38.0': + dependencies: + '@typescript-eslint/types': 8.38.0 + '@typescript-eslint/visitor-keys': 8.38.0 + + '@typescript-eslint/tsconfig-utils@8.38.0(typescript@5.9.2)': + dependencies: + typescript: 5.9.2 + '@typescript-eslint/type-utils@8.24.1(eslint@9.20.1(jiti@2.4.2))(typescript@5.7.3)': dependencies: '@typescript-eslint/typescript-estree': 8.24.1(typescript@5.7.3) @@ -6874,37 +8944,144 @@ snapshots: transitivePeerDependencies: - supports-color - '@typescript-eslint/types@8.24.1': {} + '@typescript-eslint/type-utils@8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2)': + dependencies: + '@typescript-eslint/types': 8.38.0 + '@typescript-eslint/typescript-estree': 8.38.0(typescript@5.9.2) + '@typescript-eslint/utils': 8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2) + debug: 4.4.1 + eslint: 9.32.0(jiti@2.4.2) + ts-api-utils: 2.1.0(typescript@5.9.2) + typescript: 5.9.2 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/types@8.24.1': {} + + '@typescript-eslint/types@8.38.0': {} + + '@typescript-eslint/typescript-estree@8.24.1(typescript@5.7.3)': + dependencies: + '@typescript-eslint/types': 8.24.1 + '@typescript-eslint/visitor-keys': 8.24.1 + debug: 4.4.1 + fast-glob: 3.3.3 + is-glob: 4.0.3 + minimatch: 9.0.5 + semver: 7.7.1 + ts-api-utils: 2.0.1(typescript@5.7.3) + typescript: 5.7.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/typescript-estree@8.38.0(typescript@5.9.2)': + dependencies: + '@typescript-eslint/project-service': 8.38.0(typescript@5.9.2) + '@typescript-eslint/tsconfig-utils': 8.38.0(typescript@5.9.2) + '@typescript-eslint/types': 8.38.0 + '@typescript-eslint/visitor-keys': 8.38.0 + debug: 4.4.1 + fast-glob: 3.3.3 + is-glob: 4.0.3 + minimatch: 9.0.5 + semver: 7.7.1 + ts-api-utils: 2.1.0(typescript@5.9.2) + typescript: 5.9.2 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/utils@8.24.1(eslint@9.20.1(jiti@2.4.2))(typescript@5.7.3)': + dependencies: + '@eslint-community/eslint-utils': 4.4.1(eslint@9.20.1(jiti@2.4.2)) + '@typescript-eslint/scope-manager': 8.24.1 + '@typescript-eslint/types': 8.24.1 + '@typescript-eslint/typescript-estree': 8.24.1(typescript@5.7.3) + eslint: 9.20.1(jiti@2.4.2) + typescript: 5.7.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/utils@8.38.0(eslint@9.32.0(jiti@2.4.2))(typescript@5.9.2)': + dependencies: + '@eslint-community/eslint-utils': 4.7.0(eslint@9.32.0(jiti@2.4.2)) + '@typescript-eslint/scope-manager': 8.38.0 + '@typescript-eslint/types': 8.38.0 + '@typescript-eslint/typescript-estree': 8.38.0(typescript@5.9.2) + eslint: 9.32.0(jiti@2.4.2) + typescript: 5.9.2 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/visitor-keys@8.24.1': + dependencies: + '@typescript-eslint/types': 8.24.1 + eslint-visitor-keys: 4.2.0 + + '@typescript-eslint/visitor-keys@8.38.0': + dependencies: + '@typescript-eslint/types': 8.38.0 + eslint-visitor-keys: 4.2.1 + + '@ungap/structured-clone@1.3.0': {} + + '@unrs/resolver-binding-android-arm-eabi@1.11.1': + optional: true + + '@unrs/resolver-binding-android-arm64@1.11.1': + optional: true + + '@unrs/resolver-binding-darwin-arm64@1.11.1': + optional: true + + '@unrs/resolver-binding-darwin-x64@1.11.1': + optional: true + + '@unrs/resolver-binding-freebsd-x64@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-arm-gnueabihf@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-arm-musleabihf@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-arm64-gnu@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-arm64-musl@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-ppc64-gnu@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-riscv64-gnu@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-riscv64-musl@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-s390x-gnu@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-x64-gnu@1.11.1': + optional: true + + '@unrs/resolver-binding-linux-x64-musl@1.11.1': + optional: true - '@typescript-eslint/typescript-estree@8.24.1(typescript@5.7.3)': + '@unrs/resolver-binding-wasm32-wasi@1.11.1': dependencies: - '@typescript-eslint/types': 8.24.1 - '@typescript-eslint/visitor-keys': 8.24.1 - debug: 4.4.1 - fast-glob: 3.3.3 - is-glob: 4.0.3 - minimatch: 9.0.5 - semver: 7.7.1 - ts-api-utils: 2.0.1(typescript@5.7.3) - typescript: 5.7.3 - transitivePeerDependencies: - - supports-color + '@napi-rs/wasm-runtime': 0.2.12 + optional: true - '@typescript-eslint/utils@8.24.1(eslint@9.20.1(jiti@2.4.2))(typescript@5.7.3)': - dependencies: - '@eslint-community/eslint-utils': 4.4.1(eslint@9.20.1(jiti@2.4.2)) - '@typescript-eslint/scope-manager': 8.24.1 - '@typescript-eslint/types': 8.24.1 - '@typescript-eslint/typescript-estree': 8.24.1(typescript@5.7.3) - eslint: 9.20.1(jiti@2.4.2) - typescript: 5.7.3 - transitivePeerDependencies: - - supports-color + '@unrs/resolver-binding-win32-arm64-msvc@1.11.1': + optional: true - '@typescript-eslint/visitor-keys@8.24.1': - dependencies: - '@typescript-eslint/types': 8.24.1 - eslint-visitor-keys: 4.2.0 + '@unrs/resolver-binding-win32-ia32-msvc@1.11.1': + optional: true + + '@unrs/resolver-binding-win32-x64-msvc@1.11.1': + optional: true JSONStream@1.3.5: dependencies: @@ -6915,12 +9092,18 @@ snapshots: dependencies: acorn: 8.14.0 + acorn-jsx@5.3.2(acorn@8.15.0): + dependencies: + acorn: 8.15.0 + acorn-walk@8.3.4: dependencies: acorn: 8.14.0 acorn@8.14.0: {} + acorn@8.15.0: {} + agent-base@7.1.3: {} aggregate-error@3.1.0: @@ -6962,6 +9145,8 @@ snapshots: dependencies: color-convert: 2.0.1 + ansi-styles@5.2.0: {} + ansi-styles@6.2.1: {} any-promise@1.3.0: {} @@ -6973,6 +9158,10 @@ snapshots: arg@4.1.3: {} + argparse@1.0.10: + dependencies: + sprintf-js: 1.0.3 + argparse@2.0.1: {} aria-hidden@1.2.6: @@ -7070,6 +9259,60 @@ snapshots: transitivePeerDependencies: - debug + babel-jest@30.0.5(@babel/core@7.28.0): + dependencies: + '@babel/core': 7.28.0 + '@jest/transform': 30.0.5 + '@types/babel__core': 7.20.5 + babel-plugin-istanbul: 7.0.0 + babel-preset-jest: 30.0.1(@babel/core@7.28.0) + chalk: 4.1.2 + graceful-fs: 4.2.11 + slash: 3.0.0 + transitivePeerDependencies: + - supports-color + + babel-plugin-istanbul@7.0.0: + dependencies: + '@babel/helper-plugin-utils': 7.27.1 + '@istanbuljs/load-nyc-config': 1.1.0 + '@istanbuljs/schema': 0.1.3 + istanbul-lib-instrument: 6.0.3 + test-exclude: 6.0.0 + transitivePeerDependencies: + - supports-color + + babel-plugin-jest-hoist@30.0.1: + dependencies: + '@babel/template': 7.27.2 + '@babel/types': 7.28.2 + '@types/babel__core': 7.20.5 + + babel-preset-current-node-syntax@1.2.0(@babel/core@7.28.0): + dependencies: + '@babel/core': 7.28.0 + '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.28.0) + '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.28.0) + '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.28.0) + '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.28.0) + '@babel/plugin-syntax-import-attributes': 7.27.1(@babel/core@7.28.0) + '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.28.0) + '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.28.0) + '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.28.0) + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.28.0) + '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.28.0) + '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.28.0) + '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.28.0) + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.28.0) + '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.28.0) + '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.28.0) + + babel-preset-jest@30.0.1(@babel/core@7.28.0): + dependencies: + '@babel/core': 7.28.0 + babel-plugin-jest-hoist: 30.0.1 + babel-preset-current-node-syntax: 1.2.0(@babel/core@7.28.0) + balanced-match@1.0.2: {} base64-js@1.5.1: {} @@ -7125,6 +9368,17 @@ snapshots: dependencies: fill-range: 7.1.1 + browserslist@4.25.1: + dependencies: + caniuse-lite: 1.0.30001731 + electron-to-chromium: 1.5.194 + node-releases: 2.0.19 + update-browserslist-db: 1.1.3(browserslist@4.25.1) + + bser@2.1.1: + dependencies: + node-int64: 0.4.0 + buffer-from@1.1.2: {} buffer@5.7.1: @@ -7179,10 +9433,16 @@ snapshots: quick-lru: 6.1.2 type-fest: 4.41.0 + camelcase@5.3.1: {} + + camelcase@6.3.0: {} + camelcase@8.0.0: {} caniuse-lite@1.0.30001707: {} + caniuse-lite@1.0.30001731: {} + canvas-confetti@1.9.3: {} chalk@2.4.2: @@ -7226,6 +9486,8 @@ snapshots: upper-case: 1.1.3 upper-case-first: 1.1.2 + char-regex@1.0.2: {} + chardet@0.7.0: {} chokidar@3.6.0: @@ -7246,6 +9508,10 @@ snapshots: chownr@3.0.0: {} + ci-info@4.3.0: {} + + cjs-module-lexer@2.1.0: {} + class-variance-authority@0.7.1: dependencies: clsx: 2.1.1 @@ -7287,6 +9553,10 @@ snapshots: cluster-key-slot@1.1.2: {} + co@4.6.0: {} + + collect-v8-coverage@1.0.2: {} + color-convert@1.9.3: dependencies: color-name: 1.1.3 @@ -7354,6 +9624,8 @@ snapshots: meow: 12.1.1 split2: 4.2.0 + convert-source-map@2.0.0: {} + core-js-pure@3.40.0: {} cosmiconfig-typescript-loader@6.1.0(@types/node@20.17.19)(cosmiconfig@9.0.0(typescript@5.7.3))(typescript@5.7.3): @@ -7432,6 +9704,8 @@ snapshots: optionalDependencies: supports-color: 5.5.0 + dedent@1.6.0: {} + deep-extend@0.6.0: {} deep-is@0.1.4: {} @@ -7484,6 +9758,8 @@ snapshots: detect-libc@2.0.3: optional: true + detect-newline@3.1.0: {} + detect-node-es@1.1.0: {} diff@4.0.2: {} @@ -7559,6 +9835,13 @@ snapshots: eastasianwidth@0.2.0: {} +<<<<<<< HEAD +======= + electron-to-chromium@1.5.194: {} + + emittery@0.13.1: {} + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) emoji-regex@10.4.0: {} emoji-regex@8.0.0: {} @@ -7756,6 +10039,8 @@ snapshots: escape-string-regexp@1.0.5: {} + escape-string-regexp@2.0.0: {} + escape-string-regexp@4.0.0: {} escodegen@2.1.0: @@ -7766,12 +10051,25 @@ snapshots: optionalDependencies: source-map: 0.6.1 + eslint-config-prettier@10.1.8(eslint@9.32.0(jiti@2.4.2)): + dependencies: + eslint: 9.32.0(jiti@2.4.2) + eslint-config-prettier@9.1.0(eslint@9.20.1(jiti@2.4.2)): dependencies: eslint: 9.20.1(jiti@2.4.2) eslint-plugin-only-warn@1.1.0: {} + eslint-plugin-prettier@5.5.3(eslint-config-prettier@10.1.8(eslint@9.32.0(jiti@2.4.2)))(eslint@9.32.0(jiti@2.4.2))(prettier@3.6.2): + dependencies: + eslint: 9.32.0(jiti@2.4.2) + prettier: 3.6.2 + prettier-linter-helpers: 1.0.0 + synckit: 0.11.11 + optionalDependencies: + eslint-config-prettier: 10.1.8(eslint@9.32.0(jiti@2.4.2)) + eslint-plugin-react-hooks@5.1.0(eslint@9.20.1(jiti@2.4.2)): dependencies: eslint: 9.20.1(jiti@2.4.2) @@ -7809,10 +10107,17 @@ snapshots: esrecurse: 4.3.0 estraverse: 5.3.0 + eslint-scope@8.4.0: + dependencies: + esrecurse: 4.3.0 + estraverse: 5.3.0 + eslint-visitor-keys@3.4.3: {} eslint-visitor-keys@4.2.0: {} + eslint-visitor-keys@4.2.1: {} + eslint@9.20.1(jiti@2.4.2): dependencies: '@eslint-community/eslint-utils': 4.4.1(eslint@9.20.1(jiti@2.4.2)) @@ -7854,6 +10159,48 @@ snapshots: transitivePeerDependencies: - supports-color + eslint@9.32.0(jiti@2.4.2): + dependencies: + '@eslint-community/eslint-utils': 4.4.1(eslint@9.32.0(jiti@2.4.2)) + '@eslint-community/regexpp': 4.12.1 + '@eslint/config-array': 0.21.0 + '@eslint/config-helpers': 0.3.0 + '@eslint/core': 0.15.1 + '@eslint/eslintrc': 3.3.1 + '@eslint/js': 9.32.0 + '@eslint/plugin-kit': 0.3.4 + '@humanfs/node': 0.16.6 + '@humanwhocodes/module-importer': 1.0.1 + '@humanwhocodes/retry': 0.4.2 + '@types/estree': 1.0.8 + '@types/json-schema': 7.0.15 + ajv: 6.12.6 + chalk: 4.1.2 + cross-spawn: 7.0.6 + debug: 4.4.1 + escape-string-regexp: 4.0.0 + eslint-scope: 8.4.0 + eslint-visitor-keys: 4.2.1 + espree: 10.4.0 + esquery: 1.6.0 + esutils: 2.0.3 + fast-deep-equal: 3.1.3 + file-entry-cache: 8.0.0 + find-up: 5.0.0 + glob-parent: 6.0.2 + ignore: 5.3.2 + imurmurhash: 0.1.4 + is-glob: 4.0.3 + json-stable-stringify-without-jsonify: 1.0.1 + lodash.merge: 4.6.2 + minimatch: 3.1.2 + natural-compare: 1.4.0 + optionator: 0.9.4 + optionalDependencies: + jiti: 2.4.2 + transitivePeerDependencies: + - supports-color + esm-env@1.2.2: {} espree@10.3.0: @@ -7862,6 +10209,12 @@ snapshots: acorn-jsx: 5.3.2(acorn@8.14.0) eslint-visitor-keys: 4.2.0 + espree@10.4.0: + dependencies: + acorn: 8.15.0 + acorn-jsx: 5.3.2(acorn@8.15.0) + eslint-visitor-keys: 4.2.1 + esprima@4.0.1: {} esquery@1.6.0: @@ -7904,6 +10257,17 @@ snapshots: signal-exit: 3.0.7 strip-final-newline: 3.0.0 + exit-x@0.2.2: {} + + expect@30.0.5: + dependencies: + '@jest/expect-utils': 30.0.5 + '@jest/get-type': 30.0.1 + jest-matcher-utils: 30.0.5 + jest-message-util: 30.0.5 + jest-mock: 30.0.5 + jest-util: 30.0.5 + external-editor@3.1.0: dependencies: chardet: 0.7.0 @@ -7918,6 +10282,8 @@ snapshots: fast-deep-equal@3.1.3: {} + fast-diff@1.3.0: {} + fast-glob@3.3.1: dependencies: '@nodelib/fs.stat': 2.0.5 @@ -7944,6 +10310,13 @@ snapshots: dependencies: reusify: 1.0.4 +<<<<<<< HEAD +======= + fb-watchman@2.0.2: + dependencies: + bser: 2.1.1 + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) fdir@6.4.6(picomatch@4.0.3): optionalDependencies: picomatch: 4.0.3 @@ -7965,6 +10338,11 @@ snapshots: dependencies: to-regex-range: 5.0.1 + find-up@4.1.0: + dependencies: + locate-path: 5.0.0 + path-exists: 4.0.0 + find-up@5.0.0: dependencies: locate-path: 6.0.0 @@ -7980,7 +10358,11 @@ snapshots: dependencies: magic-string: 0.30.17 mlly: 1.7.4 +<<<<<<< HEAD rollup: 4.46.1 +======= + rollup: 4.46.2 +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) flat-cache@4.0.1: dependencies: @@ -8053,6 +10435,8 @@ snapshots: functions-have-names@1.2.3: {} + gensync@1.0.0-beta.2: {} + get-caller-file@2.0.5: {} get-east-asian-width@1.3.0: {} @@ -8072,6 +10456,8 @@ snapshots: get-nonce@1.0.1: {} + get-package-type@0.1.0: {} + get-proto@1.0.1: dependencies: dunder-proto: 1.0.1 @@ -8210,6 +10596,8 @@ snapshots: hono@4.8.2: {} + html-escaper@2.0.2: {} + html-to-text@9.0.5: dependencies: '@selderee/plugin-htmlparser2': 0.11.0 @@ -8255,11 +10643,18 @@ snapshots: ignore@5.3.2: {} + ignore@7.0.5: {} + import-fresh@3.3.1: dependencies: parent-module: 1.0.1 resolve-from: 4.0.0 + import-local@3.2.0: + dependencies: + pkg-dir: 4.2.0 + resolve-cwd: 3.0.0 + import-meta-resolve@4.1.0: {} imurmurhash@0.1.4: {} @@ -8406,6 +10801,8 @@ snapshots: dependencies: get-east-asian-width: 1.3.0 + is-generator-fn@2.1.0: {} + is-generator-function@1.1.0: dependencies: call-bound: 1.0.3 @@ -8457,71 +10854,418 @@ snapshots: is-stream@2.0.1: {} - is-stream@3.0.0: {} + is-stream@3.0.0: {} + + is-string@1.1.1: + dependencies: + call-bound: 1.0.3 + has-tostringtag: 1.0.2 + + is-symbol@1.1.1: + dependencies: + call-bound: 1.0.3 + has-symbols: 1.1.0 + safe-regex-test: 1.1.0 + + is-text-path@2.0.0: + dependencies: + text-extensions: 2.4.0 + + is-typed-array@1.1.15: + dependencies: + which-typed-array: 1.1.18 + + is-unicode-supported@0.1.0: {} + + is-unicode-supported@1.3.0: {} + + is-upper-case@1.1.2: + dependencies: + upper-case: 1.1.3 + + is-weakmap@2.0.2: {} + + is-weakref@1.1.1: + dependencies: + call-bound: 1.0.3 + + is-weakset@2.0.4: + dependencies: + call-bound: 1.0.3 + get-intrinsic: 1.2.7 + + isarray@2.0.5: {} + + isbinaryfile@4.0.10: {} + + isexe@2.0.0: {} + + isows@1.0.7(ws@8.18.3): + dependencies: + ws: 8.18.3 + + istanbul-lib-coverage@3.2.2: {} + + istanbul-lib-instrument@6.0.3: + dependencies: + '@babel/core': 7.28.0 + '@babel/parser': 7.28.0 + '@istanbuljs/schema': 0.1.3 + istanbul-lib-coverage: 3.2.2 + semver: 7.7.1 + transitivePeerDependencies: + - supports-color + + istanbul-lib-report@3.0.1: + dependencies: + istanbul-lib-coverage: 3.2.2 + make-dir: 4.0.0 + supports-color: 7.2.0 + + istanbul-lib-source-maps@5.0.6: + dependencies: + '@jridgewell/trace-mapping': 0.3.29 + debug: 4.4.1 + istanbul-lib-coverage: 3.2.2 + transitivePeerDependencies: + - supports-color + + istanbul-reports@3.1.7: + dependencies: + html-escaper: 2.0.2 + istanbul-lib-report: 3.0.1 + + iterator.prototype@1.1.5: + dependencies: + define-data-property: 1.1.4 + es-object-atoms: 1.1.1 + get-intrinsic: 1.2.7 + get-proto: 1.0.1 + has-symbols: 1.1.0 + set-function-name: 2.0.2 + + jackspeak@3.4.3: + dependencies: + '@isaacs/cliui': 8.0.2 + optionalDependencies: + '@pkgjs/parseargs': 0.11.0 + +<<<<<<< HEAD +======= + jest-changed-files@30.0.5: + dependencies: + execa: 5.1.1 + jest-util: 30.0.5 + p-limit: 3.1.0 + + jest-circus@30.0.5: + dependencies: + '@jest/environment': 30.0.5 + '@jest/expect': 30.0.5 + '@jest/test-result': 30.0.5 + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + chalk: 4.1.2 + co: 4.6.0 + dedent: 1.6.0 + is-generator-fn: 2.1.0 + jest-each: 30.0.5 + jest-matcher-utils: 30.0.5 + jest-message-util: 30.0.5 + jest-runtime: 30.0.5 + jest-snapshot: 30.0.5 + jest-util: 30.0.5 + p-limit: 3.1.0 + pretty-format: 30.0.5 + pure-rand: 7.0.1 + slash: 3.0.0 + stack-utils: 2.0.6 + transitivePeerDependencies: + - babel-plugin-macros + - supports-color + + jest-cli@30.0.5(@types/node@20.17.19)(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)): + dependencies: + '@jest/core': 30.0.5(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)) + '@jest/test-result': 30.0.5 + '@jest/types': 30.0.5 + chalk: 4.1.2 + exit-x: 0.2.2 + import-local: 3.2.0 + jest-config: 30.0.5(@types/node@20.17.19)(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)) + jest-util: 30.0.5 + jest-validate: 30.0.5 + yargs: 17.7.2 + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - esbuild-register + - supports-color + - ts-node + + jest-config@30.0.5(@types/node@20.17.19)(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)): + dependencies: + '@babel/core': 7.28.0 + '@jest/get-type': 30.0.1 + '@jest/pattern': 30.0.1 + '@jest/test-sequencer': 30.0.5 + '@jest/types': 30.0.5 + babel-jest: 30.0.5(@babel/core@7.28.0) + chalk: 4.1.2 + ci-info: 4.3.0 + deepmerge: 4.3.1 + glob: 10.4.5 + graceful-fs: 4.2.11 + jest-circus: 30.0.5 + jest-docblock: 30.0.1 + jest-environment-node: 30.0.5 + jest-regex-util: 30.0.1 + jest-resolve: 30.0.5 + jest-runner: 30.0.5 + jest-util: 30.0.5 + jest-validate: 30.0.5 + micromatch: 4.0.8 + parse-json: 5.2.0 + pretty-format: 30.0.5 + slash: 3.0.0 + strip-json-comments: 3.1.1 + optionalDependencies: + '@types/node': 20.17.19 + esbuild-register: 3.6.0(esbuild@0.25.5) + ts-node: 10.9.2(@types/node@20.17.19)(typescript@5.9.2) + transitivePeerDependencies: + - babel-plugin-macros + - supports-color + + jest-diff@30.0.5: + dependencies: + '@jest/diff-sequences': 30.0.1 + '@jest/get-type': 30.0.1 + chalk: 4.1.2 + pretty-format: 30.0.5 + + jest-docblock@30.0.1: + dependencies: + detect-newline: 3.1.0 + + jest-each@30.0.5: + dependencies: + '@jest/get-type': 30.0.1 + '@jest/types': 30.0.5 + chalk: 4.1.2 + jest-util: 30.0.5 + pretty-format: 30.0.5 + + jest-environment-node@30.0.5: + dependencies: + '@jest/environment': 30.0.5 + '@jest/fake-timers': 30.0.5 + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + jest-mock: 30.0.5 + jest-util: 30.0.5 + jest-validate: 30.0.5 + + jest-haste-map@30.0.5: + dependencies: + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + anymatch: 3.1.3 + fb-watchman: 2.0.2 + graceful-fs: 4.2.11 + jest-regex-util: 30.0.1 + jest-util: 30.0.5 + jest-worker: 30.0.5 + micromatch: 4.0.8 + walker: 1.0.8 + optionalDependencies: + fsevents: 2.3.3 - is-string@1.1.1: + jest-leak-detector@30.0.5: dependencies: - call-bound: 1.0.3 - has-tostringtag: 1.0.2 + '@jest/get-type': 30.0.1 + pretty-format: 30.0.5 - is-symbol@1.1.1: + jest-matcher-utils@30.0.5: dependencies: - call-bound: 1.0.3 - has-symbols: 1.1.0 - safe-regex-test: 1.1.0 + '@jest/get-type': 30.0.1 + chalk: 4.1.2 + jest-diff: 30.0.5 + pretty-format: 30.0.5 - is-text-path@2.0.0: + jest-message-util@30.0.5: dependencies: - text-extensions: 2.4.0 + '@babel/code-frame': 7.27.1 + '@jest/types': 30.0.5 + '@types/stack-utils': 2.0.3 + chalk: 4.1.2 + graceful-fs: 4.2.11 + micromatch: 4.0.8 + pretty-format: 30.0.5 + slash: 3.0.0 + stack-utils: 2.0.6 - is-typed-array@1.1.15: + jest-mock@30.0.5: dependencies: - which-typed-array: 1.1.18 + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + jest-util: 30.0.5 - is-unicode-supported@0.1.0: {} + jest-pnp-resolver@1.2.3(jest-resolve@30.0.5): + optionalDependencies: + jest-resolve: 30.0.5 - is-unicode-supported@1.3.0: {} + jest-regex-util@30.0.1: {} - is-upper-case@1.1.2: + jest-resolve-dependencies@30.0.5: dependencies: - upper-case: 1.1.3 + jest-regex-util: 30.0.1 + jest-snapshot: 30.0.5 + transitivePeerDependencies: + - supports-color - is-weakmap@2.0.2: {} + jest-resolve@30.0.5: + dependencies: + chalk: 4.1.2 + graceful-fs: 4.2.11 + jest-haste-map: 30.0.5 + jest-pnp-resolver: 1.2.3(jest-resolve@30.0.5) + jest-util: 30.0.5 + jest-validate: 30.0.5 + slash: 3.0.0 + unrs-resolver: 1.11.1 - is-weakref@1.1.1: + jest-runner@30.0.5: dependencies: - call-bound: 1.0.3 + '@jest/console': 30.0.5 + '@jest/environment': 30.0.5 + '@jest/test-result': 30.0.5 + '@jest/transform': 30.0.5 + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + chalk: 4.1.2 + emittery: 0.13.1 + exit-x: 0.2.2 + graceful-fs: 4.2.11 + jest-docblock: 30.0.1 + jest-environment-node: 30.0.5 + jest-haste-map: 30.0.5 + jest-leak-detector: 30.0.5 + jest-message-util: 30.0.5 + jest-resolve: 30.0.5 + jest-runtime: 30.0.5 + jest-util: 30.0.5 + jest-watcher: 30.0.5 + jest-worker: 30.0.5 + p-limit: 3.1.0 + source-map-support: 0.5.13 + transitivePeerDependencies: + - supports-color - is-weakset@2.0.4: + jest-runtime@30.0.5: dependencies: - call-bound: 1.0.3 - get-intrinsic: 1.2.7 + '@jest/environment': 30.0.5 + '@jest/fake-timers': 30.0.5 + '@jest/globals': 30.0.5 + '@jest/source-map': 30.0.1 + '@jest/test-result': 30.0.5 + '@jest/transform': 30.0.5 + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + chalk: 4.1.2 + cjs-module-lexer: 2.1.0 + collect-v8-coverage: 1.0.2 + glob: 10.4.5 + graceful-fs: 4.2.11 + jest-haste-map: 30.0.5 + jest-message-util: 30.0.5 + jest-mock: 30.0.5 + jest-regex-util: 30.0.1 + jest-resolve: 30.0.5 + jest-snapshot: 30.0.5 + jest-util: 30.0.5 + slash: 3.0.0 + strip-bom: 4.0.0 + transitivePeerDependencies: + - supports-color - isarray@2.0.5: {} + jest-snapshot@30.0.5: + dependencies: + '@babel/core': 7.28.0 + '@babel/generator': 7.28.0 + '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.0) + '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.28.0) + '@babel/types': 7.28.2 + '@jest/expect-utils': 30.0.5 + '@jest/get-type': 30.0.1 + '@jest/snapshot-utils': 30.0.5 + '@jest/transform': 30.0.5 + '@jest/types': 30.0.5 + babel-preset-current-node-syntax: 1.2.0(@babel/core@7.28.0) + chalk: 4.1.2 + expect: 30.0.5 + graceful-fs: 4.2.11 + jest-diff: 30.0.5 + jest-matcher-utils: 30.0.5 + jest-message-util: 30.0.5 + jest-util: 30.0.5 + pretty-format: 30.0.5 + semver: 7.7.2 + synckit: 0.11.11 + transitivePeerDependencies: + - supports-color - isbinaryfile@4.0.10: {} + jest-util@30.0.5: + dependencies: + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + chalk: 4.1.2 + ci-info: 4.3.0 + graceful-fs: 4.2.11 + picomatch: 4.0.3 - isexe@2.0.0: {} + jest-validate@30.0.5: + dependencies: + '@jest/get-type': 30.0.1 + '@jest/types': 30.0.5 + camelcase: 6.3.0 + chalk: 4.1.2 + leven: 3.1.0 + pretty-format: 30.0.5 - isows@1.0.7(ws@8.18.3): + jest-watcher@30.0.5: dependencies: - ws: 8.18.3 + '@jest/test-result': 30.0.5 + '@jest/types': 30.0.5 + '@types/node': 20.17.19 + ansi-escapes: 4.3.2 + chalk: 4.1.2 + emittery: 0.13.1 + jest-util: 30.0.5 + string-length: 4.0.2 - iterator.prototype@1.1.5: + jest-worker@30.0.5: dependencies: - define-data-property: 1.1.4 - es-object-atoms: 1.1.1 - get-intrinsic: 1.2.7 - get-proto: 1.0.1 - has-symbols: 1.1.0 - set-function-name: 2.0.2 + '@types/node': 20.17.19 + '@ungap/structured-clone': 1.3.0 + jest-util: 30.0.5 + merge-stream: 2.0.0 + supports-color: 8.1.1 - jackspeak@3.4.3: + jest@30.0.5(@types/node@20.17.19)(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)): dependencies: - '@isaacs/cliui': 8.0.2 - optionalDependencies: - '@pkgjs/parseargs': 0.11.0 + '@jest/core': 30.0.5(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)) + '@jest/types': 30.0.5 + import-local: 3.2.0 + jest-cli: 30.0.5(@types/node@20.17.19)(esbuild-register@3.6.0(esbuild@0.25.5))(ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2)) + transitivePeerDependencies: + - '@types/node' + - babel-plugin-macros + - esbuild-register + - supports-color + - ts-node +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) jiti@2.4.2: {} jose@5.10.0: {} @@ -8530,12 +11274,19 @@ snapshots: js-tokens@4.0.0: {} + js-yaml@3.14.1: + dependencies: + argparse: 1.0.10 + esprima: 4.0.1 + js-yaml@4.1.0: dependencies: argparse: 2.0.1 jsbn@1.1.0: {} + jsesc@3.1.0: {} + json-buffer@3.0.1: {} json-parse-even-better-errors@2.3.1: {} @@ -8546,6 +11297,8 @@ snapshots: json-stable-stringify-without-jsonify@1.0.1: {} + json5@2.2.3: {} + jsonfile@6.1.0: dependencies: universalify: 2.0.1 @@ -8571,6 +11324,8 @@ snapshots: leac@0.6.0: {} + leven@3.1.0: {} + levn@0.4.1: dependencies: prelude-ls: 1.2.1 @@ -8671,6 +11426,13 @@ snapshots: load-tsconfig@0.2.5: {} +<<<<<<< HEAD +======= + locate-path@5.0.0: + dependencies: + p-locate: 4.1.0 + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) locate-path@6.0.0: dependencies: p-locate: 5.0.0 @@ -8747,6 +11509,13 @@ snapshots: lru-cache@10.4.3: {} +<<<<<<< HEAD +======= + lru-cache@5.1.1: + dependencies: + yallist: 3.1.1 + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) lru-cache@7.18.3: {} lucide-react@0.475.0(react@19.0.0): @@ -8757,8 +11526,19 @@ snapshots: dependencies: '@jridgewell/sourcemap-codec': 1.5.0 +<<<<<<< HEAD +======= + make-dir@4.0.0: + dependencies: + semver: 7.7.1 + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) make-error@1.3.6: {} + makeerror@1.0.12: + dependencies: + tmpl: 1.0.5 + map-obj@5.0.0: {} math-intrinsics@1.1.0: {} @@ -8778,6 +11558,21 @@ snapshots: transitivePeerDependencies: - encoding + mediasoup-client@3.14.0: + dependencies: + '@types/debug': 4.1.12 + '@types/events-alias': '@types/events@3.0.3' + awaitqueue: 3.2.2(supports-color@10.0.0) + debug: 4.4.1(supports-color@10.0.0) + events-alias: events@3.3.0 + fake-mediastreamtrack: 2.1.2 + h264-profile-level-id: 2.2.2(supports-color@10.0.0) + sdp-transform: 2.15.0 + supports-color: 10.0.0 + ua-parser-js: 2.0.4 + transitivePeerDependencies: + - encoding + mediasoup@3.16.7: dependencies: '@types/ini': 4.1.1 @@ -8873,6 +11668,8 @@ snapshots: nanostores@0.11.4: {} + napi-postinstall@0.3.2: {} + natural-compare@1.4.0: {} neo-async@2.6.2: {} @@ -8925,6 +11722,8 @@ snapshots: fetch-blob: 3.2.0 formdata-polyfill: 4.0.10 + node-int64@0.4.0: {} + node-plop@0.26.3: dependencies: '@babel/runtime-corejs3': 7.26.9 @@ -8939,6 +11738,8 @@ snapshots: mkdirp: 0.5.6 resolve: 1.22.10 + node-releases@2.0.19: {} + nodemon@3.1.10: dependencies: chokidar: 3.6.0 @@ -9069,6 +11870,10 @@ snapshots: object-keys: 1.1.1 safe-push-apply: 1.0.0 + p-limit@2.3.0: + dependencies: + p-try: 2.2.0 + p-limit@3.1.0: dependencies: yocto-queue: 0.1.0 @@ -9077,6 +11882,10 @@ snapshots: dependencies: yocto-queue: 1.2.1 + p-locate@4.1.0: + dependencies: + p-limit: 2.3.0 + p-locate@5.0.0: dependencies: p-limit: 3.1.0 @@ -9089,6 +11898,8 @@ snapshots: dependencies: aggregate-error: 3.1.0 + p-try@2.2.0: {} + pac-proxy-agent@7.2.0: dependencies: '@tootallnate/quickjs-emscripten': 0.23.0 @@ -9208,6 +12019,13 @@ snapshots: pirates@4.0.7: {} +<<<<<<< HEAD +======= + pkg-dir@4.2.0: + dependencies: + find-up: 4.1.0 + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) pkg-types@1.3.1: dependencies: confbox: 0.1.8 @@ -9251,6 +12069,10 @@ snapshots: prelude-ls@1.2.1: {} + prettier-linter-helpers@1.0.0: + dependencies: + fast-diff: 1.3.0 + prettier-plugin-tailwindcss@0.6.14(prettier@3.5.1): dependencies: prettier: 3.5.1 @@ -9259,6 +12081,14 @@ snapshots: prettier@3.6.0: {} + prettier@3.6.2: {} + + pretty-format@30.0.5: + dependencies: + '@jest/schemas': 30.0.5 + ansi-styles: 5.2.0 + react-is: 18.3.1 + prompts@2.4.2: dependencies: kleur: 3.0.3 @@ -9289,6 +12119,8 @@ snapshots: punycode@2.3.1: {} + pure-rand@7.0.1: {} + pvtsutils@1.3.6: dependencies: tslib: 2.8.1 @@ -9313,16 +12145,23 @@ snapshots: react: 19.0.0 scheduler: 0.25.0 + react-dom@19.1.1(react@19.1.1): + dependencies: + react: 19.1.1 + scheduler: 0.26.0 + react-hook-form@7.58.1(react@19.0.0): dependencies: react: 19.0.0 - react-icons@5.5.0(react@19.0.0): + react-icons@5.5.0(react@19.1.1): dependencies: - react: 19.0.0 + react: 19.1.1 react-is@16.13.1: {} + react-is@18.3.1: {} + react-promise-suspense@0.3.4: dependencies: fast-deep-equal: 2.0.1 @@ -9335,6 +12174,14 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + react-remove-scroll-bar@2.3.8(@types/react@19.1.9)(react@19.1.1): + dependencies: + react: 19.1.1 + react-style-singleton: 2.2.3(@types/react@19.1.9)(react@19.1.1) + tslib: 2.8.1 + optionalDependencies: + '@types/react': 19.1.9 + react-remove-scroll@2.7.1(@types/react@19.0.10)(react@19.0.0): dependencies: react: 19.0.0 @@ -9346,6 +12193,17 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + react-remove-scroll@2.7.1(@types/react@19.1.9)(react@19.1.1): + dependencies: + react: 19.1.1 + react-remove-scroll-bar: 2.3.8(@types/react@19.1.9)(react@19.1.1) + react-style-singleton: 2.2.3(@types/react@19.1.9)(react@19.1.1) + tslib: 2.8.1 + use-callback-ref: 1.3.3(@types/react@19.1.9)(react@19.1.1) + use-sidecar: 1.1.3(@types/react@19.1.9)(react@19.1.1) + optionalDependencies: + '@types/react': 19.1.9 + react-style-singleton@2.2.3(@types/react@19.0.10)(react@19.0.0): dependencies: get-nonce: 1.0.1 @@ -9354,8 +12212,18 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + react-style-singleton@2.2.3(@types/react@19.1.9)(react@19.1.1): + dependencies: + get-nonce: 1.0.1 + react: 19.1.1 + tslib: 2.8.1 + optionalDependencies: + '@types/react': 19.1.9 + react@19.0.0: {} + react@19.1.1: {} + readable-stream@3.6.2: dependencies: inherits: 2.0.4 @@ -9409,13 +12277,17 @@ snapshots: require-from-string@2.0.2: {} - resend@4.6.0(react-dom@19.0.0(react@19.0.0))(react@19.0.0): + resend@4.6.0(react-dom@19.1.1(react@19.1.1))(react@19.1.1): dependencies: - '@react-email/render': 1.1.2(react-dom@19.0.0(react@19.0.0))(react@19.0.0) + '@react-email/render': 1.1.2(react-dom@19.1.1(react@19.1.1))(react@19.1.1) transitivePeerDependencies: - react - react-dom + resolve-cwd@3.0.0: + dependencies: + resolve-from: 5.0.0 + resolve-from@4.0.0: {} resolve-from@5.0.0: {} @@ -9457,6 +12329,7 @@ snapshots: dependencies: glob: 7.2.3 +<<<<<<< HEAD rollup@4.46.1: dependencies: '@types/estree': 1.0.8 @@ -9481,6 +12354,32 @@ snapshots: '@rollup/rollup-win32-arm64-msvc': 4.46.1 '@rollup/rollup-win32-ia32-msvc': 4.46.1 '@rollup/rollup-win32-x64-msvc': 4.46.1 +======= + rollup@4.46.2: + dependencies: + '@types/estree': 1.0.8 + optionalDependencies: + '@rollup/rollup-android-arm-eabi': 4.46.2 + '@rollup/rollup-android-arm64': 4.46.2 + '@rollup/rollup-darwin-arm64': 4.46.2 + '@rollup/rollup-darwin-x64': 4.46.2 + '@rollup/rollup-freebsd-arm64': 4.46.2 + '@rollup/rollup-freebsd-x64': 4.46.2 + '@rollup/rollup-linux-arm-gnueabihf': 4.46.2 + '@rollup/rollup-linux-arm-musleabihf': 4.46.2 + '@rollup/rollup-linux-arm64-gnu': 4.46.2 + '@rollup/rollup-linux-arm64-musl': 4.46.2 + '@rollup/rollup-linux-loongarch64-gnu': 4.46.2 + '@rollup/rollup-linux-ppc64-gnu': 4.46.2 + '@rollup/rollup-linux-riscv64-gnu': 4.46.2 + '@rollup/rollup-linux-riscv64-musl': 4.46.2 + '@rollup/rollup-linux-s390x-gnu': 4.46.2 + '@rollup/rollup-linux-x64-gnu': 4.46.2 + '@rollup/rollup-linux-x64-musl': 4.46.2 + '@rollup/rollup-win32-arm64-msvc': 4.46.2 + '@rollup/rollup-win32-ia32-msvc': 4.46.2 + '@rollup/rollup-win32-x64-msvc': 4.46.2 +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) fsevents: 2.3.3 rou3@0.5.1: {} @@ -9528,6 +12427,8 @@ snapshots: scheduler@0.25.0: {} + scheduler@0.26.0: {} + sdp-transform@2.15.0: {} sdp@3.2.1: {} @@ -9542,6 +12443,8 @@ snapshots: semver@7.7.1: {} + semver@7.7.2: {} + sentence-case@2.1.1: dependencies: no-case: 2.3.2 @@ -9703,6 +12606,11 @@ snapshots: source-map-js@1.2.1: {} + source-map-support@0.5.13: + dependencies: + buffer-from: 1.1.2 + source-map: 0.6.1 + source-map-support@0.5.21: dependencies: buffer-from: 1.1.2 @@ -9716,8 +12624,14 @@ snapshots: split2@4.2.0: {} + sprintf-js@1.0.3: {} + sprintf-js@1.1.3: {} + stack-utils@2.0.6: + dependencies: + escape-string-regexp: 2.0.0 + standard-as-callback@2.1.0: {} stdin-discarder@0.1.0: @@ -9728,6 +12642,11 @@ snapshots: string-argv@0.3.2: {} + string-length@4.0.2: + dependencies: + char-regex: 1.0.2 + strip-ansi: 6.0.1 + string-width@4.2.3: dependencies: emoji-regex: 8.0.0 @@ -9802,6 +12721,8 @@ snapshots: dependencies: ansi-regex: 6.1.0 + strip-bom@4.0.0: {} + strip-final-newline@2.0.0: {} strip-final-newline@3.0.0: {} @@ -9835,6 +12756,10 @@ snapshots: dependencies: has-flag: 4.0.0 + supports-color@8.1.1: + dependencies: + has-flag: 4.0.0 + supports-preserve-symlinks-flag@1.0.0: {} swap-case@1.1.2: @@ -9842,6 +12767,10 @@ snapshots: lower-case: 1.1.4 upper-case: 1.1.3 + synckit@0.11.11: + dependencies: + '@pkgr/core': 0.2.9 + tailwind-merge@3.0.1: {} tailwindcss@4.0.8: {} @@ -9857,6 +12786,12 @@ snapshots: mkdirp: 3.0.1 yallist: 5.0.0 + test-exclude@6.0.0: + dependencies: + '@istanbuljs/schema': 0.1.3 + glob: 7.2.3 + minimatch: 3.1.2 + text-extensions@2.4.0: {} thenify-all@1.6.0: @@ -9894,6 +12829,8 @@ snapshots: dependencies: os-tmpdir: 1.0.2 + tmpl@1.0.5: {} + to-regex-range@5.0.1: dependencies: is-number: 7.0.0 @@ -9912,6 +12849,10 @@ snapshots: dependencies: typescript: 5.7.3 + ts-api-utils@2.1.0(typescript@5.9.2): + dependencies: + typescript: 5.9.2 + ts-debounce@4.0.0: {} ts-interface-checker@0.1.13: {} @@ -9934,6 +12875,25 @@ snapshots: v8-compile-cache-lib: 3.0.1 yn: 3.1.1 + ts-node@10.9.2(@types/node@20.17.19)(typescript@5.9.2): + dependencies: + '@cspotcode/source-map-support': 0.8.1 + '@tsconfig/node10': 1.0.11 + '@tsconfig/node12': 1.0.11 + '@tsconfig/node14': 1.0.3 + '@tsconfig/node16': 1.0.4 + '@types/node': 20.17.19 + acorn: 8.14.0 + acorn-walk: 8.3.4 + arg: 4.1.3 + create-require: 1.1.1 + diff: 4.0.2 + make-error: 1.3.6 + typescript: 5.9.2 + v8-compile-cache-lib: 3.0.1 + yn: 3.1.1 + optional: true + tslib@1.14.1: {} tslib@2.8.1: {} @@ -9951,7 +12911,11 @@ snapshots: picocolors: 1.1.1 postcss-load-config: 6.0.1(jiti@2.4.2)(postcss@8.5.3)(tsx@4.20.3)(yaml@2.8.0) resolve-from: 5.0.0 +<<<<<<< HEAD rollup: 4.46.1 +======= + rollup: 4.46.2 +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) source-map: 0.8.0-beta.0 sucrase: 3.35.0 tinyexec: 0.3.2 @@ -9966,6 +12930,37 @@ snapshots: - tsx - yaml +<<<<<<< HEAD +======= + tsup@8.5.0(jiti@2.4.2)(postcss@8.5.3)(tsx@4.20.3)(typescript@5.9.2)(yaml@2.8.0): + dependencies: + bundle-require: 5.1.0(esbuild@0.25.5) + cac: 6.7.14 + chokidar: 4.0.3 + consola: 3.4.2 + debug: 4.4.1 + esbuild: 0.25.5 + fix-dts-default-cjs-exports: 1.0.1 + joycon: 3.1.1 + picocolors: 1.1.1 + postcss-load-config: 6.0.1(jiti@2.4.2)(postcss@8.5.3)(tsx@4.20.3)(yaml@2.8.0) + resolve-from: 5.0.0 + rollup: 4.46.2 + source-map: 0.8.0-beta.0 + sucrase: 3.35.0 + tinyexec: 0.3.2 + tinyglobby: 0.2.14 + tree-kill: 1.2.2 + optionalDependencies: + postcss: 8.5.3 + typescript: 5.9.2 + transitivePeerDependencies: + - jiti + - supports-color + - tsx + - yaml + +>>>>>>> b9c0f28 (feat: upgrade dependencies and fixed build issues) tsx@4.20.3: dependencies: esbuild: 0.25.5 @@ -10006,6 +13001,8 @@ snapshots: dependencies: prelude-ls: 1.2.1 + type-detect@4.0.8: {} + type-fest@0.21.3: {} type-fest@4.41.0: {} @@ -10061,6 +13058,8 @@ snapshots: typescript@5.8.3: {} + typescript@5.9.2: {} + ua-is-frozen@0.1.2: {} ua-parser-js@2.0.4: @@ -10095,6 +13094,36 @@ snapshots: universalify@2.0.1: {} + unrs-resolver@1.11.1: + dependencies: + napi-postinstall: 0.3.2 + optionalDependencies: + '@unrs/resolver-binding-android-arm-eabi': 1.11.1 + '@unrs/resolver-binding-android-arm64': 1.11.1 + '@unrs/resolver-binding-darwin-arm64': 1.11.1 + '@unrs/resolver-binding-darwin-x64': 1.11.1 + '@unrs/resolver-binding-freebsd-x64': 1.11.1 + '@unrs/resolver-binding-linux-arm-gnueabihf': 1.11.1 + '@unrs/resolver-binding-linux-arm-musleabihf': 1.11.1 + '@unrs/resolver-binding-linux-arm64-gnu': 1.11.1 + '@unrs/resolver-binding-linux-arm64-musl': 1.11.1 + '@unrs/resolver-binding-linux-ppc64-gnu': 1.11.1 + '@unrs/resolver-binding-linux-riscv64-gnu': 1.11.1 + '@unrs/resolver-binding-linux-riscv64-musl': 1.11.1 + '@unrs/resolver-binding-linux-s390x-gnu': 1.11.1 + '@unrs/resolver-binding-linux-x64-gnu': 1.11.1 + '@unrs/resolver-binding-linux-x64-musl': 1.11.1 + '@unrs/resolver-binding-wasm32-wasi': 1.11.1 + '@unrs/resolver-binding-win32-arm64-msvc': 1.11.1 + '@unrs/resolver-binding-win32-ia32-msvc': 1.11.1 + '@unrs/resolver-binding-win32-x64-msvc': 1.11.1 + + update-browserslist-db@1.1.3(browserslist@4.25.1): + dependencies: + browserslist: 4.25.1 + escalade: 3.2.0 + picocolors: 1.1.1 + update-check@1.5.4: dependencies: registry-auth-token: 3.3.2 @@ -10117,6 +13146,13 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + use-callback-ref@1.3.3(@types/react@19.1.9)(react@19.1.1): + dependencies: + react: 19.1.1 + tslib: 2.8.1 + optionalDependencies: + '@types/react': 19.1.9 + use-sidecar@1.1.3(@types/react@19.0.10)(react@19.0.0): dependencies: detect-node-es: 1.1.0 @@ -10125,6 +13161,14 @@ snapshots: optionalDependencies: '@types/react': 19.0.10 + use-sidecar@1.1.3(@types/react@19.1.9)(react@19.1.1): + dependencies: + detect-node-es: 1.1.0 + react: 19.1.1 + tslib: 2.8.1 + optionalDependencies: + '@types/react': 19.1.9 + use-sync-external-store@1.5.0(react@19.0.0): dependencies: react: 19.0.0 @@ -10140,8 +13184,18 @@ snapshots: v8-compile-cache-lib@3.0.1: {} + v8-to-istanbul@9.3.0: + dependencies: + '@jridgewell/trace-mapping': 0.3.29 + '@types/istanbul-lib-coverage': 2.0.6 + convert-source-map: 2.0.0 + validate-npm-package-name@5.0.1: {} + walker@1.0.8: + dependencies: + makeerror: 1.0.12 + wcwidth@1.0.1: dependencies: defaults: 1.0.4 @@ -10241,6 +13295,11 @@ snapshots: wrappy@1.0.2: {} + write-file-atomic@5.0.1: + dependencies: + imurmurhash: 0.1.4 + signal-exit: 4.1.0 + ws@8.17.1: {} ws@8.18.3: {} @@ -10251,6 +13310,8 @@ snapshots: y18n@5.0.8: {} + yallist@3.1.1: {} + yallist@5.0.0: {} yaml@2.8.0: {}