@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/dist/src/hooks/useSubtitles.js

@@ -0,0 +1,73 @@
+import { useState, useEffect } from "react";
+export function useSubtitles(subtitleSrc) {
+    const [subtitlesEnabled, setSubtitlesEnabled] = useState(false);
+    const [subtitleCues, setSubtitleCues] = useState([]);
+    const [currentSubtitle, setCurrentSubtitle] = useState("");
+    const parseVTTTime = (timeStr) => {
+        const parts = timeStr.split(":");
+        const seconds = parts[2] ? parseFloat(parts[2]) : 0;
+        const minutes = parts[1] ? parseInt(parts[1], 10) * 60 : 0;
+        const hours = parts[0] ? parseInt(parts[0], 10) * 3600 : 0;
+        return hours + minutes + seconds;
+    };
+    const loadSubtitles = async (url) => {
+        try {
+            const response = await fetch(url);
+            const text = await response.text();
+            const cues = [];
+            const lines = text.split("\n");
+            let i = 0;
+            while (i < lines.length) {
+                if (lines[i]?.includes("-->")) {
+                    const [startStr, endStr] = (lines[i] || "").split("-->").map((s) => s.trim());
+                    const start = parseVTTTime(startStr || "");
+                    const end = parseVTTTime(endStr || "");
+                    i++;
+                    let subtitleText = "";
+                    while (i < lines.length && lines[i]?.trim() !== "") {
+                        subtitleText += (subtitleText ? " " : "") + lines[i]?.trim();
+                        i++;
+                    }
+                    if (subtitleText) {
+                        cues.push({ start, end, text: subtitleText });
+                    }
+                }
+                i++;
+            }
+            setSubtitleCues(cues);
+        }
+        catch (error) {
+            console.error("Failed to load subtitles:", error);
+        }
+    };
+    const getCurrentSubtitle = (currentTime) => {
+        if (!subtitlesEnabled || subtitleCues.length === 0)
+            return "";
+        const currentCue = subtitleCues.find((cue) => currentTime >= cue.start && currentTime <= cue.end);
+        return currentCue?.text || "";
+    };
+    const toggleSubtitles = () => {
+        setSubtitlesEnabled(prev => {
+            const newEnabled = !prev;
+            if (newEnabled && subtitleSrc && subtitleCues.length === 0) {
+                loadSubtitles(subtitleSrc);
+            }
+            else if (!newEnabled) {
+                setCurrentSubtitle("");
+            }
+            return newEnabled;
+        });
+    };
+    useEffect(() => {
+        if (!subtitlesEnabled) {
+            setCurrentSubtitle("");
+        }
+    }, [subtitlesEnabled]);
+    return {
+        subtitlesEnabled,
+        currentSubtitle,
+        toggleSubtitles,
+        getCurrentSubtitle,
+        setCurrentSubtitle
+    };
+}

package/dist/src/hooks/useSubtitles.ts

@@ -0,0 +1,91 @@
+import { useState, useCallback, useMemo, useEffect } from "react"
+
+interface SubtitleCue {
+	start: number
+	end: number
+	text: string
+}
+
+export function useSubtitles(subtitleSrc?: string) {
+	const [subtitlesEnabled, setSubtitlesEnabled] = useState(false)
+	const [subtitleCues, setSubtitleCues] = useState<SubtitleCue[]>([])
+	const [currentSubtitle, setCurrentSubtitle] = useState("")
+
+	const parseVTTTime = (timeStr: string): number => {
+    		const parts = timeStr.split(":")
+    		const seconds = parts[2] ? parseFloat(parts[2]) : 0
+    		const minutes = parts[1] ? parseInt(parts[1], 10) * 60 : 0
+    		const hours = parts[0] ? parseInt(parts[0], 10) * 3600 : 0
+    		return hours + minutes + seconds
+    	}
+
+	const loadSubtitles = async (url: string) => {
+    		try {
+    			const response = await fetch(url)
+    			const text = await response.text()
+
+    			const cues: SubtitleCue[] = []
+    			const lines = text.split("\n")
+    			let i = 0
+
+    			while (i < lines.length) {
+    				if (lines[i]?.includes("-->")) {
+    					const [startStr, endStr] = (lines[i] || "").split("-->").map((s) => s.trim())
+    					const start = parseVTTTime(startStr || "")
+    					const end = parseVTTTime(endStr || "")
+
+    					i++
+    					let subtitleText = ""
+    					while (i < lines.length && lines[i]?.trim() !== "") {
+    						subtitleText += (subtitleText ? " " : "") + lines[i]?.trim()
+    						i++
+    					}
+
+    					if (subtitleText) {
+    						cues.push({ start, end, text: subtitleText })
+    					}
+    				}
+    				i++
+    			}
+
+    			setSubtitleCues(cues)
+    		} catch (error) {
+    			console.error("Failed to load subtitles:", error)
+    		}
+    	}
+
+	const getCurrentSubtitle = (currentTime: number) => {
+    			if (!subtitlesEnabled || subtitleCues.length === 0) return ""
+    			
+    			const currentCue = subtitleCues.find(
+    				(cue) => currentTime >= cue.start && currentTime <= cue.end
+    			)
+    			return currentCue?.text || ""
+    		}
+
+	const toggleSubtitles = () => {
+    		setSubtitlesEnabled(prev => {
+    			const newEnabled = !prev
+    			if (newEnabled && subtitleSrc && subtitleCues.length === 0) {
+    				loadSubtitles(subtitleSrc)
+    			} else if (!newEnabled) {
+    				setCurrentSubtitle("")
+    			}
+    			return newEnabled
+    		})
+    	}
+
+	useEffect(() => {
+		if (!subtitlesEnabled) {
+			setCurrentSubtitle("")
+		}
+	}, [subtitlesEnabled])
+
+	return {
+		subtitlesEnabled,
+		currentSubtitle,
+		toggleSubtitles,
+		getCurrentSubtitle,
+		setCurrentSubtitle
+	}
+}

package/dist/src/hooks/useVideoPlayer.d.ts

@@ -0,0 +1,32 @@
+export interface BufferedRange {
+    start: number;
+    end: number;
+    percentage: number;
+}
+export interface VideoState {
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    volume: number;
+    isMuted: boolean;
+    isFullscreen: boolean;
+    isLoading: boolean;
+    isSeeking: boolean;
+    isBuffering: boolean;
+    bufferedRanges: BufferedRange[];
+}
+export interface VideoControls {
+    togglePlay: () => void;
+    seekForward: (seconds?: number) => void;
+    seekBackward: (seconds?: number) => void;
+    toggleMute: () => void;
+    setVolume: (volume: number) => void;
+    toggleFullscreen: () => void;
+    seekTo: (time: number) => void;
+}
+export declare function useVideoPlayer(containerRef: React.RefObject<HTMLDivElement | null>): {
+    videoRef: import("react").RefObject<HTMLVideoElement | null>;
+    state: VideoState;
+    controls: VideoControls;
+};
+//# sourceMappingURL=useVideoPlayer.d.ts.map

package/dist/src/hooks/useVideoPlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVideoPlayer.d.ts","sourceRoot":"","sources":["useVideoPlayer.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,UAAU;IAC1B,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,OAAO,CAAA;IACpB,cAAc,EAAE,aAAa,EAAE,CAAA;CAC/B;AAED,MAAM,WAAW,aAAa;IAC7B,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,YAAY,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9B;AAED,wBAAgB,cAAc,CAAC,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC;;;;EAwMlF"}

package/dist/src/hooks/useVideoPlayer.js

@@ -0,0 +1,184 @@
+import { useState, useRef, useEffect } from "react";
+export function useVideoPlayer(containerRef) {
+    const videoRef = useRef(null);
+    const [state, setState] = useState({
+        isPlaying: false,
+        currentTime: 0,
+        duration: 0,
+        volume: 1,
+        isMuted: false,
+        isFullscreen: false,
+        isLoading: true,
+        isSeeking: false,
+        isBuffering: false,
+        bufferedRanges: []
+    });
+    useEffect(() => {
+        const video = videoRef.current;
+        if (!video)
+            return;
+        const handleTimeUpdate = () => {
+            setState(prev => ({ ...prev, currentTime: video.currentTime }));
+        };
+        const handleLoadedMetadata = () => {
+            setState(prev => ({ ...prev, duration: video.duration }));
+        };
+        const handlePlay = () => {
+            setState(prev => ({ ...prev, isPlaying: true, isBuffering: false }));
+        };
+        const handlePause = () => {
+            setState(prev => ({ ...prev, isPlaying: false }));
+        };
+        const handleVolumeChange = () => {
+            setState(prev => ({
+                ...prev,
+                volume: video.volume,
+                isMuted: video.muted
+            }));
+        };
+        // Loading state handlers
+        const handleLoadStart = () => {
+            setState(prev => ({ ...prev, isLoading: true }));
+        };
+        const handleLoadedData = () => {
+            setState(prev => ({ ...prev, isLoading: false }));
+        };
+        // Seeking state handlers
+        const handleSeeking = () => {
+            setState(prev => ({ ...prev, isSeeking: true }));
+        };
+        const handleSeeked = () => {
+            setState(prev => ({ ...prev, isSeeking: false }));
+        };
+        // Buffering state handlers
+        const handleWaiting = () => {
+            setState(prev => ({ ...prev, isBuffering: true }));
+        };
+        const handlePlaying = () => {
+            setState(prev => ({ ...prev, isBuffering: false, isLoading: false }));
+        };
+        const handleCanPlay = () => {
+            setState(prev => ({ ...prev, isLoading: false, isBuffering: false }));
+        };
+        // Progress handler for buffered ranges
+        const handleProgress = () => {
+            if (!video.buffered || video.buffered.length === 0 || video.duration === 0) {
+                setState(prev => ({ ...prev, bufferedRanges: [] }));
+                return;
+            }
+            const ranges = [];
+            for (let i = 0; i < video.buffered.length; i++) {
+                const start = video.buffered.start(i);
+                const end = video.buffered.end(i);
+                ranges.push({
+                    start,
+                    end,
+                    percentage: ((end - start) / video.duration) * 100
+                });
+            }
+            setState(prev => ({ ...prev, bufferedRanges: ranges }));
+        };
+        video.addEventListener("timeupdate", handleTimeUpdate);
+        video.addEventListener("loadedmetadata", handleLoadedMetadata);
+        video.addEventListener("play", handlePlay);
+        video.addEventListener("pause", handlePause);
+        video.addEventListener("volumechange", handleVolumeChange);
+        video.addEventListener("loadstart", handleLoadStart);
+        video.addEventListener("loadeddata", handleLoadedData);
+        video.addEventListener("seeking", handleSeeking);
+        video.addEventListener("seeked", handleSeeked);
+        video.addEventListener("waiting", handleWaiting);
+        video.addEventListener("playing", handlePlaying);
+        video.addEventListener("canplay", handleCanPlay);
+        video.addEventListener("progress", handleProgress);
+        return () => {
+            video.removeEventListener("timeupdate", handleTimeUpdate);
+            video.removeEventListener("loadedmetadata", handleLoadedMetadata);
+            video.removeEventListener("play", handlePlay);
+            video.removeEventListener("pause", handlePause);
+            video.removeEventListener("volumechange", handleVolumeChange);
+            video.removeEventListener("loadstart", handleLoadStart);
+            video.removeEventListener("loadeddata", handleLoadedData);
+            video.removeEventListener("seeking", handleSeeking);
+            video.removeEventListener("seeked", handleSeeked);
+            video.removeEventListener("waiting", handleWaiting);
+            video.removeEventListener("playing", handlePlaying);
+            video.removeEventListener("canplay", handleCanPlay);
+            video.removeEventListener("progress", handleProgress);
+        };
+    }, []);
+    const togglePlay = () => {
+        const video = videoRef.current;
+        if (!video)
+            return;
+        if (state.isPlaying) {
+            video.pause();
+        }
+        else {
+            video.play();
+        }
+    };
+    const seekForward = (seconds = 10) => {
+        const video = videoRef.current;
+        if (!video)
+            return;
+        video.currentTime = Math.min(state.duration, video.currentTime + seconds);
+    };
+    const seekBackward = (seconds = 10) => {
+        const video = videoRef.current;
+        if (!video)
+            return;
+        video.currentTime = Math.max(0, video.currentTime - seconds);
+    };
+    const toggleMute = () => {
+        const video = videoRef.current;
+        if (!video)
+            return;
+        video.muted = !state.isMuted;
+    };
+    const setVolume = (volume) => {
+        const video = videoRef.current;
+        if (!video)
+            return;
+        video.volume = volume;
+        if (volume > 0 && state.isMuted) {
+            video.muted = false;
+        }
+    };
+    const toggleFullscreen = () => {
+        const container = containerRef.current;
+        if (!container)
+            return;
+        if (!state.isFullscreen) {
+            if (container.requestFullscreen) {
+                container.requestFullscreen();
+            }
+        }
+        else {
+            if (document.exitFullscreen) {
+                document.exitFullscreen();
+            }
+        }
+        setState(prev => ({ ...prev, isFullscreen: !prev.isFullscreen }));
+    };
+    const seekTo = (time) => {
+        const video = videoRef.current;
+        if (!video || state.duration === 0)
+            return;
+        video.currentTime = Math.max(0, Math.min(state.duration, time));
+    };
+    const controls = {
+        togglePlay,
+        seekForward,
+        seekBackward,
+        toggleMute,
+        setVolume,
+        toggleFullscreen,
+        seekTo
+    };
+    return {
+        videoRef,
+        state,
+        controls
+    };
+}

package/dist/src/hooks/useVideoPlayer.ts

@@ -0,0 +1,232 @@
+import { useState, useRef, useCallback, useEffect } from "react"
+
+export interface BufferedRange {
+	start: number
+	end: number
+	percentage: number
+}
+
+export interface VideoState {
+	isPlaying: boolean
+	currentTime: number
+	duration: number
+	volume: number
+	isMuted: boolean
+	isFullscreen: boolean
+	isLoading: boolean
+	isSeeking: boolean
+	isBuffering: boolean
+	bufferedRanges: BufferedRange[]
+}
+
+export interface VideoControls {
+	togglePlay: () => void
+	seekForward: (seconds?: number) => void
+	seekBackward: (seconds?: number) => void
+	toggleMute: () => void
+	setVolume: (volume: number) => void
+	toggleFullscreen: () => void
+	seekTo: (time: number) => void
+}
+
+export function useVideoPlayer(containerRef: React.RefObject<HTMLDivElement | null>) {
+	const videoRef = useRef<HTMLVideoElement>(null)
+	const [state, setState] = useState<VideoState>({
+		isPlaying: false,
+		currentTime: 0,
+		duration: 0,
+		volume: 1,
+		isMuted: false,
+		isFullscreen: false,
+		isLoading: true,
+		isSeeking: false,
+		isBuffering: false,
+		bufferedRanges: []
+	})
+
+	useEffect(() => {
+		const video = videoRef.current
+		if (!video) return
+
+		const handleTimeUpdate = () => {
+			setState(prev => ({ ...prev, currentTime: video.currentTime }))
+		}
+
+		const handleLoadedMetadata = () => {
+			setState(prev => ({ ...prev, duration: video.duration }))
+		}
+
+		const handlePlay = () => {
+			setState(prev => ({ ...prev, isPlaying: true, isBuffering: false }))
+		}
+
+		const handlePause = () => {
+			setState(prev => ({ ...prev, isPlaying: false }))
+		}
+
+		const handleVolumeChange = () => {
+			setState(prev => ({
+				...prev,
+				volume: video.volume,
+				isMuted: video.muted
+			}))
+		}
+
+		// Loading state handlers
+		const handleLoadStart = () => {
+			setState(prev => ({ ...prev, isLoading: true }))
+		}
+
+		const handleLoadedData = () => {
+			setState(prev => ({ ...prev, isLoading: false }))
+		}
+
+		// Seeking state handlers
+		const handleSeeking = () => {
+			setState(prev => ({ ...prev, isSeeking: true }))
+		}
+
+		const handleSeeked = () => {
+			setState(prev => ({ ...prev, isSeeking: false }))
+		}
+
+		// Buffering state handlers
+		const handleWaiting = () => {
+			setState(prev => ({ ...prev, isBuffering: true }))
+		}
+
+		const handlePlaying = () => {
+			setState(prev => ({ ...prev, isBuffering: false, isLoading: false }))
+		}
+
+		const handleCanPlay = () => {
+			setState(prev => ({ ...prev, isLoading: false, isBuffering: false }))
+		}
+
+		// Progress handler for buffered ranges
+		const handleProgress = () => {
+			if (!video.buffered || video.buffered.length === 0 || video.duration === 0) {
+				setState(prev => ({ ...prev, bufferedRanges: [] }))
+				return
+			}
+
+			const ranges: BufferedRange[] = []
+			for (let i = 0; i < video.buffered.length; i++) {
+				const start = video.buffered.start(i)
+				const end = video.buffered.end(i)
+				ranges.push({
+					start,
+					end,
+					percentage: ((end - start) / video.duration) * 100
+				})
+			}
+			setState(prev => ({ ...prev, bufferedRanges: ranges }))
+		}
+
+		video.addEventListener("timeupdate", handleTimeUpdate)
+		video.addEventListener("loadedmetadata", handleLoadedMetadata)
+		video.addEventListener("play", handlePlay)
+		video.addEventListener("pause", handlePause)
+		video.addEventListener("volumechange", handleVolumeChange)
+		video.addEventListener("loadstart", handleLoadStart)
+		video.addEventListener("loadeddata", handleLoadedData)
+		video.addEventListener("seeking", handleSeeking)
+		video.addEventListener("seeked", handleSeeked)
+		video.addEventListener("waiting", handleWaiting)
+		video.addEventListener("playing", handlePlaying)
+		video.addEventListener("canplay", handleCanPlay)
+		video.addEventListener("progress", handleProgress)
+
+		return () => {
+			video.removeEventListener("timeupdate", handleTimeUpdate)
+			video.removeEventListener("loadedmetadata", handleLoadedMetadata)
+			video.removeEventListener("play", handlePlay)
+			video.removeEventListener("pause", handlePause)
+			video.removeEventListener("volumechange", handleVolumeChange)
+			video.removeEventListener("loadstart", handleLoadStart)
+			video.removeEventListener("loadeddata", handleLoadedData)
+			video.removeEventListener("seeking", handleSeeking)
+			video.removeEventListener("seeked", handleSeeked)
+			video.removeEventListener("waiting", handleWaiting)
+			video.removeEventListener("playing", handlePlaying)
+			video.removeEventListener("canplay", handleCanPlay)
+			video.removeEventListener("progress", handleProgress)
+		}
+	}, [])
+
+	const togglePlay = () => {
+    		const video = videoRef.current
+    		if (!video) return
+
+    		if (state.isPlaying) {
+    			video.pause()
+    		} else {
+    			video.play()
+    		}
+    	}
+
+	const seekForward = (seconds = 10) => {
+    		const video = videoRef.current
+    		if (!video) return
+    		video.currentTime = Math.min(state.duration, video.currentTime + seconds)
+    	}
+
+	const seekBackward = (seconds = 10) => {
+    		const video = videoRef.current
+    		if (!video) return
+    		video.currentTime = Math.max(0, video.currentTime - seconds)
+    	}
+
+	const toggleMute = () => {
+    		const video = videoRef.current
+    		if (!video) return
+    		video.muted = !state.isMuted
+    	}
+
+	const setVolume = (volume: number) => {
+    		const video = videoRef.current
+    		if (!video) return
+    		video.volume = volume
+    		if (volume > 0 && state.isMuted) {
+    			video.muted = false
+    		}
+    	}
+
+	const toggleFullscreen = () => {
+    		const container = containerRef.current
+    		if (!container) return
+
+    		if (!state.isFullscreen) {
+    			if (container.requestFullscreen) {
+    				container.requestFullscreen()
+    			}
+    		} else {
+    			if (document.exitFullscreen) {
+    				document.exitFullscreen()
+    			}
+    		}
+    		setState(prev => ({ ...prev, isFullscreen: !prev.isFullscreen }))
+    	}
+
+	const seekTo = (time: number) => {
+    		const video = videoRef.current
+    		if (!video || state.duration === 0) return
+    		video.currentTime = Math.max(0, Math.min(state.duration, time))
+    	}
+
+	const controls: VideoControls = {
+		togglePlay,
+		seekForward,
+		seekBackward,
+		toggleMute,
+		setVolume,
+		toggleFullscreen,
+		seekTo
+	}
+
+	return {
+		videoRef,
+		state,
+		controls
+	}
+}

package/dist/src/icons/components/FullscreenIcon.d.ts

@@ -0,0 +1,3 @@
+import type { IconProps } from '../types';
+export declare function FullscreenIcon(props: IconProps): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<import("react").ReactNode> | Promise<import("react").ReactNode> | null | undefined;
+//# sourceMappingURL=FullscreenIcon.d.ts.map

package/dist/src/icons/components/FullscreenIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FullscreenIcon.d.ts","sourceRoot":"","sources":["FullscreenIcon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGzC,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,8KAiC9C"}

package/dist/src/icons/components/FullscreenIcon.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconTheme, useCustomIcon } from '../provider';
+export function FullscreenIcon(props) {
+    const theme = useIconTheme();
+    const customIcon = useCustomIcon('fullscreen');
+    if (customIcon) {
+        return customIcon(props);
+    }
+    const { size = theme.size, color = theme.color, strokeWidth = theme.strokeWidth, className = theme.className, ...rest } = props;
+    return (_jsx("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: color, strokeWidth: strokeWidth, strokeLinecap: "round", strokeLinejoin: "round", className: className, "aria-hidden": "true", ...rest, children: _jsx("path", { d: "M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3" }) }));
+}

package/dist/src/icons/components/FullscreenIcon.tsx

@@ -0,0 +1,37 @@
+import type { IconProps } from '../types'
+import { useIconTheme, useCustomIcon } from '../provider'
+
+export function FullscreenIcon(props: IconProps) {
+  const theme = useIconTheme()
+  const customIcon = useCustomIcon('fullscreen')
+  
+  if (customIcon) {
+    return customIcon(props)
+  }
+  
+  const {
+    size = theme.size,
+    color = theme.color,
+    strokeWidth = theme.strokeWidth,
+    className = theme.className,
+    ...rest
+  } = props
+  
+  return (
+    <svg
+      width={size}
+      height={size}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke={color}
+      strokeWidth={strokeWidth}
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      className={className}
+      aria-hidden="true"
+      {...rest}
+    >
+      <path d="M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3" />
+    </svg>
+  )
+}

package/dist/src/icons/components/SettingsIcon.d.ts

@@ -0,0 +1,3 @@
+import type { IconProps } from '../types';
+export declare function SettingsIcon(props: IconProps): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<import("react").ReactNode> | Promise<import("react").ReactNode> | null | undefined;
+//# sourceMappingURL=SettingsIcon.d.ts.map

package/dist/src/icons/components/SettingsIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SettingsIcon.d.ts","sourceRoot":"","sources":["SettingsIcon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGzC,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,8KAkC5C"}