diff --git a/book-examples/leptos/src/app.rs b/book-examples/leptos/src/app.rs
index d2c80e4..4c24798 100644
--- a/book-examples/leptos/src/app.rs
+++ b/book-examples/leptos/src/app.rs
@@ -8,17 +8,8 @@ pub fn App() -> impl IntoView {
     #[cfg(feature = "icons")]
     {
         use crate::icons::Icons;
-        views.push(
-            view! {
-                <Icons />
-            }
-            .into_any(),
-        );
+        views.push(view! { <Icons/> }.into_any());
     }
 
-    view! {
-        <div class="w-full h-full flex justify-center items-start">
-            {views.into_view()}
-        </div>
-    }
+    view! { <div class="w-full h-full flex justify-center items-start">{views.into_view()}</div> }
 }
diff --git a/book-examples/leptos/src/icons.rs b/book-examples/leptos/src/icons.rs
index 31ca518..8efd672 100644
--- a/book-examples/leptos/src/icons.rs
+++ b/book-examples/leptos/src/icons.rs
@@ -1,6 +1,2057 @@
 use leptos::prelude::*;
-
+use lucide_leptos::*;
 #[component]
 pub fn Icons() -> impl IntoView {
-    view! {}
+    view! {
+        <div class="w-full max-w-80 py-4">
+            <IconsA/>
+            <IconsB/>
+            <IconsC/>
+            <IconsD/>
+            <IconsE/>
+            <IconsF/>
+            <IconsG/>
+            <IconsH/>
+            <IconsI/>
+            <IconsJ/>
+            <IconsK/>
+            <IconsL/>
+            <IconsM/>
+            <IconsN/>
+            <IconsO/>
+            <IconsP/>
+            <IconsQ/>
+            <IconsR/>
+            <IconsS/>
+            <IconsT/>
+            <IconsU/>
+            <IconsV/>
+            <IconsW/>
+            <IconsX/>
+            <IconsY/>
+            <IconsZ/>
+        </div>
+    }
+}
+#[component]
+pub fn IconsA() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <AArrowDown/> }.into_any(), "A Arrow Down"),
+                (view! { <AArrowUp/> }.into_any(), "A Arrow Up"),
+                (view! { <ALargeSmall/> }.into_any(), "A Large Small"),
+                (view! { <Accessibility/> }.into_any(), "Accessibility"),
+                (view! { <Activity/> }.into_any(), "Activity"),
+                (view! { <AirVent/> }.into_any(), "Air Vent"),
+                (view! { <Airplay/> }.into_any(), "Airplay"),
+                (view! { <AlarmClockCheck/> }.into_any(), "Alarm Clock Check"),
+                (view! { <AlarmClockMinus/> }.into_any(), "Alarm Clock Minus"),
+                (view! { <AlarmClockOff/> }.into_any(), "Alarm Clock Off"),
+                (view! { <AlarmClockPlus/> }.into_any(), "Alarm Clock Plus"),
+                (view! { <AlarmClock/> }.into_any(), "Alarm Clock"),
+                (view! { <AlarmSmoke/> }.into_any(), "Alarm Smoke"),
+                (view! { <Album/> }.into_any(), "Album"),
+                (view! { <AlignCenterHorizontal/> }.into_any(), "Align Center Horizontal"),
+                (view! { <AlignCenterVertical/> }.into_any(), "Align Center Vertical"),
+                (view! { <AlignCenter/> }.into_any(), "Align Center"),
+                (view! { <AlignEndHorizontal/> }.into_any(), "Align End Horizontal"),
+                (view! { <AlignEndVertical/> }.into_any(), "Align End Vertical"),
+                (
+                    view! { <AlignHorizontalDistributeCenter/> }.into_any(),
+                    "Align Horizontal Distribute Center",
+                ),
+                (
+                    view! { <AlignHorizontalDistributeEnd/> }.into_any(),
+                    "Align Horizontal Distribute End",
+                ),
+                (
+                    view! { <AlignHorizontalDistributeStart/> }.into_any(),
+                    "Align Horizontal Distribute Start",
+                ),
+                (
+                    view! { <AlignHorizontalJustifyCenter/> }.into_any(),
+                    "Align Horizontal Justify Center",
+                ),
+                (view! { <AlignHorizontalJustifyEnd/> }.into_any(), "Align Horizontal Justify End"),
+                (
+                    view! { <AlignHorizontalJustifyStart/> }.into_any(),
+                    "Align Horizontal Justify Start",
+                ),
+                (
+                    view! { <AlignHorizontalSpaceAround/> }.into_any(),
+                    "Align Horizontal Space Around",
+                ),
+                (
+                    view! { <AlignHorizontalSpaceBetween/> }.into_any(),
+                    "Align Horizontal Space Between",
+                ),
+                (view! { <AlignJustify/> }.into_any(), "Align Justify"),
+                (view! { <AlignLeft/> }.into_any(), "Align Left"),
+                (view! { <AlignRight/> }.into_any(), "Align Right"),
+                (view! { <AlignStartHorizontal/> }.into_any(), "Align Start Horizontal"),
+                (view! { <AlignStartVertical/> }.into_any(), "Align Start Vertical"),
+                (
+                    view! { <AlignVerticalDistributeCenter/> }.into_any(),
+                    "Align Vertical Distribute Center",
+                ),
+                (
+                    view! { <AlignVerticalDistributeEnd/> }.into_any(),
+                    "Align Vertical Distribute End",
+                ),
+                (
+                    view! { <AlignVerticalDistributeStart/> }.into_any(),
+                    "Align Vertical Distribute Start",
+                ),
+                (
+                    view! { <AlignVerticalJustifyCenter/> }.into_any(),
+                    "Align Vertical Justify Center",
+                ),
+                (view! { <AlignVerticalJustifyEnd/> }.into_any(), "Align Vertical Justify End"),
+                (view! { <AlignVerticalJustifyStart/> }.into_any(), "Align Vertical Justify Start"),
+                (view! { <AlignVerticalSpaceAround/> }.into_any(), "Align Vertical Space Around"),
+                (view! { <AlignVerticalSpaceBetween/> }.into_any(), "Align Vertical Space Between"),
+                (view! { <Ambulance/> }.into_any(), "Ambulance"),
+                (view! { <Ampersand/> }.into_any(), "Ampersand"),
+                (view! { <Ampersands/> }.into_any(), "Ampersands"),
+                (view! { <Amphora/> }.into_any(), "Amphora"),
+                (view! { <Anchor/> }.into_any(), "Anchor"),
+                (view! { <Angry/> }.into_any(), "Angry"),
+                (view! { <Annoyed/> }.into_any(), "Annoyed"),
+                (view! { <Antenna/> }.into_any(), "Antenna"),
+                (view! { <Anvil/> }.into_any(), "Anvil"),
+                (view! { <Aperture/> }.into_any(), "Aperture"),
+                (view! { <AppWindowMac/> }.into_any(), "App Window Mac"),
+                (view! { <AppWindow/> }.into_any(), "App Window"),
+                (view! { <Apple/> }.into_any(), "Apple"),
+                (view! { <ArchiveRestore/> }.into_any(), "Archive Restore"),
+                (view! { <ArchiveX/> }.into_any(), "Archive X"),
+                (view! { <Archive/> }.into_any(), "Archive"),
+                (view! { <Armchair/> }.into_any(), "Armchair"),
+                (view! { <ArrowBigDownDash/> }.into_any(), "Arrow Big Down Dash"),
+                (view! { <ArrowBigDown/> }.into_any(), "Arrow Big Down"),
+                (view! { <ArrowBigLeftDash/> }.into_any(), "Arrow Big Left Dash"),
+                (view! { <ArrowBigLeft/> }.into_any(), "Arrow Big Left"),
+                (view! { <ArrowBigRightDash/> }.into_any(), "Arrow Big Right Dash"),
+                (view! { <ArrowBigRight/> }.into_any(), "Arrow Big Right"),
+                (view! { <ArrowBigUpDash/> }.into_any(), "Arrow Big Up Dash"),
+                (view! { <ArrowBigUp/> }.into_any(), "Arrow Big Up"),
+                (view! { <ArrowDown01/> }.into_any(), "Arrow Down 01"),
+                (view! { <ArrowDown10/> }.into_any(), "Arrow Down 10"),
+                (view! { <ArrowDownAZ/> }.into_any(), "Arrow Down Az"),
+                (view! { <ArrowDownFromLine/> }.into_any(), "Arrow Down From Line"),
+                (view! { <ArrowDownLeft/> }.into_any(), "Arrow Down Left"),
+                (view! { <ArrowDownNarrowWide/> }.into_any(), "Arrow Down Narrow Wide"),
+                (view! { <ArrowDownRight/> }.into_any(), "Arrow Down Right"),
+                (view! { <ArrowDownToDot/> }.into_any(), "Arrow Down To Dot"),
+                (view! { <ArrowDownToLine/> }.into_any(), "Arrow Down To Line"),
+                (view! { <ArrowDownUp/> }.into_any(), "Arrow Down Up"),
+                (view! { <ArrowDownWideNarrow/> }.into_any(), "Arrow Down Wide Narrow"),
+                (view! { <ArrowDownZA/> }.into_any(), "Arrow Down Za"),
+                (view! { <ArrowDown/> }.into_any(), "Arrow Down"),
+                (view! { <ArrowLeftFromLine/> }.into_any(), "Arrow Left From Line"),
+                (view! { <ArrowLeftRight/> }.into_any(), "Arrow Left Right"),
+                (view! { <ArrowLeftToLine/> }.into_any(), "Arrow Left To Line"),
+                (view! { <ArrowLeft/> }.into_any(), "Arrow Left"),
+                (view! { <ArrowRightFromLine/> }.into_any(), "Arrow Right From Line"),
+                (view! { <ArrowRightLeft/> }.into_any(), "Arrow Right Left"),
+                (view! { <ArrowRightToLine/> }.into_any(), "Arrow Right To Line"),
+                (view! { <ArrowRight/> }.into_any(), "Arrow Right"),
+                (view! { <ArrowUp01/> }.into_any(), "Arrow Up 01"),
+                (view! { <ArrowUp10/> }.into_any(), "Arrow Up 10"),
+                (view! { <ArrowUpAZ/> }.into_any(), "Arrow Up Az"),
+                (view! { <ArrowUpDown/> }.into_any(), "Arrow Up Down"),
+                (view! { <ArrowUpFromDot/> }.into_any(), "Arrow Up From Dot"),
+                (view! { <ArrowUpFromLine/> }.into_any(), "Arrow Up From Line"),
+                (view! { <ArrowUpLeft/> }.into_any(), "Arrow Up Left"),
+                (view! { <ArrowUpNarrowWide/> }.into_any(), "Arrow Up Narrow Wide"),
+                (view! { <ArrowUpRight/> }.into_any(), "Arrow Up Right"),
+                (view! { <ArrowUpToLine/> }.into_any(), "Arrow Up To Line"),
+                (view! { <ArrowUpWideNarrow/> }.into_any(), "Arrow Up Wide Narrow"),
+                (view! { <ArrowUpZA/> }.into_any(), "Arrow Up Za"),
+                (view! { <ArrowUp/> }.into_any(), "Arrow Up"),
+                (view! { <ArrowsUpFromLine/> }.into_any(), "Arrows Up From Line"),
+                (view! { <Asterisk/> }.into_any(), "Asterisk"),
+                (view! { <AtSign/> }.into_any(), "At Sign"),
+                (view! { <Atom/> }.into_any(), "Atom"),
+                (view! { <AudioLines/> }.into_any(), "Audio Lines"),
+                (view! { <AudioWaveform/> }.into_any(), "Audio Waveform"),
+                (view! { <Award/> }.into_any(), "Award"),
+                (view! { <Axe/> }.into_any(), "Axe"),
+                (view! { <Axis3D/> }.into_any(), "Axis 3 D"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsB() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Baby/> }.into_any(), "Baby"),
+                (view! { <Backpack/> }.into_any(), "Backpack"),
+                (view! { <BadgeAlert/> }.into_any(), "Badge Alert"),
+                (view! { <BadgeCent/> }.into_any(), "Badge Cent"),
+                (view! { <BadgeCheck/> }.into_any(), "Badge Check"),
+                (view! { <BadgeDollarSign/> }.into_any(), "Badge Dollar Sign"),
+                (view! { <BadgeEuro/> }.into_any(), "Badge Euro"),
+                (view! { <BadgeHelp/> }.into_any(), "Badge Help"),
+                (view! { <BadgeIndianRupee/> }.into_any(), "Badge Indian Rupee"),
+                (view! { <BadgeInfo/> }.into_any(), "Badge Info"),
+                (view! { <BadgeJapaneseYen/> }.into_any(), "Badge Japanese Yen"),
+                (view! { <BadgeMinus/> }.into_any(), "Badge Minus"),
+                (view! { <BadgePercent/> }.into_any(), "Badge Percent"),
+                (view! { <BadgePlus/> }.into_any(), "Badge Plus"),
+                (view! { <BadgePoundSterling/> }.into_any(), "Badge Pound Sterling"),
+                (view! { <BadgeRussianRuble/> }.into_any(), "Badge Russian Ruble"),
+                (view! { <BadgeSwissFranc/> }.into_any(), "Badge Swiss Franc"),
+                (view! { <BadgeX/> }.into_any(), "Badge X"),
+                (view! { <Badge/> }.into_any(), "Badge"),
+                (view! { <BaggageClaim/> }.into_any(), "Baggage Claim"),
+                (view! { <Ban/> }.into_any(), "Ban"),
+                (view! { <Banana/> }.into_any(), "Banana"),
+                (view! { <Bandage/> }.into_any(), "Bandage"),
+                (view! { <Banknote/> }.into_any(), "Banknote"),
+                (view! { <Barcode/> }.into_any(), "Barcode"),
+                (view! { <Baseline/> }.into_any(), "Baseline"),
+                (view! { <Bath/> }.into_any(), "Bath"),
+                (view! { <BatteryCharging/> }.into_any(), "Battery Charging"),
+                (view! { <BatteryFull/> }.into_any(), "Battery Full"),
+                (view! { <BatteryLow/> }.into_any(), "Battery Low"),
+                (view! { <BatteryMedium/> }.into_any(), "Battery Medium"),
+                (view! { <BatteryWarning/> }.into_any(), "Battery Warning"),
+                (view! { <Battery/> }.into_any(), "Battery"),
+                (view! { <Beaker/> }.into_any(), "Beaker"),
+                (view! { <BeanOff/> }.into_any(), "Bean Off"),
+                (view! { <Bean/> }.into_any(), "Bean"),
+                (view! { <BedDouble/> }.into_any(), "Bed Double"),
+                (view! { <BedSingle/> }.into_any(), "Bed Single"),
+                (view! { <Bed/> }.into_any(), "Bed"),
+                (view! { <Beef/> }.into_any(), "Beef"),
+                (view! { <BeerOff/> }.into_any(), "Beer Off"),
+                (view! { <Beer/> }.into_any(), "Beer"),
+                (view! { <BellDot/> }.into_any(), "Bell Dot"),
+                (view! { <BellElectric/> }.into_any(), "Bell Electric"),
+                (view! { <BellMinus/> }.into_any(), "Bell Minus"),
+                (view! { <BellOff/> }.into_any(), "Bell Off"),
+                (view! { <BellPlus/> }.into_any(), "Bell Plus"),
+                (view! { <BellRing/> }.into_any(), "Bell Ring"),
+                (view! { <Bell/> }.into_any(), "Bell"),
+                (view! { <BetweenHorizontalEnd/> }.into_any(), "Between Horizontal End"),
+                (view! { <BetweenHorizontalStart/> }.into_any(), "Between Horizontal Start"),
+                (view! { <BetweenVerticalEnd/> }.into_any(), "Between Vertical End"),
+                (view! { <BetweenVerticalStart/> }.into_any(), "Between Vertical Start"),
+                (view! { <BicepsFlexed/> }.into_any(), "Biceps Flexed"),
+                (view! { <Bike/> }.into_any(), "Bike"),
+                (view! { <Binary/> }.into_any(), "Binary"),
+                (view! { <Binoculars/> }.into_any(), "Binoculars"),
+                (view! { <Biohazard/> }.into_any(), "Biohazard"),
+                (view! { <Bird/> }.into_any(), "Bird"),
+                (view! { <Bitcoin/> }.into_any(), "Bitcoin"),
+                (view! { <Blend/> }.into_any(), "Blend"),
+                (view! { <Blinds/> }.into_any(), "Blinds"),
+                (view! { <Blocks/> }.into_any(), "Blocks"),
+                (view! { <BluetoothConnected/> }.into_any(), "Bluetooth Connected"),
+                (view! { <BluetoothOff/> }.into_any(), "Bluetooth Off"),
+                (view! { <BluetoothSearching/> }.into_any(), "Bluetooth Searching"),
+                (view! { <Bluetooth/> }.into_any(), "Bluetooth"),
+                (view! { <Bold/> }.into_any(), "Bold"),
+                (view! { <Bolt/> }.into_any(), "Bolt"),
+                (view! { <Bomb/> }.into_any(), "Bomb"),
+                (view! { <Bone/> }.into_any(), "Bone"),
+                (view! { <BookA/> }.into_any(), "Book A"),
+                (view! { <BookAudio/> }.into_any(), "Book Audio"),
+                (view! { <BookCheck/> }.into_any(), "Book Check"),
+                (view! { <BookCopy/> }.into_any(), "Book Copy"),
+                (view! { <BookDashed/> }.into_any(), "Book Dashed"),
+                (view! { <BookDown/> }.into_any(), "Book Down"),
+                (view! { <BookHeadphones/> }.into_any(), "Book Headphones"),
+                (view! { <BookHeart/> }.into_any(), "Book Heart"),
+                (view! { <BookImage/> }.into_any(), "Book Image"),
+                (view! { <BookKey/> }.into_any(), "Book Key"),
+                (view! { <BookLock/> }.into_any(), "Book Lock"),
+                (view! { <BookMarked/> }.into_any(), "Book Marked"),
+                (view! { <BookMinus/> }.into_any(), "Book Minus"),
+                (view! { <BookOpenCheck/> }.into_any(), "Book Open Check"),
+                (view! { <BookOpenText/> }.into_any(), "Book Open Text"),
+                (view! { <BookOpen/> }.into_any(), "Book Open"),
+                (view! { <BookPlus/> }.into_any(), "Book Plus"),
+                (view! { <BookText/> }.into_any(), "Book Text"),
+                (view! { <BookType/> }.into_any(), "Book Type"),
+                (view! { <BookUp2/> }.into_any(), "Book Up 2"),
+                (view! { <BookUp/> }.into_any(), "Book Up"),
+                (view! { <BookUser/> }.into_any(), "Book User"),
+                (view! { <BookX/> }.into_any(), "Book X"),
+                (view! { <Book/> }.into_any(), "Book"),
+                (view! { <BookmarkCheck/> }.into_any(), "Bookmark Check"),
+                (view! { <BookmarkMinus/> }.into_any(), "Bookmark Minus"),
+                (view! { <BookmarkPlus/> }.into_any(), "Bookmark Plus"),
+                (view! { <BookmarkX/> }.into_any(), "Bookmark X"),
+                (view! { <Bookmark/> }.into_any(), "Bookmark"),
+                (view! { <BoomBox/> }.into_any(), "Boom Box"),
+                (view! { <BotMessageSquare/> }.into_any(), "Bot Message Square"),
+                (view! { <BotOff/> }.into_any(), "Bot Off"),
+                (view! { <Bot/> }.into_any(), "Bot"),
+                (view! { <Box/> }.into_any(), "Box"),
+                (view! { <Boxes/> }.into_any(), "Boxes"),
+                (view! { <Braces/> }.into_any(), "Braces"),
+                (view! { <Brackets/> }.into_any(), "Brackets"),
+                (view! { <BrainCircuit/> }.into_any(), "Brain Circuit"),
+                (view! { <BrainCog/> }.into_any(), "Brain Cog"),
+                (view! { <Brain/> }.into_any(), "Brain"),
+                (view! { <BrickWall/> }.into_any(), "Brick Wall"),
+                (view! { <BriefcaseBusiness/> }.into_any(), "Briefcase Business"),
+                (view! { <BriefcaseConveyorBelt/> }.into_any(), "Briefcase Conveyor Belt"),
+                (view! { <BriefcaseMedical/> }.into_any(), "Briefcase Medical"),
+                (view! { <Briefcase/> }.into_any(), "Briefcase"),
+                (view! { <BringToFront/> }.into_any(), "Bring To Front"),
+                (view! { <Brush/> }.into_any(), "Brush"),
+                (view! { <BugOff/> }.into_any(), "Bug Off"),
+                (view! { <BugPlay/> }.into_any(), "Bug Play"),
+                (view! { <Bug/> }.into_any(), "Bug"),
+                (view! { <Building2/> }.into_any(), "Building 2"),
+                (view! { <Building/> }.into_any(), "Building"),
+                (view! { <BusFront/> }.into_any(), "Bus Front"),
+                (view! { <Bus/> }.into_any(), "Bus"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsC() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <CableCar/> }.into_any(), "Cable Car"),
+                (view! { <Cable/> }.into_any(), "Cable"),
+                (view! { <CakeSlice/> }.into_any(), "Cake Slice"),
+                (view! { <Cake/> }.into_any(), "Cake"),
+                (view! { <Calculator/> }.into_any(), "Calculator"),
+                (view! { <Calendar1/> }.into_any(), "Calendar 1"),
+                (view! { <CalendarArrowDown/> }.into_any(), "Calendar Arrow Down"),
+                (view! { <CalendarArrowUp/> }.into_any(), "Calendar Arrow Up"),
+                (view! { <CalendarCheck2/> }.into_any(), "Calendar Check 2"),
+                (view! { <CalendarCheck/> }.into_any(), "Calendar Check"),
+                (view! { <CalendarClock/> }.into_any(), "Calendar Clock"),
+                (view! { <CalendarCog/> }.into_any(), "Calendar Cog"),
+                (view! { <CalendarDays/> }.into_any(), "Calendar Days"),
+                (view! { <CalendarFold/> }.into_any(), "Calendar Fold"),
+                (view! { <CalendarHeart/> }.into_any(), "Calendar Heart"),
+                (view! { <CalendarMinus2/> }.into_any(), "Calendar Minus 2"),
+                (view! { <CalendarMinus/> }.into_any(), "Calendar Minus"),
+                (view! { <CalendarOff/> }.into_any(), "Calendar Off"),
+                (view! { <CalendarPlus2/> }.into_any(), "Calendar Plus 2"),
+                (view! { <CalendarPlus/> }.into_any(), "Calendar Plus"),
+                (view! { <CalendarRange/> }.into_any(), "Calendar Range"),
+                (view! { <CalendarSearch/> }.into_any(), "Calendar Search"),
+                (view! { <CalendarX2/> }.into_any(), "Calendar X 2"),
+                (view! { <CalendarX/> }.into_any(), "Calendar X"),
+                (view! { <Calendar/> }.into_any(), "Calendar"),
+                (view! { <CameraOff/> }.into_any(), "Camera Off"),
+                (view! { <Camera/> }.into_any(), "Camera"),
+                (view! { <CandyCane/> }.into_any(), "Candy Cane"),
+                (view! { <CandyOff/> }.into_any(), "Candy Off"),
+                (view! { <Candy/> }.into_any(), "Candy"),
+                (view! { <Cannabis/> }.into_any(), "Cannabis"),
+                (view! { <CaptionsOff/> }.into_any(), "Captions Off"),
+                (view! { <Captions/> }.into_any(), "Captions"),
+                (view! { <CarFront/> }.into_any(), "Car Front"),
+                (view! { <CarTaxiFront/> }.into_any(), "Car Taxi Front"),
+                (view! { <Car/> }.into_any(), "Car"),
+                (view! { <Caravan/> }.into_any(), "Caravan"),
+                (view! { <Carrot/> }.into_any(), "Carrot"),
+                (view! { <CaseLower/> }.into_any(), "Case Lower"),
+                (view! { <CaseSensitive/> }.into_any(), "Case Sensitive"),
+                (view! { <CaseUpper/> }.into_any(), "Case Upper"),
+                (view! { <CassetteTape/> }.into_any(), "Cassette Tape"),
+                (view! { <Cast/> }.into_any(), "Cast"),
+                (view! { <Castle/> }.into_any(), "Castle"),
+                (view! { <Cat/> }.into_any(), "Cat"),
+                (view! { <Cctv/> }.into_any(), "Cctv"),
+                (view! { <ChartArea/> }.into_any(), "Chart Area"),
+                (view! { <ChartBarBig/> }.into_any(), "Chart Bar Big"),
+                (view! { <ChartBarDecreasing/> }.into_any(), "Chart Bar Decreasing"),
+                (view! { <ChartBarIncreasing/> }.into_any(), "Chart Bar Increasing"),
+                (view! { <ChartBarStacked/> }.into_any(), "Chart Bar Stacked"),
+                (view! { <ChartBar/> }.into_any(), "Chart Bar"),
+                (view! { <ChartCandlestick/> }.into_any(), "Chart Candlestick"),
+                (view! { <ChartColumnBig/> }.into_any(), "Chart Column Big"),
+                (view! { <ChartColumnDecreasing/> }.into_any(), "Chart Column Decreasing"),
+                (view! { <ChartColumnIncreasing/> }.into_any(), "Chart Column Increasing"),
+                (view! { <ChartColumnStacked/> }.into_any(), "Chart Column Stacked"),
+                (view! { <ChartColumn/> }.into_any(), "Chart Column"),
+                (view! { <ChartGantt/> }.into_any(), "Chart Gantt"),
+                (view! { <ChartLine/> }.into_any(), "Chart Line"),
+                (view! { <ChartNetwork/> }.into_any(), "Chart Network"),
+                (
+                    view! { <ChartNoAxesColumnDecreasing/> }.into_any(),
+                    "Chart No Axes Column Decreasing",
+                ),
+                (
+                    view! { <ChartNoAxesColumnIncreasing/> }.into_any(),
+                    "Chart No Axes Column Increasing",
+                ),
+                (view! { <ChartNoAxesColumn/> }.into_any(), "Chart No Axes Column"),
+                (view! { <ChartNoAxesCombined/> }.into_any(), "Chart No Axes Combined"),
+                (view! { <ChartNoAxesGantt/> }.into_any(), "Chart No Axes Gantt"),
+                (view! { <ChartPie/> }.into_any(), "Chart Pie"),
+                (view! { <ChartScatter/> }.into_any(), "Chart Scatter"),
+                (view! { <ChartSpline/> }.into_any(), "Chart Spline"),
+                (view! { <CheckCheck/> }.into_any(), "Check Check"),
+                (view! { <Check/> }.into_any(), "Check"),
+                (view! { <ChefHat/> }.into_any(), "Chef Hat"),
+                (view! { <Cherry/> }.into_any(), "Cherry"),
+                (view! { <ChevronDown/> }.into_any(), "Chevron Down"),
+                (view! { <ChevronFirst/> }.into_any(), "Chevron First"),
+                (view! { <ChevronLast/> }.into_any(), "Chevron Last"),
+                (view! { <ChevronLeft/> }.into_any(), "Chevron Left"),
+                (view! { <ChevronRight/> }.into_any(), "Chevron Right"),
+                (view! { <ChevronUp/> }.into_any(), "Chevron Up"),
+                (view! { <ChevronsDownUp/> }.into_any(), "Chevrons Down Up"),
+                (view! { <ChevronsDown/> }.into_any(), "Chevrons Down"),
+                (view! { <ChevronsLeftRightEllipsis/> }.into_any(), "Chevrons Left Right Ellipsis"),
+                (view! { <ChevronsLeftRight/> }.into_any(), "Chevrons Left Right"),
+                (view! { <ChevronsLeft/> }.into_any(), "Chevrons Left"),
+                (view! { <ChevronsRightLeft/> }.into_any(), "Chevrons Right Left"),
+                (view! { <ChevronsRight/> }.into_any(), "Chevrons Right"),
+                (view! { <ChevronsUpDown/> }.into_any(), "Chevrons Up Down"),
+                (view! { <ChevronsUp/> }.into_any(), "Chevrons Up"),
+                (view! { <Chrome/> }.into_any(), "Chrome"),
+                (view! { <Church/> }.into_any(), "Church"),
+                (view! { <CigaretteOff/> }.into_any(), "Cigarette Off"),
+                (view! { <Cigarette/> }.into_any(), "Cigarette"),
+                (view! { <CircleAlert/> }.into_any(), "Circle Alert"),
+                (view! { <CircleArrowDown/> }.into_any(), "Circle Arrow Down"),
+                (view! { <CircleArrowLeft/> }.into_any(), "Circle Arrow Left"),
+                (view! { <CircleArrowOutDownLeft/> }.into_any(), "Circle Arrow Out Down Left"),
+                (view! { <CircleArrowOutDownRight/> }.into_any(), "Circle Arrow Out Down Right"),
+                (view! { <CircleArrowOutUpLeft/> }.into_any(), "Circle Arrow Out Up Left"),
+                (view! { <CircleArrowOutUpRight/> }.into_any(), "Circle Arrow Out Up Right"),
+                (view! { <CircleArrowRight/> }.into_any(), "Circle Arrow Right"),
+                (view! { <CircleArrowUp/> }.into_any(), "Circle Arrow Up"),
+                (view! { <CircleCheckBig/> }.into_any(), "Circle Check Big"),
+                (view! { <CircleCheck/> }.into_any(), "Circle Check"),
+                (view! { <CircleChevronDown/> }.into_any(), "Circle Chevron Down"),
+                (view! { <CircleChevronLeft/> }.into_any(), "Circle Chevron Left"),
+                (view! { <CircleChevronRight/> }.into_any(), "Circle Chevron Right"),
+                (view! { <CircleChevronUp/> }.into_any(), "Circle Chevron Up"),
+                (view! { <CircleDashed/> }.into_any(), "Circle Dashed"),
+                (view! { <CircleDivide/> }.into_any(), "Circle Divide"),
+                (view! { <CircleDollarSign/> }.into_any(), "Circle Dollar Sign"),
+                (view! { <CircleDotDashed/> }.into_any(), "Circle Dot Dashed"),
+                (view! { <CircleDot/> }.into_any(), "Circle Dot"),
+                (view! { <CircleEllipsis/> }.into_any(), "Circle Ellipsis"),
+                (view! { <CircleEqual/> }.into_any(), "Circle Equal"),
+                (view! { <CircleFadingArrowUp/> }.into_any(), "Circle Fading Arrow Up"),
+                (view! { <CircleFadingPlus/> }.into_any(), "Circle Fading Plus"),
+                (view! { <CircleGauge/> }.into_any(), "Circle Gauge"),
+                (view! { <CircleHelp/> }.into_any(), "Circle Help"),
+                (view! { <CircleMinus/> }.into_any(), "Circle Minus"),
+                (view! { <CircleOff/> }.into_any(), "Circle Off"),
+                (view! { <CircleParkingOff/> }.into_any(), "Circle Parking Off"),
+                (view! { <CircleParking/> }.into_any(), "Circle Parking"),
+                (view! { <CirclePause/> }.into_any(), "Circle Pause"),
+                (view! { <CirclePercent/> }.into_any(), "Circle Percent"),
+                (view! { <CirclePlay/> }.into_any(), "Circle Play"),
+                (view! { <CirclePlus/> }.into_any(), "Circle Plus"),
+                (view! { <CirclePower/> }.into_any(), "Circle Power"),
+                (view! { <CircleSlash2/> }.into_any(), "Circle Slash 2"),
+                (view! { <CircleSlash/> }.into_any(), "Circle Slash"),
+                (view! { <CircleStop/> }.into_any(), "Circle Stop"),
+                (view! { <CircleUserRound/> }.into_any(), "Circle User Round"),
+                (view! { <CircleUser/> }.into_any(), "Circle User"),
+                (view! { <CircleX/> }.into_any(), "Circle X"),
+                (view! { <Circle/> }.into_any(), "Circle"),
+                (view! { <CircuitBoard/> }.into_any(), "Circuit Board"),
+                (view! { <Citrus/> }.into_any(), "Citrus"),
+                (view! { <Clapperboard/> }.into_any(), "Clapperboard"),
+                (view! { <ClipboardCheck/> }.into_any(), "Clipboard Check"),
+                (view! { <ClipboardCopy/> }.into_any(), "Clipboard Copy"),
+                (view! { <ClipboardList/> }.into_any(), "Clipboard List"),
+                (view! { <ClipboardMinus/> }.into_any(), "Clipboard Minus"),
+                (view! { <ClipboardPaste/> }.into_any(), "Clipboard Paste"),
+                (view! { <ClipboardPenLine/> }.into_any(), "Clipboard Pen Line"),
+                (view! { <ClipboardPen/> }.into_any(), "Clipboard Pen"),
+                (view! { <ClipboardPlus/> }.into_any(), "Clipboard Plus"),
+                (view! { <ClipboardType/> }.into_any(), "Clipboard Type"),
+                (view! { <ClipboardX/> }.into_any(), "Clipboard X"),
+                (view! { <Clipboard/> }.into_any(), "Clipboard"),
+                (view! { <Clock1/> }.into_any(), "Clock 1"),
+                (view! { <Clock10/> }.into_any(), "Clock 10"),
+                (view! { <Clock11/> }.into_any(), "Clock 11"),
+                (view! { <Clock12/> }.into_any(), "Clock 12"),
+                (view! { <Clock2/> }.into_any(), "Clock 2"),
+                (view! { <Clock3/> }.into_any(), "Clock 3"),
+                (view! { <Clock4/> }.into_any(), "Clock 4"),
+                (view! { <Clock5/> }.into_any(), "Clock 5"),
+                (view! { <Clock6/> }.into_any(), "Clock 6"),
+                (view! { <Clock7/> }.into_any(), "Clock 7"),
+                (view! { <Clock8/> }.into_any(), "Clock 8"),
+                (view! { <Clock9/> }.into_any(), "Clock 9"),
+                (view! { <ClockAlert/> }.into_any(), "Clock Alert"),
+                (view! { <ClockArrowDown/> }.into_any(), "Clock Arrow Down"),
+                (view! { <ClockArrowUp/> }.into_any(), "Clock Arrow Up"),
+                (view! { <Clock/> }.into_any(), "Clock"),
+                (view! { <CloudAlert/> }.into_any(), "Cloud Alert"),
+                (view! { <CloudCog/> }.into_any(), "Cloud Cog"),
+                (view! { <CloudDownload/> }.into_any(), "Cloud Download"),
+                (view! { <CloudDrizzle/> }.into_any(), "Cloud Drizzle"),
+                (view! { <CloudFog/> }.into_any(), "Cloud Fog"),
+                (view! { <CloudHail/> }.into_any(), "Cloud Hail"),
+                (view! { <CloudLightning/> }.into_any(), "Cloud Lightning"),
+                (view! { <CloudMoonRain/> }.into_any(), "Cloud Moon Rain"),
+                (view! { <CloudMoon/> }.into_any(), "Cloud Moon"),
+                (view! { <CloudOff/> }.into_any(), "Cloud Off"),
+                (view! { <CloudRainWind/> }.into_any(), "Cloud Rain Wind"),
+                (view! { <CloudRain/> }.into_any(), "Cloud Rain"),
+                (view! { <CloudSnow/> }.into_any(), "Cloud Snow"),
+                (view! { <CloudSunRain/> }.into_any(), "Cloud Sun Rain"),
+                (view! { <CloudSun/> }.into_any(), "Cloud Sun"),
+                (view! { <CloudUpload/> }.into_any(), "Cloud Upload"),
+                (view! { <Cloud/> }.into_any(), "Cloud"),
+                (view! { <Cloudy/> }.into_any(), "Cloudy"),
+                (view! { <Clover/> }.into_any(), "Clover"),
+                (view! { <Club/> }.into_any(), "Club"),
+                (view! { <CodeXml/> }.into_any(), "Code Xml"),
+                (view! { <Code/> }.into_any(), "Code"),
+                (view! { <Codepen/> }.into_any(), "Codepen"),
+                (view! { <Codesandbox/> }.into_any(), "Codesandbox"),
+                (view! { <Coffee/> }.into_any(), "Coffee"),
+                (view! { <Cog/> }.into_any(), "Cog"),
+                (view! { <Coins/> }.into_any(), "Coins"),
+                (view! { <Columns2/> }.into_any(), "Columns 2"),
+                (view! { <Columns3/> }.into_any(), "Columns 3"),
+                (view! { <Columns4/> }.into_any(), "Columns 4"),
+                (view! { <Combine/> }.into_any(), "Combine"),
+                (view! { <Command/> }.into_any(), "Command"),
+                (view! { <Compass/> }.into_any(), "Compass"),
+                (view! { <Component/> }.into_any(), "Component"),
+                (view! { <Computer/> }.into_any(), "Computer"),
+                (view! { <ConciergeBell/> }.into_any(), "Concierge Bell"),
+                (view! { <Cone/> }.into_any(), "Cone"),
+                (view! { <Construction/> }.into_any(), "Construction"),
+                (view! { <ContactRound/> }.into_any(), "Contact Round"),
+                (view! { <Contact/> }.into_any(), "Contact"),
+                (view! { <Container/> }.into_any(), "Container"),
+                (view! { <Contrast/> }.into_any(), "Contrast"),
+                (view! { <Cookie/> }.into_any(), "Cookie"),
+                (view! { <CookingPot/> }.into_any(), "Cooking Pot"),
+                (view! { <CopyCheck/> }.into_any(), "Copy Check"),
+                (view! { <CopyMinus/> }.into_any(), "Copy Minus"),
+                (view! { <CopyPlus/> }.into_any(), "Copy Plus"),
+                (view! { <CopySlash/> }.into_any(), "Copy Slash"),
+                (view! { <CopyX/> }.into_any(), "Copy X"),
+                (view! { <Copy/> }.into_any(), "Copy"),
+                (view! { <Copyleft/> }.into_any(), "Copyleft"),
+                (view! { <Copyright/> }.into_any(), "Copyright"),
+                (view! { <CornerDownLeft/> }.into_any(), "Corner Down Left"),
+                (view! { <CornerDownRight/> }.into_any(), "Corner Down Right"),
+                (view! { <CornerLeftDown/> }.into_any(), "Corner Left Down"),
+                (view! { <CornerLeftUp/> }.into_any(), "Corner Left Up"),
+                (view! { <CornerRightDown/> }.into_any(), "Corner Right Down"),
+                (view! { <CornerRightUp/> }.into_any(), "Corner Right Up"),
+                (view! { <CornerUpLeft/> }.into_any(), "Corner Up Left"),
+                (view! { <CornerUpRight/> }.into_any(), "Corner Up Right"),
+                (view! { <Cpu/> }.into_any(), "Cpu"),
+                (view! { <CreativeCommons/> }.into_any(), "Creative Commons"),
+                (view! { <CreditCard/> }.into_any(), "Credit Card"),
+                (view! { <Croissant/> }.into_any(), "Croissant"),
+                (view! { <Crop/> }.into_any(), "Crop"),
+                (view! { <Cross/> }.into_any(), "Cross"),
+                (view! { <Crosshair/> }.into_any(), "Crosshair"),
+                (view! { <Crown/> }.into_any(), "Crown"),
+                (view! { <Cuboid/> }.into_any(), "Cuboid"),
+                (view! { <CupSoda/> }.into_any(), "Cup Soda"),
+                (view! { <Currency/> }.into_any(), "Currency"),
+                (view! { <Cylinder/> }.into_any(), "Cylinder"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsD() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Dam/> }.into_any(), "Dam"),
+                (view! { <DatabaseBackup/> }.into_any(), "Database Backup"),
+                (view! { <DatabaseZap/> }.into_any(), "Database Zap"),
+                (view! { <Database/> }.into_any(), "Database"),
+                (view! { <Delete/> }.into_any(), "Delete"),
+                (view! { <Dessert/> }.into_any(), "Dessert"),
+                (view! { <Diameter/> }.into_any(), "Diameter"),
+                (view! { <DiamondMinus/> }.into_any(), "Diamond Minus"),
+                (view! { <DiamondPercent/> }.into_any(), "Diamond Percent"),
+                (view! { <DiamondPlus/> }.into_any(), "Diamond Plus"),
+                (view! { <Diamond/> }.into_any(), "Diamond"),
+                (view! { <Dice1/> }.into_any(), "Dice 1"),
+                (view! { <Dice2/> }.into_any(), "Dice 2"),
+                (view! { <Dice3/> }.into_any(), "Dice 3"),
+                (view! { <Dice4/> }.into_any(), "Dice 4"),
+                (view! { <Dice5/> }.into_any(), "Dice 5"),
+                (view! { <Dice6/> }.into_any(), "Dice 6"),
+                (view! { <Dices/> }.into_any(), "Dices"),
+                (view! { <Diff/> }.into_any(), "Diff"),
+                (view! { <Disc2/> }.into_any(), "Disc 2"),
+                (view! { <Disc3/> }.into_any(), "Disc 3"),
+                (view! { <DiscAlbum/> }.into_any(), "Disc Album"),
+                (view! { <Disc/> }.into_any(), "Disc"),
+                (view! { <Divide/> }.into_any(), "Divide"),
+                (view! { <DnaOff/> }.into_any(), "Dna Off"),
+                (view! { <Dna/> }.into_any(), "Dna"),
+                (view! { <Dock/> }.into_any(), "Dock"),
+                (view! { <Dog/> }.into_any(), "Dog"),
+                (view! { <DollarSign/> }.into_any(), "Dollar Sign"),
+                (view! { <Donut/> }.into_any(), "Donut"),
+                (view! { <DoorClosed/> }.into_any(), "Door Closed"),
+                (view! { <DoorOpen/> }.into_any(), "Door Open"),
+                (view! { <Dot/> }.into_any(), "Dot"),
+                (view! { <Download/> }.into_any(), "Download"),
+                (view! { <DraftingCompass/> }.into_any(), "Drafting Compass"),
+                (view! { <Drama/> }.into_any(), "Drama"),
+                (view! { <Dribbble/> }.into_any(), "Dribbble"),
+                (view! { <Drill/> }.into_any(), "Drill"),
+                (view! { <Droplet/> }.into_any(), "Droplet"),
+                (view! { <Droplets/> }.into_any(), "Droplets"),
+                (view! { <Drum/> }.into_any(), "Drum"),
+                (view! { <Drumstick/> }.into_any(), "Drumstick"),
+                (view! { <Dumbbell/> }.into_any(), "Dumbbell"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsE() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <EarOff/> }.into_any(), "Ear Off"),
+                (view! { <Ear/> }.into_any(), "Ear"),
+                (view! { <EarthLock/> }.into_any(), "Earth Lock"),
+                (view! { <Earth/> }.into_any(), "Earth"),
+                (view! { <Eclipse/> }.into_any(), "Eclipse"),
+                (view! { <EggFried/> }.into_any(), "Egg Fried"),
+                (view! { <EggOff/> }.into_any(), "Egg Off"),
+                (view! { <Egg/> }.into_any(), "Egg"),
+                (view! { <EllipsisVertical/> }.into_any(), "Ellipsis Vertical"),
+                (view! { <Ellipsis/> }.into_any(), "Ellipsis"),
+                (view! { <EqualApproximately/> }.into_any(), "Equal Approximately"),
+                (view! { <EqualNot/> }.into_any(), "Equal Not"),
+                (view! { <Equal/> }.into_any(), "Equal"),
+                (view! { <Eraser/> }.into_any(), "Eraser"),
+                (view! { <EthernetPort/> }.into_any(), "Ethernet Port"),
+                (view! { <Euro/> }.into_any(), "Euro"),
+                (view! { <Expand/> }.into_any(), "Expand"),
+                (view! { <ExternalLink/> }.into_any(), "External Link"),
+                (view! { <EyeClosed/> }.into_any(), "Eye Closed"),
+                (view! { <EyeOff/> }.into_any(), "Eye Off"),
+                (view! { <Eye/> }.into_any(), "Eye"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsF() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Facebook/> }.into_any(), "Facebook"),
+                (view! { <Factory/> }.into_any(), "Factory"),
+                (view! { <Fan/> }.into_any(), "Fan"),
+                (view! { <FastForward/> }.into_any(), "Fast Forward"),
+                (view! { <Feather/> }.into_any(), "Feather"),
+                (view! { <Fence/> }.into_any(), "Fence"),
+                (view! { <FerrisWheel/> }.into_any(), "Ferris Wheel"),
+                (view! { <Figma/> }.into_any(), "Figma"),
+                (view! { <FileArchive/> }.into_any(), "File Archive"),
+                (view! { <FileAudio2/> }.into_any(), "File Audio 2"),
+                (view! { <FileAudio/> }.into_any(), "File Audio"),
+                (view! { <FileAxis3D/> }.into_any(), "File Axis 3 D"),
+                (view! { <FileBadge2/> }.into_any(), "File Badge 2"),
+                (view! { <FileBadge/> }.into_any(), "File Badge"),
+                (view! { <FileBox/> }.into_any(), "File Box"),
+                (view! { <FileChartColumnIncreasing/> }.into_any(), "File Chart Column Increasing"),
+                (view! { <FileChartColumn/> }.into_any(), "File Chart Column"),
+                (view! { <FileChartLine/> }.into_any(), "File Chart Line"),
+                (view! { <FileChartPie/> }.into_any(), "File Chart Pie"),
+                (view! { <FileCheck2/> }.into_any(), "File Check 2"),
+                (view! { <FileCheck/> }.into_any(), "File Check"),
+                (view! { <FileClock/> }.into_any(), "File Clock"),
+                (view! { <FileCode2/> }.into_any(), "File Code 2"),
+                (view! { <FileCode/> }.into_any(), "File Code"),
+                (view! { <FileCog/> }.into_any(), "File Cog"),
+                (view! { <FileDiff/> }.into_any(), "File Diff"),
+                (view! { <FileDigit/> }.into_any(), "File Digit"),
+                (view! { <FileDown/> }.into_any(), "File Down"),
+                (view! { <FileHeart/> }.into_any(), "File Heart"),
+                (view! { <FileImage/> }.into_any(), "File Image"),
+                (view! { <FileInput/> }.into_any(), "File Input"),
+                (view! { <FileJson2/> }.into_any(), "File Json 2"),
+                (view! { <FileJson/> }.into_any(), "File Json"),
+                (view! { <FileKey2/> }.into_any(), "File Key 2"),
+                (view! { <FileKey/> }.into_any(), "File Key"),
+                (view! { <FileLock2/> }.into_any(), "File Lock 2"),
+                (view! { <FileLock/> }.into_any(), "File Lock"),
+                (view! { <FileMinus2/> }.into_any(), "File Minus 2"),
+                (view! { <FileMinus/> }.into_any(), "File Minus"),
+                (view! { <FileMusic/> }.into_any(), "File Music"),
+                (view! { <FileOutput/> }.into_any(), "File Output"),
+                (view! { <FilePenLine/> }.into_any(), "File Pen Line"),
+                (view! { <FilePen/> }.into_any(), "File Pen"),
+                (view! { <FilePlus2/> }.into_any(), "File Plus 2"),
+                (view! { <FilePlus/> }.into_any(), "File Plus"),
+                (view! { <FileQuestion/> }.into_any(), "File Question"),
+                (view! { <FileScan/> }.into_any(), "File Scan"),
+                (view! { <FileSearch2/> }.into_any(), "File Search 2"),
+                (view! { <FileSearch/> }.into_any(), "File Search"),
+                (view! { <FileSliders/> }.into_any(), "File Sliders"),
+                (view! { <FileSpreadsheet/> }.into_any(), "File Spreadsheet"),
+                (view! { <FileStack/> }.into_any(), "File Stack"),
+                (view! { <FileSymlink/> }.into_any(), "File Symlink"),
+                (view! { <FileTerminal/> }.into_any(), "File Terminal"),
+                (view! { <FileText/> }.into_any(), "File Text"),
+                (view! { <FileType2/> }.into_any(), "File Type 2"),
+                (view! { <FileType/> }.into_any(), "File Type"),
+                (view! { <FileUp/> }.into_any(), "File Up"),
+                (view! { <FileUser/> }.into_any(), "File User"),
+                (view! { <FileVideo2/> }.into_any(), "File Video 2"),
+                (view! { <FileVideo/> }.into_any(), "File Video"),
+                (view! { <FileVolume2/> }.into_any(), "File Volume 2"),
+                (view! { <FileVolume/> }.into_any(), "File Volume"),
+                (view! { <FileWarning/> }.into_any(), "File Warning"),
+                (view! { <FileX2/> }.into_any(), "File X 2"),
+                (view! { <FileX/> }.into_any(), "File X"),
+                (view! { <File/> }.into_any(), "File"),
+                (view! { <Files/> }.into_any(), "Files"),
+                (view! { <Film/> }.into_any(), "Film"),
+                (view! { <FilterX/> }.into_any(), "Filter X"),
+                (view! { <Filter/> }.into_any(), "Filter"),
+                (view! { <Fingerprint/> }.into_any(), "Fingerprint"),
+                (view! { <FireExtinguisher/> }.into_any(), "Fire Extinguisher"),
+                (view! { <FishOff/> }.into_any(), "Fish Off"),
+                (view! { <FishSymbol/> }.into_any(), "Fish Symbol"),
+                (view! { <Fish/> }.into_any(), "Fish"),
+                (view! { <FlagOff/> }.into_any(), "Flag Off"),
+                (view! { <FlagTriangleLeft/> }.into_any(), "Flag Triangle Left"),
+                (view! { <FlagTriangleRight/> }.into_any(), "Flag Triangle Right"),
+                (view! { <Flag/> }.into_any(), "Flag"),
+                (view! { <FlameKindling/> }.into_any(), "Flame Kindling"),
+                (view! { <Flame/> }.into_any(), "Flame"),
+                (view! { <FlashlightOff/> }.into_any(), "Flashlight Off"),
+                (view! { <Flashlight/> }.into_any(), "Flashlight"),
+                (view! { <FlaskConicalOff/> }.into_any(), "Flask Conical Off"),
+                (view! { <FlaskConical/> }.into_any(), "Flask Conical"),
+                (view! { <FlaskRound/> }.into_any(), "Flask Round"),
+                (view! { <FlipHorizontal2/> }.into_any(), "Flip Horizontal 2"),
+                (view! { <FlipHorizontal/> }.into_any(), "Flip Horizontal"),
+                (view! { <FlipVertical2/> }.into_any(), "Flip Vertical 2"),
+                (view! { <FlipVertical/> }.into_any(), "Flip Vertical"),
+                (view! { <Flower2/> }.into_any(), "Flower 2"),
+                (view! { <Flower/> }.into_any(), "Flower"),
+                (view! { <Focus/> }.into_any(), "Focus"),
+                (view! { <FoldHorizontal/> }.into_any(), "Fold Horizontal"),
+                (view! { <FoldVertical/> }.into_any(), "Fold Vertical"),
+                (view! { <FolderArchive/> }.into_any(), "Folder Archive"),
+                (view! { <FolderCheck/> }.into_any(), "Folder Check"),
+                (view! { <FolderClock/> }.into_any(), "Folder Clock"),
+                (view! { <FolderClosed/> }.into_any(), "Folder Closed"),
+                (view! { <FolderCode/> }.into_any(), "Folder Code"),
+                (view! { <FolderCog/> }.into_any(), "Folder Cog"),
+                (view! { <FolderDot/> }.into_any(), "Folder Dot"),
+                (view! { <FolderDown/> }.into_any(), "Folder Down"),
+                (view! { <FolderGit2/> }.into_any(), "Folder Git 2"),
+                (view! { <FolderGit/> }.into_any(), "Folder Git"),
+                (view! { <FolderHeart/> }.into_any(), "Folder Heart"),
+                (view! { <FolderInput/> }.into_any(), "Folder Input"),
+                (view! { <FolderKanban/> }.into_any(), "Folder Kanban"),
+                (view! { <FolderKey/> }.into_any(), "Folder Key"),
+                (view! { <FolderLock/> }.into_any(), "Folder Lock"),
+                (view! { <FolderMinus/> }.into_any(), "Folder Minus"),
+                (view! { <FolderOpenDot/> }.into_any(), "Folder Open Dot"),
+                (view! { <FolderOpen/> }.into_any(), "Folder Open"),
+                (view! { <FolderOutput/> }.into_any(), "Folder Output"),
+                (view! { <FolderPen/> }.into_any(), "Folder Pen"),
+                (view! { <FolderPlus/> }.into_any(), "Folder Plus"),
+                (view! { <FolderRoot/> }.into_any(), "Folder Root"),
+                (view! { <FolderSearch2/> }.into_any(), "Folder Search 2"),
+                (view! { <FolderSearch/> }.into_any(), "Folder Search"),
+                (view! { <FolderSymlink/> }.into_any(), "Folder Symlink"),
+                (view! { <FolderSync/> }.into_any(), "Folder Sync"),
+                (view! { <FolderTree/> }.into_any(), "Folder Tree"),
+                (view! { <FolderUp/> }.into_any(), "Folder Up"),
+                (view! { <FolderX/> }.into_any(), "Folder X"),
+                (view! { <Folder/> }.into_any(), "Folder"),
+                (view! { <Folders/> }.into_any(), "Folders"),
+                (view! { <Footprints/> }.into_any(), "Footprints"),
+                (view! { <Forklift/> }.into_any(), "Forklift"),
+                (view! { <Forward/> }.into_any(), "Forward"),
+                (view! { <Frame/> }.into_any(), "Frame"),
+                (view! { <Framer/> }.into_any(), "Framer"),
+                (view! { <Frown/> }.into_any(), "Frown"),
+                (view! { <Fuel/> }.into_any(), "Fuel"),
+                (view! { <Fullscreen/> }.into_any(), "Fullscreen"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsG() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <GalleryHorizontalEnd/> }.into_any(), "Gallery Horizontal End"),
+                (view! { <GalleryHorizontal/> }.into_any(), "Gallery Horizontal"),
+                (view! { <GalleryThumbnails/> }.into_any(), "Gallery Thumbnails"),
+                (view! { <GalleryVerticalEnd/> }.into_any(), "Gallery Vertical End"),
+                (view! { <GalleryVertical/> }.into_any(), "Gallery Vertical"),
+                (view! { <Gamepad2/> }.into_any(), "Gamepad 2"),
+                (view! { <Gamepad/> }.into_any(), "Gamepad"),
+                (view! { <Gauge/> }.into_any(), "Gauge"),
+                (view! { <Gavel/> }.into_any(), "Gavel"),
+                (view! { <Gem/> }.into_any(), "Gem"),
+                (view! { <Ghost/> }.into_any(), "Ghost"),
+                (view! { <Gift/> }.into_any(), "Gift"),
+                (view! { <GitBranchPlus/> }.into_any(), "Git Branch Plus"),
+                (view! { <GitBranch/> }.into_any(), "Git Branch"),
+                (view! { <GitCommitHorizontal/> }.into_any(), "Git Commit Horizontal"),
+                (view! { <GitCommitVertical/> }.into_any(), "Git Commit Vertical"),
+                (view! { <GitCompareArrows/> }.into_any(), "Git Compare Arrows"),
+                (view! { <GitCompare/> }.into_any(), "Git Compare"),
+                (view! { <GitFork/> }.into_any(), "Git Fork"),
+                (view! { <GitGraph/> }.into_any(), "Git Graph"),
+                (view! { <GitMerge/> }.into_any(), "Git Merge"),
+                (view! { <GitPullRequestArrow/> }.into_any(), "Git Pull Request Arrow"),
+                (view! { <GitPullRequestClosed/> }.into_any(), "Git Pull Request Closed"),
+                (
+                    view! { <GitPullRequestCreateArrow/> }.into_any(),
+                    "Git Pull Request Create Arrow",
+                ),
+                (view! { <GitPullRequestCreate/> }.into_any(), "Git Pull Request Create"),
+                (view! { <GitPullRequestDraft/> }.into_any(), "Git Pull Request Draft"),
+                (view! { <GitPullRequest/> }.into_any(), "Git Pull Request"),
+                (view! { <Github/> }.into_any(), "Github"),
+                (view! { <Gitlab/> }.into_any(), "Gitlab"),
+                (view! { <GlassWater/> }.into_any(), "Glass Water"),
+                (view! { <Glasses/> }.into_any(), "Glasses"),
+                (view! { <GlobeLock/> }.into_any(), "Globe Lock"),
+                (view! { <Globe/> }.into_any(), "Globe"),
+                (view! { <Goal/> }.into_any(), "Goal"),
+                (view! { <Grab/> }.into_any(), "Grab"),
+                (view! { <GraduationCap/> }.into_any(), "Graduation Cap"),
+                (view! { <Grape/> }.into_any(), "Grape"),
+                (view! { <Grid2X2Check/> }.into_any(), "Grid 2 X 2 Check"),
+                (view! { <Grid2X2Plus/> }.into_any(), "Grid 2 X 2 Plus"),
+                (view! { <Grid2X2X/> }.into_any(), "Grid 2 X 2 X"),
+                (view! { <Grid2X2/> }.into_any(), "Grid 2 X 2"),
+                (view! { <Grid3X3/> }.into_any(), "Grid 3 X 3"),
+                (view! { <GripHorizontal/> }.into_any(), "Grip Horizontal"),
+                (view! { <GripVertical/> }.into_any(), "Grip Vertical"),
+                (view! { <Grip/> }.into_any(), "Grip"),
+                (view! { <Group/> }.into_any(), "Group"),
+                (view! { <Guitar/> }.into_any(), "Guitar"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsH() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Ham/> }.into_any(), "Ham"),
+                (view! { <Hammer/> }.into_any(), "Hammer"),
+                (view! { <HandCoins/> }.into_any(), "Hand Coins"),
+                (view! { <HandHeart/> }.into_any(), "Hand Heart"),
+                (view! { <HandHelping/> }.into_any(), "Hand Helping"),
+                (view! { <HandMetal/> }.into_any(), "Hand Metal"),
+                (view! { <HandPlatter/> }.into_any(), "Hand Platter"),
+                (view! { <Hand/> }.into_any(), "Hand"),
+                (view! { <Handshake/> }.into_any(), "Handshake"),
+                (view! { <HardDriveDownload/> }.into_any(), "Hard Drive Download"),
+                (view! { <HardDriveUpload/> }.into_any(), "Hard Drive Upload"),
+                (view! { <HardDrive/> }.into_any(), "Hard Drive"),
+                (view! { <HardHat/> }.into_any(), "Hard Hat"),
+                (view! { <Hash/> }.into_any(), "Hash"),
+                (view! { <Haze/> }.into_any(), "Haze"),
+                (view! { <HdmiPort/> }.into_any(), "Hdmi Port"),
+                (view! { <Heading1/> }.into_any(), "Heading 1"),
+                (view! { <Heading2/> }.into_any(), "Heading 2"),
+                (view! { <Heading3/> }.into_any(), "Heading 3"),
+                (view! { <Heading4/> }.into_any(), "Heading 4"),
+                (view! { <Heading5/> }.into_any(), "Heading 5"),
+                (view! { <Heading6/> }.into_any(), "Heading 6"),
+                (view! { <Heading/> }.into_any(), "Heading"),
+                (view! { <HeadphoneOff/> }.into_any(), "Headphone Off"),
+                (view! { <Headphones/> }.into_any(), "Headphones"),
+                (view! { <Headset/> }.into_any(), "Headset"),
+                (view! { <HeartCrack/> }.into_any(), "Heart Crack"),
+                (view! { <HeartHandshake/> }.into_any(), "Heart Handshake"),
+                (view! { <HeartOff/> }.into_any(), "Heart Off"),
+                (view! { <HeartPulse/> }.into_any(), "Heart Pulse"),
+                (view! { <Heart/> }.into_any(), "Heart"),
+                (view! { <Heater/> }.into_any(), "Heater"),
+                (view! { <Hexagon/> }.into_any(), "Hexagon"),
+                (view! { <Highlighter/> }.into_any(), "Highlighter"),
+                (view! { <History/> }.into_any(), "History"),
+                (view! { <HopOff/> }.into_any(), "Hop Off"),
+                (view! { <Hop/> }.into_any(), "Hop"),
+                (view! { <Hospital/> }.into_any(), "Hospital"),
+                (view! { <Hotel/> }.into_any(), "Hotel"),
+                (view! { <Hourglass/> }.into_any(), "Hourglass"),
+                (view! { <HousePlug/> }.into_any(), "House Plug"),
+                (view! { <HousePlus/> }.into_any(), "House Plus"),
+                (view! { <House/> }.into_any(), "House"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsI() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <IceCreamBowl/> }.into_any(), "Ice Cream Bowl"),
+                (view! { <IceCreamCone/> }.into_any(), "Ice Cream Cone"),
+                (view! { <IdCard/> }.into_any(), "Id Card"),
+                (view! { <ImageDown/> }.into_any(), "Image Down"),
+                (view! { <ImageMinus/> }.into_any(), "Image Minus"),
+                (view! { <ImageOff/> }.into_any(), "Image Off"),
+                (view! { <ImagePlay/> }.into_any(), "Image Play"),
+                (view! { <ImagePlus/> }.into_any(), "Image Plus"),
+                (view! { <ImageUp/> }.into_any(), "Image Up"),
+                (view! { <Image/> }.into_any(), "Image"),
+                (view! { <Images/> }.into_any(), "Images"),
+                (view! { <Import/> }.into_any(), "Import"),
+                (view! { <Inbox/> }.into_any(), "Inbox"),
+                (view! { <IndentDecrease/> }.into_any(), "Indent Decrease"),
+                (view! { <IndentIncrease/> }.into_any(), "Indent Increase"),
+                (view! { <IndianRupee/> }.into_any(), "Indian Rupee"),
+                (view! { <Infinity/> }.into_any(), "Infinity"),
+                (view! { <Info/> }.into_any(), "Info"),
+                (view! { <InspectionPanel/> }.into_any(), "Inspection Panel"),
+                (view! { <Instagram/> }.into_any(), "Instagram"),
+                (view! { <Italic/> }.into_any(), "Italic"),
+                (view! { <IterationCcw/> }.into_any(), "Iteration Ccw"),
+                (view! { <IterationCw/> }.into_any(), "Iteration Cw"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsJ() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <JapaneseYen/> }.into_any(), "Japanese Yen"),
+                (view! { <Joystick/> }.into_any(), "Joystick"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsK() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Kanban/> }.into_any(), "Kanban"),
+                (view! { <KeyRound/> }.into_any(), "Key Round"),
+                (view! { <KeySquare/> }.into_any(), "Key Square"),
+                (view! { <Key/> }.into_any(), "Key"),
+                (view! { <KeyboardMusic/> }.into_any(), "Keyboard Music"),
+                (view! { <KeyboardOff/> }.into_any(), "Keyboard Off"),
+                (view! { <Keyboard/> }.into_any(), "Keyboard"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsL() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <LampCeiling/> }.into_any(), "Lamp Ceiling"),
+                (view! { <LampDesk/> }.into_any(), "Lamp Desk"),
+                (view! { <LampFloor/> }.into_any(), "Lamp Floor"),
+                (view! { <LampWallDown/> }.into_any(), "Lamp Wall Down"),
+                (view! { <LampWallUp/> }.into_any(), "Lamp Wall Up"),
+                (view! { <Lamp/> }.into_any(), "Lamp"),
+                (view! { <LandPlot/> }.into_any(), "Land Plot"),
+                (view! { <Landmark/> }.into_any(), "Landmark"),
+                (view! { <Languages/> }.into_any(), "Languages"),
+                (view! { <LaptopMinimalCheck/> }.into_any(), "Laptop Minimal Check"),
+                (view! { <LaptopMinimal/> }.into_any(), "Laptop Minimal"),
+                (view! { <Laptop/> }.into_any(), "Laptop"),
+                (view! { <LassoSelect/> }.into_any(), "Lasso Select"),
+                (view! { <Lasso/> }.into_any(), "Lasso"),
+                (view! { <Laugh/> }.into_any(), "Laugh"),
+                (view! { <Layers2/> }.into_any(), "Layers 2"),
+                (view! { <Layers3/> }.into_any(), "Layers 3"),
+                (view! { <Layers/> }.into_any(), "Layers"),
+                (view! { <LayoutDashboard/> }.into_any(), "Layout Dashboard"),
+                (view! { <LayoutGrid/> }.into_any(), "Layout Grid"),
+                (view! { <LayoutList/> }.into_any(), "Layout List"),
+                (view! { <LayoutPanelLeft/> }.into_any(), "Layout Panel Left"),
+                (view! { <LayoutPanelTop/> }.into_any(), "Layout Panel Top"),
+                (view! { <LayoutTemplate/> }.into_any(), "Layout Template"),
+                (view! { <Leaf/> }.into_any(), "Leaf"),
+                (view! { <LeafyGreen/> }.into_any(), "Leafy Green"),
+                (view! { <Lectern/> }.into_any(), "Lectern"),
+                (view! { <LetterText/> }.into_any(), "Letter Text"),
+                (view! { <LibraryBig/> }.into_any(), "Library Big"),
+                (view! { <Library/> }.into_any(), "Library"),
+                (view! { <LifeBuoy/> }.into_any(), "Life Buoy"),
+                (view! { <Ligature/> }.into_any(), "Ligature"),
+                (view! { <LightbulbOff/> }.into_any(), "Lightbulb Off"),
+                (view! { <Lightbulb/> }.into_any(), "Lightbulb"),
+                (view! { <Link2Off/> }.into_any(), "Link 2 Off"),
+                (view! { <Link2/> }.into_any(), "Link 2"),
+                (view! { <Link/> }.into_any(), "Link"),
+                (view! { <Linkedin/> }.into_any(), "Linkedin"),
+                (view! { <ListCheck/> }.into_any(), "List Check"),
+                (view! { <ListChecks/> }.into_any(), "List Checks"),
+                (view! { <ListCollapse/> }.into_any(), "List Collapse"),
+                (view! { <ListEnd/> }.into_any(), "List End"),
+                (view! { <ListFilter/> }.into_any(), "List Filter"),
+                (view! { <ListMinus/> }.into_any(), "List Minus"),
+                (view! { <ListMusic/> }.into_any(), "List Music"),
+                (view! { <ListOrdered/> }.into_any(), "List Ordered"),
+                (view! { <ListPlus/> }.into_any(), "List Plus"),
+                (view! { <ListRestart/> }.into_any(), "List Restart"),
+                (view! { <ListStart/> }.into_any(), "List Start"),
+                (view! { <ListTodo/> }.into_any(), "List Todo"),
+                (view! { <ListTree/> }.into_any(), "List Tree"),
+                (view! { <ListVideo/> }.into_any(), "List Video"),
+                (view! { <ListX/> }.into_any(), "List X"),
+                (view! { <List/> }.into_any(), "List"),
+                (view! { <LoaderCircle/> }.into_any(), "Loader Circle"),
+                (view! { <LoaderPinwheel/> }.into_any(), "Loader Pinwheel"),
+                (view! { <Loader/> }.into_any(), "Loader"),
+                (view! { <LocateFixed/> }.into_any(), "Locate Fixed"),
+                (view! { <LocateOff/> }.into_any(), "Locate Off"),
+                (view! { <Locate/> }.into_any(), "Locate"),
+                (view! { <LockKeyholeOpen/> }.into_any(), "Lock Keyhole Open"),
+                (view! { <LockKeyhole/> }.into_any(), "Lock Keyhole"),
+                (view! { <LockOpen/> }.into_any(), "Lock Open"),
+                (view! { <Lock/> }.into_any(), "Lock"),
+                (view! { <LogIn/> }.into_any(), "Log In"),
+                (view! { <LogOut/> }.into_any(), "Log Out"),
+                (view! { <Logs/> }.into_any(), "Logs"),
+                (view! { <Lollipop/> }.into_any(), "Lollipop"),
+                (view! { <Luggage/> }.into_any(), "Luggage"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsM() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Magnet/> }.into_any(), "Magnet"),
+                (view! { <MailCheck/> }.into_any(), "Mail Check"),
+                (view! { <MailMinus/> }.into_any(), "Mail Minus"),
+                (view! { <MailOpen/> }.into_any(), "Mail Open"),
+                (view! { <MailPlus/> }.into_any(), "Mail Plus"),
+                (view! { <MailQuestion/> }.into_any(), "Mail Question"),
+                (view! { <MailSearch/> }.into_any(), "Mail Search"),
+                (view! { <MailWarning/> }.into_any(), "Mail Warning"),
+                (view! { <MailX/> }.into_any(), "Mail X"),
+                (view! { <Mail/> }.into_any(), "Mail"),
+                (view! { <Mailbox/> }.into_any(), "Mailbox"),
+                (view! { <Mails/> }.into_any(), "Mails"),
+                (view! { <MapPinCheckInside/> }.into_any(), "Map Pin Check Inside"),
+                (view! { <MapPinCheck/> }.into_any(), "Map Pin Check"),
+                (view! { <MapPinHouse/> }.into_any(), "Map Pin House"),
+                (view! { <MapPinMinusInside/> }.into_any(), "Map Pin Minus Inside"),
+                (view! { <MapPinMinus/> }.into_any(), "Map Pin Minus"),
+                (view! { <MapPinOff/> }.into_any(), "Map Pin Off"),
+                (view! { <MapPinPlusInside/> }.into_any(), "Map Pin Plus Inside"),
+                (view! { <MapPinPlus/> }.into_any(), "Map Pin Plus"),
+                (view! { <MapPinXInside/> }.into_any(), "Map Pin X Inside"),
+                (view! { <MapPinX/> }.into_any(), "Map Pin X"),
+                (view! { <MapPin/> }.into_any(), "Map Pin"),
+                (view! { <MapPinned/> }.into_any(), "Map Pinned"),
+                (view! { <Map/> }.into_any(), "Map"),
+                (view! { <Martini/> }.into_any(), "Martini"),
+                (view! { <Maximize2/> }.into_any(), "Maximize 2"),
+                (view! { <Maximize/> }.into_any(), "Maximize"),
+                (view! { <Medal/> }.into_any(), "Medal"),
+                (view! { <MegaphoneOff/> }.into_any(), "Megaphone Off"),
+                (view! { <Megaphone/> }.into_any(), "Megaphone"),
+                (view! { <Meh/> }.into_any(), "Meh"),
+                (view! { <MemoryStick/> }.into_any(), "Memory Stick"),
+                (view! { <Menu/> }.into_any(), "Menu"),
+                (view! { <Merge/> }.into_any(), "Merge"),
+                (view! { <MessageCircleCode/> }.into_any(), "Message Circle Code"),
+                (view! { <MessageCircleDashed/> }.into_any(), "Message Circle Dashed"),
+                (view! { <MessageCircleHeart/> }.into_any(), "Message Circle Heart"),
+                (view! { <MessageCircleMore/> }.into_any(), "Message Circle More"),
+                (view! { <MessageCircleOff/> }.into_any(), "Message Circle Off"),
+                (view! { <MessageCirclePlus/> }.into_any(), "Message Circle Plus"),
+                (view! { <MessageCircleQuestion/> }.into_any(), "Message Circle Question"),
+                (view! { <MessageCircleReply/> }.into_any(), "Message Circle Reply"),
+                (view! { <MessageCircleWarning/> }.into_any(), "Message Circle Warning"),
+                (view! { <MessageCircleX/> }.into_any(), "Message Circle X"),
+                (view! { <MessageCircle/> }.into_any(), "Message Circle"),
+                (view! { <MessageSquareCode/> }.into_any(), "Message Square Code"),
+                (view! { <MessageSquareDashed/> }.into_any(), "Message Square Dashed"),
+                (view! { <MessageSquareDiff/> }.into_any(), "Message Square Diff"),
+                (view! { <MessageSquareDot/> }.into_any(), "Message Square Dot"),
+                (view! { <MessageSquareHeart/> }.into_any(), "Message Square Heart"),
+                (view! { <MessageSquareLock/> }.into_any(), "Message Square Lock"),
+                (view! { <MessageSquareMore/> }.into_any(), "Message Square More"),
+                (view! { <MessageSquareOff/> }.into_any(), "Message Square Off"),
+                (view! { <MessageSquarePlus/> }.into_any(), "Message Square Plus"),
+                (view! { <MessageSquareQuote/> }.into_any(), "Message Square Quote"),
+                (view! { <MessageSquareReply/> }.into_any(), "Message Square Reply"),
+                (view! { <MessageSquareShare/> }.into_any(), "Message Square Share"),
+                (view! { <MessageSquareText/> }.into_any(), "Message Square Text"),
+                (view! { <MessageSquareWarning/> }.into_any(), "Message Square Warning"),
+                (view! { <MessageSquareX/> }.into_any(), "Message Square X"),
+                (view! { <MessageSquare/> }.into_any(), "Message Square"),
+                (view! { <MessagesSquare/> }.into_any(), "Messages Square"),
+                (view! { <MicOff/> }.into_any(), "Mic Off"),
+                (view! { <MicVocal/> }.into_any(), "Mic Vocal"),
+                (view! { <Mic/> }.into_any(), "Mic"),
+                (view! { <Microchip/> }.into_any(), "Microchip"),
+                (view! { <Microscope/> }.into_any(), "Microscope"),
+                (view! { <Microwave/> }.into_any(), "Microwave"),
+                (view! { <Milestone/> }.into_any(), "Milestone"),
+                (view! { <MilkOff/> }.into_any(), "Milk Off"),
+                (view! { <Milk/> }.into_any(), "Milk"),
+                (view! { <Minimize2/> }.into_any(), "Minimize 2"),
+                (view! { <Minimize/> }.into_any(), "Minimize"),
+                (view! { <Minus/> }.into_any(), "Minus"),
+                (view! { <MonitorCheck/> }.into_any(), "Monitor Check"),
+                (view! { <MonitorCog/> }.into_any(), "Monitor Cog"),
+                (view! { <MonitorDot/> }.into_any(), "Monitor Dot"),
+                (view! { <MonitorDown/> }.into_any(), "Monitor Down"),
+                (view! { <MonitorOff/> }.into_any(), "Monitor Off"),
+                (view! { <MonitorPause/> }.into_any(), "Monitor Pause"),
+                (view! { <MonitorPlay/> }.into_any(), "Monitor Play"),
+                (view! { <MonitorSmartphone/> }.into_any(), "Monitor Smartphone"),
+                (view! { <MonitorSpeaker/> }.into_any(), "Monitor Speaker"),
+                (view! { <MonitorStop/> }.into_any(), "Monitor Stop"),
+                (view! { <MonitorUp/> }.into_any(), "Monitor Up"),
+                (view! { <MonitorX/> }.into_any(), "Monitor X"),
+                (view! { <Monitor/> }.into_any(), "Monitor"),
+                (view! { <MoonStar/> }.into_any(), "Moon Star"),
+                (view! { <Moon/> }.into_any(), "Moon"),
+                (view! { <MountainSnow/> }.into_any(), "Mountain Snow"),
+                (view! { <Mountain/> }.into_any(), "Mountain"),
+                (view! { <MouseOff/> }.into_any(), "Mouse Off"),
+                (view! { <MousePointer2/> }.into_any(), "Mouse Pointer 2"),
+                (view! { <MousePointerBan/> }.into_any(), "Mouse Pointer Ban"),
+                (view! { <MousePointerClick/> }.into_any(), "Mouse Pointer Click"),
+                (view! { <MousePointer/> }.into_any(), "Mouse Pointer"),
+                (view! { <Mouse/> }.into_any(), "Mouse"),
+                (view! { <Move3D/> }.into_any(), "Move 3 D"),
+                (view! { <MoveDiagonal2/> }.into_any(), "Move Diagonal 2"),
+                (view! { <MoveDiagonal/> }.into_any(), "Move Diagonal"),
+                (view! { <MoveDownLeft/> }.into_any(), "Move Down Left"),
+                (view! { <MoveDownRight/> }.into_any(), "Move Down Right"),
+                (view! { <MoveDown/> }.into_any(), "Move Down"),
+                (view! { <MoveHorizontal/> }.into_any(), "Move Horizontal"),
+                (view! { <MoveLeft/> }.into_any(), "Move Left"),
+                (view! { <MoveRight/> }.into_any(), "Move Right"),
+                (view! { <MoveUpLeft/> }.into_any(), "Move Up Left"),
+                (view! { <MoveUpRight/> }.into_any(), "Move Up Right"),
+                (view! { <MoveUp/> }.into_any(), "Move Up"),
+                (view! { <MoveVertical/> }.into_any(), "Move Vertical"),
+                (view! { <Move/> }.into_any(), "Move"),
+                (view! { <Music2/> }.into_any(), "Music 2"),
+                (view! { <Music3/> }.into_any(), "Music 3"),
+                (view! { <Music4/> }.into_any(), "Music 4"),
+                (view! { <Music/> }.into_any(), "Music"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsN() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Navigation2Off/> }.into_any(), "Navigation 2 Off"),
+                (view! { <Navigation2/> }.into_any(), "Navigation 2"),
+                (view! { <NavigationOff/> }.into_any(), "Navigation Off"),
+                (view! { <Navigation/> }.into_any(), "Navigation"),
+                (view! { <Network/> }.into_any(), "Network"),
+                (view! { <Newspaper/> }.into_any(), "Newspaper"),
+                (view! { <Nfc/> }.into_any(), "Nfc"),
+                (view! { <NotebookPen/> }.into_any(), "Notebook Pen"),
+                (view! { <NotebookTabs/> }.into_any(), "Notebook Tabs"),
+                (view! { <NotebookText/> }.into_any(), "Notebook Text"),
+                (view! { <Notebook/> }.into_any(), "Notebook"),
+                (view! { <NotepadTextDashed/> }.into_any(), "Notepad Text Dashed"),
+                (view! { <NotepadText/> }.into_any(), "Notepad Text"),
+                (view! { <NutOff/> }.into_any(), "Nut Off"),
+                (view! { <Nut/> }.into_any(), "Nut"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsO() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <OctagonAlert/> }.into_any(), "Octagon Alert"),
+                (view! { <OctagonMinus/> }.into_any(), "Octagon Minus"),
+                (view! { <OctagonPause/> }.into_any(), "Octagon Pause"),
+                (view! { <OctagonX/> }.into_any(), "Octagon X"),
+                (view! { <Octagon/> }.into_any(), "Octagon"),
+                (view! { <Omega/> }.into_any(), "Omega"),
+                (view! { <Option/> }.into_any(), "Option"),
+                (view! { <Orbit/> }.into_any(), "Orbit"),
+                (view! { <Origami/> }.into_any(), "Origami"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsP() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Package2/> }.into_any(), "Package 2"),
+                (view! { <PackageCheck/> }.into_any(), "Package Check"),
+                (view! { <PackageMinus/> }.into_any(), "Package Minus"),
+                (view! { <PackageOpen/> }.into_any(), "Package Open"),
+                (view! { <PackagePlus/> }.into_any(), "Package Plus"),
+                (view! { <PackageSearch/> }.into_any(), "Package Search"),
+                (view! { <PackageX/> }.into_any(), "Package X"),
+                (view! { <Package/> }.into_any(), "Package"),
+                (view! { <PaintBucket/> }.into_any(), "Paint Bucket"),
+                (view! { <PaintRoller/> }.into_any(), "Paint Roller"),
+                (view! { <PaintbrushVertical/> }.into_any(), "Paintbrush Vertical"),
+                (view! { <Paintbrush/> }.into_any(), "Paintbrush"),
+                (view! { <Palette/> }.into_any(), "Palette"),
+                (view! { <PanelBottomClose/> }.into_any(), "Panel Bottom Close"),
+                (view! { <PanelBottomDashed/> }.into_any(), "Panel Bottom Dashed"),
+                (view! { <PanelBottomOpen/> }.into_any(), "Panel Bottom Open"),
+                (view! { <PanelBottom/> }.into_any(), "Panel Bottom"),
+                (view! { <PanelLeftClose/> }.into_any(), "Panel Left Close"),
+                (view! { <PanelLeftDashed/> }.into_any(), "Panel Left Dashed"),
+                (view! { <PanelLeftOpen/> }.into_any(), "Panel Left Open"),
+                (view! { <PanelLeft/> }.into_any(), "Panel Left"),
+                (view! { <PanelRightClose/> }.into_any(), "Panel Right Close"),
+                (view! { <PanelRightDashed/> }.into_any(), "Panel Right Dashed"),
+                (view! { <PanelRightOpen/> }.into_any(), "Panel Right Open"),
+                (view! { <PanelRight/> }.into_any(), "Panel Right"),
+                (view! { <PanelTopClose/> }.into_any(), "Panel Top Close"),
+                (view! { <PanelTopDashed/> }.into_any(), "Panel Top Dashed"),
+                (view! { <PanelTopOpen/> }.into_any(), "Panel Top Open"),
+                (view! { <PanelTop/> }.into_any(), "Panel Top"),
+                (view! { <PanelsLeftBottom/> }.into_any(), "Panels Left Bottom"),
+                (view! { <PanelsRightBottom/> }.into_any(), "Panels Right Bottom"),
+                (view! { <PanelsTopLeft/> }.into_any(), "Panels Top Left"),
+                (view! { <Paperclip/> }.into_any(), "Paperclip"),
+                (view! { <Parentheses/> }.into_any(), "Parentheses"),
+                (view! { <ParkingMeter/> }.into_any(), "Parking Meter"),
+                (view! { <PartyPopper/> }.into_any(), "Party Popper"),
+                (view! { <Pause/> }.into_any(), "Pause"),
+                (view! { <PawPrint/> }.into_any(), "Paw Print"),
+                (view! { <PcCase/> }.into_any(), "Pc Case"),
+                (view! { <PenLine/> }.into_any(), "Pen Line"),
+                (view! { <PenOff/> }.into_any(), "Pen Off"),
+                (view! { <PenTool/> }.into_any(), "Pen Tool"),
+                (view! { <Pen/> }.into_any(), "Pen"),
+                (view! { <PencilLine/> }.into_any(), "Pencil Line"),
+                (view! { <PencilOff/> }.into_any(), "Pencil Off"),
+                (view! { <PencilRuler/> }.into_any(), "Pencil Ruler"),
+                (view! { <Pencil/> }.into_any(), "Pencil"),
+                (view! { <Pentagon/> }.into_any(), "Pentagon"),
+                (view! { <Percent/> }.into_any(), "Percent"),
+                (view! { <PersonStanding/> }.into_any(), "Person Standing"),
+                (view! { <PhilippinePeso/> }.into_any(), "Philippine Peso"),
+                (view! { <PhoneCall/> }.into_any(), "Phone Call"),
+                (view! { <PhoneForwarded/> }.into_any(), "Phone Forwarded"),
+                (view! { <PhoneIncoming/> }.into_any(), "Phone Incoming"),
+                (view! { <PhoneMissed/> }.into_any(), "Phone Missed"),
+                (view! { <PhoneOff/> }.into_any(), "Phone Off"),
+                (view! { <PhoneOutgoing/> }.into_any(), "Phone Outgoing"),
+                (view! { <Phone/> }.into_any(), "Phone"),
+                (view! { <Pi/> }.into_any(), "Pi"),
+                (view! { <Piano/> }.into_any(), "Piano"),
+                (view! { <Pickaxe/> }.into_any(), "Pickaxe"),
+                (view! { <PictureInPicture2/> }.into_any(), "Picture In Picture 2"),
+                (view! { <PictureInPicture/> }.into_any(), "Picture In Picture"),
+                (view! { <PiggyBank/> }.into_any(), "Piggy Bank"),
+                (view! { <PilcrowLeft/> }.into_any(), "Pilcrow Left"),
+                (view! { <PilcrowRight/> }.into_any(), "Pilcrow Right"),
+                (view! { <Pilcrow/> }.into_any(), "Pilcrow"),
+                (view! { <PillBottle/> }.into_any(), "Pill Bottle"),
+                (view! { <Pill/> }.into_any(), "Pill"),
+                (view! { <PinOff/> }.into_any(), "Pin Off"),
+                (view! { <Pin/> }.into_any(), "Pin"),
+                (view! { <Pipette/> }.into_any(), "Pipette"),
+                (view! { <Pizza/> }.into_any(), "Pizza"),
+                (view! { <PlaneLanding/> }.into_any(), "Plane Landing"),
+                (view! { <PlaneTakeoff/> }.into_any(), "Plane Takeoff"),
+                (view! { <Plane/> }.into_any(), "Plane"),
+                (view! { <Play/> }.into_any(), "Play"),
+                (view! { <Plug2/> }.into_any(), "Plug 2"),
+                (view! { <PlugZap/> }.into_any(), "Plug Zap"),
+                (view! { <Plug/> }.into_any(), "Plug"),
+                (view! { <Plus/> }.into_any(), "Plus"),
+                (view! { <PocketKnife/> }.into_any(), "Pocket Knife"),
+                (view! { <Pocket/> }.into_any(), "Pocket"),
+                (view! { <Podcast/> }.into_any(), "Podcast"),
+                (view! { <PointerOff/> }.into_any(), "Pointer Off"),
+                (view! { <Pointer/> }.into_any(), "Pointer"),
+                (view! { <Popcorn/> }.into_any(), "Popcorn"),
+                (view! { <Popsicle/> }.into_any(), "Popsicle"),
+                (view! { <PoundSterling/> }.into_any(), "Pound Sterling"),
+                (view! { <PowerOff/> }.into_any(), "Power Off"),
+                (view! { <Power/> }.into_any(), "Power"),
+                (view! { <Presentation/> }.into_any(), "Presentation"),
+                (view! { <PrinterCheck/> }.into_any(), "Printer Check"),
+                (view! { <Printer/> }.into_any(), "Printer"),
+                (view! { <Projector/> }.into_any(), "Projector"),
+                (view! { <Proportions/> }.into_any(), "Proportions"),
+                (view! { <Puzzle/> }.into_any(), "Puzzle"),
+                (view! { <Pyramid/> }.into_any(), "Pyramid"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsQ() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <QrCode/> }.into_any(), "Qr Code"),
+                (view! { <Quote/> }.into_any(), "Quote"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsR() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Rabbit/> }.into_any(), "Rabbit"),
+                (view! { <Radar/> }.into_any(), "Radar"),
+                (view! { <Radiation/> }.into_any(), "Radiation"),
+                (view! { <Radical/> }.into_any(), "Radical"),
+                (view! { <RadioReceiver/> }.into_any(), "Radio Receiver"),
+                (view! { <RadioTower/> }.into_any(), "Radio Tower"),
+                (view! { <Radio/> }.into_any(), "Radio"),
+                (view! { <Radius/> }.into_any(), "Radius"),
+                (view! { <RailSymbol/> }.into_any(), "Rail Symbol"),
+                (view! { <Rainbow/> }.into_any(), "Rainbow"),
+                (view! { <Rat/> }.into_any(), "Rat"),
+                (view! { <Ratio/> }.into_any(), "Ratio"),
+                (view! { <ReceiptCent/> }.into_any(), "Receipt Cent"),
+                (view! { <ReceiptEuro/> }.into_any(), "Receipt Euro"),
+                (view! { <ReceiptIndianRupee/> }.into_any(), "Receipt Indian Rupee"),
+                (view! { <ReceiptJapaneseYen/> }.into_any(), "Receipt Japanese Yen"),
+                (view! { <ReceiptPoundSterling/> }.into_any(), "Receipt Pound Sterling"),
+                (view! { <ReceiptRussianRuble/> }.into_any(), "Receipt Russian Ruble"),
+                (view! { <ReceiptSwissFranc/> }.into_any(), "Receipt Swiss Franc"),
+                (view! { <ReceiptText/> }.into_any(), "Receipt Text"),
+                (view! { <Receipt/> }.into_any(), "Receipt"),
+                (view! { <RectangleEllipsis/> }.into_any(), "Rectangle Ellipsis"),
+                (view! { <RectangleHorizontal/> }.into_any(), "Rectangle Horizontal"),
+                (view! { <RectangleVertical/> }.into_any(), "Rectangle Vertical"),
+                (view! { <Recycle/> }.into_any(), "Recycle"),
+                (view! { <Redo2/> }.into_any(), "Redo 2"),
+                (view! { <RedoDot/> }.into_any(), "Redo Dot"),
+                (view! { <Redo/> }.into_any(), "Redo"),
+                (view! { <RefreshCcwDot/> }.into_any(), "Refresh Ccw Dot"),
+                (view! { <RefreshCcw/> }.into_any(), "Refresh Ccw"),
+                (view! { <RefreshCwOff/> }.into_any(), "Refresh Cw Off"),
+                (view! { <RefreshCw/> }.into_any(), "Refresh Cw"),
+                (view! { <Refrigerator/> }.into_any(), "Refrigerator"),
+                (view! { <Regex/> }.into_any(), "Regex"),
+                (view! { <RemoveFormatting/> }.into_any(), "Remove Formatting"),
+                (view! { <Repeat1/> }.into_any(), "Repeat 1"),
+                (view! { <Repeat2/> }.into_any(), "Repeat 2"),
+                (view! { <Repeat/> }.into_any(), "Repeat"),
+                (view! { <ReplaceAll/> }.into_any(), "Replace All"),
+                (view! { <Replace/> }.into_any(), "Replace"),
+                (view! { <ReplyAll/> }.into_any(), "Reply All"),
+                (view! { <Reply/> }.into_any(), "Reply"),
+                (view! { <Rewind/> }.into_any(), "Rewind"),
+                (view! { <Ribbon/> }.into_any(), "Ribbon"),
+                (view! { <Rocket/> }.into_any(), "Rocket"),
+                (view! { <RockingChair/> }.into_any(), "Rocking Chair"),
+                (view! { <RollerCoaster/> }.into_any(), "Roller Coaster"),
+                (view! { <Rotate3D/> }.into_any(), "Rotate 3 D"),
+                (view! { <RotateCcwSquare/> }.into_any(), "Rotate Ccw Square"),
+                (view! { <RotateCcw/> }.into_any(), "Rotate Ccw"),
+                (view! { <RotateCwSquare/> }.into_any(), "Rotate Cw Square"),
+                (view! { <RotateCw/> }.into_any(), "Rotate Cw"),
+                (view! { <RouteOff/> }.into_any(), "Route Off"),
+                (view! { <Route/> }.into_any(), "Route"),
+                (view! { <Router/> }.into_any(), "Router"),
+                (view! { <Rows2/> }.into_any(), "Rows 2"),
+                (view! { <Rows3/> }.into_any(), "Rows 3"),
+                (view! { <Rows4/> }.into_any(), "Rows 4"),
+                (view! { <Rss/> }.into_any(), "Rss"),
+                (view! { <Ruler/> }.into_any(), "Ruler"),
+                (view! { <RussianRuble/> }.into_any(), "Russian Ruble"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsS() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Sailboat/> }.into_any(), "Sailboat"),
+                (view! { <Salad/> }.into_any(), "Salad"),
+                (view! { <Sandwich/> }.into_any(), "Sandwich"),
+                (view! { <SatelliteDish/> }.into_any(), "Satellite Dish"),
+                (view! { <Satellite/> }.into_any(), "Satellite"),
+                (view! { <SaveAll/> }.into_any(), "Save All"),
+                (view! { <SaveOff/> }.into_any(), "Save Off"),
+                (view! { <Save/> }.into_any(), "Save"),
+                (view! { <Scale3D/> }.into_any(), "Scale 3 D"),
+                (view! { <Scale/> }.into_any(), "Scale"),
+                (view! { <Scaling/> }.into_any(), "Scaling"),
+                (view! { <ScanBarcode/> }.into_any(), "Scan Barcode"),
+                (view! { <ScanEye/> }.into_any(), "Scan Eye"),
+                (view! { <ScanFace/> }.into_any(), "Scan Face"),
+                (view! { <ScanLine/> }.into_any(), "Scan Line"),
+                (view! { <ScanQrCode/> }.into_any(), "Scan Qr Code"),
+                (view! { <ScanSearch/> }.into_any(), "Scan Search"),
+                (view! { <ScanText/> }.into_any(), "Scan Text"),
+                (view! { <Scan/> }.into_any(), "Scan"),
+                (view! { <School/> }.into_any(), "School"),
+                (view! { <ScissorsLineDashed/> }.into_any(), "Scissors Line Dashed"),
+                (view! { <Scissors/> }.into_any(), "Scissors"),
+                (view! { <ScreenShareOff/> }.into_any(), "Screen Share Off"),
+                (view! { <ScreenShare/> }.into_any(), "Screen Share"),
+                (view! { <ScrollText/> }.into_any(), "Scroll Text"),
+                (view! { <Scroll/> }.into_any(), "Scroll"),
+                (view! { <SearchCheck/> }.into_any(), "Search Check"),
+                (view! { <SearchCode/> }.into_any(), "Search Code"),
+                (view! { <SearchSlash/> }.into_any(), "Search Slash"),
+                (view! { <SearchX/> }.into_any(), "Search X"),
+                (view! { <Search/> }.into_any(), "Search"),
+                (view! { <Section/> }.into_any(), "Section"),
+                (view! { <SendHorizontal/> }.into_any(), "Send Horizontal"),
+                (view! { <SendToBack/> }.into_any(), "Send To Back"),
+                (view! { <Send/> }.into_any(), "Send"),
+                (view! { <SeparatorHorizontal/> }.into_any(), "Separator Horizontal"),
+                (view! { <SeparatorVertical/> }.into_any(), "Separator Vertical"),
+                (view! { <ServerCog/> }.into_any(), "Server Cog"),
+                (view! { <ServerCrash/> }.into_any(), "Server Crash"),
+                (view! { <ServerOff/> }.into_any(), "Server Off"),
+                (view! { <Server/> }.into_any(), "Server"),
+                (view! { <Settings2/> }.into_any(), "Settings 2"),
+                (view! { <Settings/> }.into_any(), "Settings"),
+                (view! { <Shapes/> }.into_any(), "Shapes"),
+                (view! { <Share2/> }.into_any(), "Share 2"),
+                (view! { <Share/> }.into_any(), "Share"),
+                (view! { <Sheet/> }.into_any(), "Sheet"),
+                (view! { <Shell/> }.into_any(), "Shell"),
+                (view! { <ShieldAlert/> }.into_any(), "Shield Alert"),
+                (view! { <ShieldBan/> }.into_any(), "Shield Ban"),
+                (view! { <ShieldCheck/> }.into_any(), "Shield Check"),
+                (view! { <ShieldEllipsis/> }.into_any(), "Shield Ellipsis"),
+                (view! { <ShieldHalf/> }.into_any(), "Shield Half"),
+                (view! { <ShieldMinus/> }.into_any(), "Shield Minus"),
+                (view! { <ShieldOff/> }.into_any(), "Shield Off"),
+                (view! { <ShieldPlus/> }.into_any(), "Shield Plus"),
+                (view! { <ShieldQuestion/> }.into_any(), "Shield Question"),
+                (view! { <ShieldX/> }.into_any(), "Shield X"),
+                (view! { <Shield/> }.into_any(), "Shield"),
+                (view! { <ShipWheel/> }.into_any(), "Ship Wheel"),
+                (view! { <Ship/> }.into_any(), "Ship"),
+                (view! { <Shirt/> }.into_any(), "Shirt"),
+                (view! { <ShoppingBag/> }.into_any(), "Shopping Bag"),
+                (view! { <ShoppingBasket/> }.into_any(), "Shopping Basket"),
+                (view! { <ShoppingCart/> }.into_any(), "Shopping Cart"),
+                (view! { <Shovel/> }.into_any(), "Shovel"),
+                (view! { <ShowerHead/> }.into_any(), "Shower Head"),
+                (view! { <Shrink/> }.into_any(), "Shrink"),
+                (view! { <Shrub/> }.into_any(), "Shrub"),
+                (view! { <Shuffle/> }.into_any(), "Shuffle"),
+                (view! { <Sigma/> }.into_any(), "Sigma"),
+                (view! { <SignalHigh/> }.into_any(), "Signal High"),
+                (view! { <SignalLow/> }.into_any(), "Signal Low"),
+                (view! { <SignalMedium/> }.into_any(), "Signal Medium"),
+                (view! { <SignalZero/> }.into_any(), "Signal Zero"),
+                (view! { <Signal/> }.into_any(), "Signal"),
+                (view! { <Signature/> }.into_any(), "Signature"),
+                (view! { <SignpostBig/> }.into_any(), "Signpost Big"),
+                (view! { <Signpost/> }.into_any(), "Signpost"),
+                (view! { <Siren/> }.into_any(), "Siren"),
+                (view! { <SkipBack/> }.into_any(), "Skip Back"),
+                (view! { <SkipForward/> }.into_any(), "Skip Forward"),
+                (view! { <Skull/> }.into_any(), "Skull"),
+                (view! { <Slack/> }.into_any(), "Slack"),
+                (view! { <Slash/> }.into_any(), "Slash"),
+                (view! { <Slice/> }.into_any(), "Slice"),
+                (view! { <SlidersHorizontal/> }.into_any(), "Sliders Horizontal"),
+                (view! { <SlidersVertical/> }.into_any(), "Sliders Vertical"),
+                (view! { <SmartphoneCharging/> }.into_any(), "Smartphone Charging"),
+                (view! { <SmartphoneNfc/> }.into_any(), "Smartphone Nfc"),
+                (view! { <Smartphone/> }.into_any(), "Smartphone"),
+                (view! { <SmilePlus/> }.into_any(), "Smile Plus"),
+                (view! { <Smile/> }.into_any(), "Smile"),
+                (view! { <Snail/> }.into_any(), "Snail"),
+                (view! { <Snowflake/> }.into_any(), "Snowflake"),
+                (view! { <Sofa/> }.into_any(), "Sofa"),
+                (view! { <Soup/> }.into_any(), "Soup"),
+                (view! { <Space/> }.into_any(), "Space"),
+                (view! { <Spade/> }.into_any(), "Spade"),
+                (view! { <Sparkle/> }.into_any(), "Sparkle"),
+                (view! { <Sparkles/> }.into_any(), "Sparkles"),
+                (view! { <Speaker/> }.into_any(), "Speaker"),
+                (view! { <Speech/> }.into_any(), "Speech"),
+                (view! { <SpellCheck2/> }.into_any(), "Spell Check 2"),
+                (view! { <SpellCheck/> }.into_any(), "Spell Check"),
+                (view! { <Spline/> }.into_any(), "Spline"),
+                (view! { <Split/> }.into_any(), "Split"),
+                (view! { <SprayCan/> }.into_any(), "Spray Can"),
+                (view! { <Sprout/> }.into_any(), "Sprout"),
+                (view! { <SquareActivity/> }.into_any(), "Square Activity"),
+                (view! { <SquareArrowDownLeft/> }.into_any(), "Square Arrow Down Left"),
+                (view! { <SquareArrowDownRight/> }.into_any(), "Square Arrow Down Right"),
+                (view! { <SquareArrowDown/> }.into_any(), "Square Arrow Down"),
+                (view! { <SquareArrowLeft/> }.into_any(), "Square Arrow Left"),
+                (view! { <SquareArrowOutDownLeft/> }.into_any(), "Square Arrow Out Down Left"),
+                (view! { <SquareArrowOutDownRight/> }.into_any(), "Square Arrow Out Down Right"),
+                (view! { <SquareArrowOutUpLeft/> }.into_any(), "Square Arrow Out Up Left"),
+                (view! { <SquareArrowOutUpRight/> }.into_any(), "Square Arrow Out Up Right"),
+                (view! { <SquareArrowRight/> }.into_any(), "Square Arrow Right"),
+                (view! { <SquareArrowUpLeft/> }.into_any(), "Square Arrow Up Left"),
+                (view! { <SquareArrowUpRight/> }.into_any(), "Square Arrow Up Right"),
+                (view! { <SquareArrowUp/> }.into_any(), "Square Arrow Up"),
+                (view! { <SquareAsterisk/> }.into_any(), "Square Asterisk"),
+                (
+                    view! { <SquareBottomDashedScissors/> }.into_any(),
+                    "Square Bottom Dashed Scissors",
+                ),
+                (view! { <SquareChartGantt/> }.into_any(), "Square Chart Gantt"),
+                (view! { <SquareCheckBig/> }.into_any(), "Square Check Big"),
+                (view! { <SquareCheck/> }.into_any(), "Square Check"),
+                (view! { <SquareChevronDown/> }.into_any(), "Square Chevron Down"),
+                (view! { <SquareChevronLeft/> }.into_any(), "Square Chevron Left"),
+                (view! { <SquareChevronRight/> }.into_any(), "Square Chevron Right"),
+                (view! { <SquareChevronUp/> }.into_any(), "Square Chevron Up"),
+                (view! { <SquareCode/> }.into_any(), "Square Code"),
+                (view! { <SquareDashedBottomCode/> }.into_any(), "Square Dashed Bottom Code"),
+                (view! { <SquareDashedBottom/> }.into_any(), "Square Dashed Bottom"),
+                (view! { <SquareDashedKanban/> }.into_any(), "Square Dashed Kanban"),
+                (view! { <SquareDashedMousePointer/> }.into_any(), "Square Dashed Mouse Pointer"),
+                (view! { <SquareDashed/> }.into_any(), "Square Dashed"),
+                (view! { <SquareDivide/> }.into_any(), "Square Divide"),
+                (view! { <SquareDot/> }.into_any(), "Square Dot"),
+                (view! { <SquareEqual/> }.into_any(), "Square Equal"),
+                (view! { <SquareFunction/> }.into_any(), "Square Function"),
+                (view! { <SquareKanban/> }.into_any(), "Square Kanban"),
+                (view! { <SquareLibrary/> }.into_any(), "Square Library"),
+                (view! { <SquareM/> }.into_any(), "Square M"),
+                (view! { <SquareMenu/> }.into_any(), "Square Menu"),
+                (view! { <SquareMinus/> }.into_any(), "Square Minus"),
+                (view! { <SquareMousePointer/> }.into_any(), "Square Mouse Pointer"),
+                (view! { <SquareParkingOff/> }.into_any(), "Square Parking Off"),
+                (view! { <SquareParking/> }.into_any(), "Square Parking"),
+                (view! { <SquarePen/> }.into_any(), "Square Pen"),
+                (view! { <SquarePercent/> }.into_any(), "Square Percent"),
+                (view! { <SquarePi/> }.into_any(), "Square Pi"),
+                (view! { <SquarePilcrow/> }.into_any(), "Square Pilcrow"),
+                (view! { <SquarePlay/> }.into_any(), "Square Play"),
+                (view! { <SquarePlus/> }.into_any(), "Square Plus"),
+                (view! { <SquarePower/> }.into_any(), "Square Power"),
+                (view! { <SquareRadical/> }.into_any(), "Square Radical"),
+                (view! { <SquareScissors/> }.into_any(), "Square Scissors"),
+                (view! { <SquareSigma/> }.into_any(), "Square Sigma"),
+                (view! { <SquareSlash/> }.into_any(), "Square Slash"),
+                (view! { <SquareSplitHorizontal/> }.into_any(), "Square Split Horizontal"),
+                (view! { <SquareSplitVertical/> }.into_any(), "Square Split Vertical"),
+                (view! { <SquareSquare/> }.into_any(), "Square Square"),
+                (view! { <SquareStack/> }.into_any(), "Square Stack"),
+                (view! { <SquareTerminal/> }.into_any(), "Square Terminal"),
+                (view! { <SquareUserRound/> }.into_any(), "Square User Round"),
+                (view! { <SquareUser/> }.into_any(), "Square User"),
+                (view! { <SquareX/> }.into_any(), "Square X"),
+                (view! { <Square/> }.into_any(), "Square"),
+                (view! { <Squircle/> }.into_any(), "Squircle"),
+                (view! { <Squirrel/> }.into_any(), "Squirrel"),
+                (view! { <Stamp/> }.into_any(), "Stamp"),
+                (view! { <StarHalf/> }.into_any(), "Star Half"),
+                (view! { <StarOff/> }.into_any(), "Star Off"),
+                (view! { <Star/> }.into_any(), "Star"),
+                (view! { <StepBack/> }.into_any(), "Step Back"),
+                (view! { <StepForward/> }.into_any(), "Step Forward"),
+                (view! { <Stethoscope/> }.into_any(), "Stethoscope"),
+                (view! { <Sticker/> }.into_any(), "Sticker"),
+                (view! { <StickyNote/> }.into_any(), "Sticky Note"),
+                (view! { <Store/> }.into_any(), "Store"),
+                (view! { <StretchHorizontal/> }.into_any(), "Stretch Horizontal"),
+                (view! { <StretchVertical/> }.into_any(), "Stretch Vertical"),
+                (view! { <Strikethrough/> }.into_any(), "Strikethrough"),
+                (view! { <Subscript/> }.into_any(), "Subscript"),
+                (view! { <SunDim/> }.into_any(), "Sun Dim"),
+                (view! { <SunMedium/> }.into_any(), "Sun Medium"),
+                (view! { <SunMoon/> }.into_any(), "Sun Moon"),
+                (view! { <SunSnow/> }.into_any(), "Sun Snow"),
+                (view! { <Sun/> }.into_any(), "Sun"),
+                (view! { <Sunrise/> }.into_any(), "Sunrise"),
+                (view! { <Sunset/> }.into_any(), "Sunset"),
+                (view! { <Superscript/> }.into_any(), "Superscript"),
+                (view! { <SwatchBook/> }.into_any(), "Swatch Book"),
+                (view! { <SwissFranc/> }.into_any(), "Swiss Franc"),
+                (view! { <SwitchCamera/> }.into_any(), "Switch Camera"),
+                (view! { <Sword/> }.into_any(), "Sword"),
+                (view! { <Swords/> }.into_any(), "Swords"),
+                (view! { <Syringe/> }.into_any(), "Syringe"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsT() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Table2/> }.into_any(), "Table 2"),
+                (view! { <TableCellsMerge/> }.into_any(), "Table Cells Merge"),
+                (view! { <TableCellsSplit/> }.into_any(), "Table Cells Split"),
+                (view! { <TableColumnsSplit/> }.into_any(), "Table Columns Split"),
+                (view! { <TableOfContents/> }.into_any(), "Table Of Contents"),
+                (view! { <TableProperties/> }.into_any(), "Table Properties"),
+                (view! { <TableRowsSplit/> }.into_any(), "Table Rows Split"),
+                (view! { <Table/> }.into_any(), "Table"),
+                (view! { <TabletSmartphone/> }.into_any(), "Tablet Smartphone"),
+                (view! { <Tablet/> }.into_any(), "Tablet"),
+                (view! { <Tablets/> }.into_any(), "Tablets"),
+                (view! { <Tag/> }.into_any(), "Tag"),
+                (view! { <Tags/> }.into_any(), "Tags"),
+                (view! { <Tally1/> }.into_any(), "Tally 1"),
+                (view! { <Tally2/> }.into_any(), "Tally 2"),
+                (view! { <Tally3/> }.into_any(), "Tally 3"),
+                (view! { <Tally4/> }.into_any(), "Tally 4"),
+                (view! { <Tally5/> }.into_any(), "Tally 5"),
+                (view! { <Tangent/> }.into_any(), "Tangent"),
+                (view! { <Target/> }.into_any(), "Target"),
+                (view! { <Telescope/> }.into_any(), "Telescope"),
+                (view! { <TentTree/> }.into_any(), "Tent Tree"),
+                (view! { <Tent/> }.into_any(), "Tent"),
+                (view! { <Terminal/> }.into_any(), "Terminal"),
+                (view! { <TestTubeDiagonal/> }.into_any(), "Test Tube Diagonal"),
+                (view! { <TestTube/> }.into_any(), "Test Tube"),
+                (view! { <TestTubes/> }.into_any(), "Test Tubes"),
+                (view! { <TextCursorInput/> }.into_any(), "Text Cursor Input"),
+                (view! { <TextCursor/> }.into_any(), "Text Cursor"),
+                (view! { <TextQuote/> }.into_any(), "Text Quote"),
+                (view! { <TextSearch/> }.into_any(), "Text Search"),
+                (view! { <TextSelect/> }.into_any(), "Text Select"),
+                (view! { <Text/> }.into_any(), "Text"),
+                (view! { <Theater/> }.into_any(), "Theater"),
+                (view! { <ThermometerSnowflake/> }.into_any(), "Thermometer Snowflake"),
+                (view! { <ThermometerSun/> }.into_any(), "Thermometer Sun"),
+                (view! { <Thermometer/> }.into_any(), "Thermometer"),
+                (view! { <ThumbsDown/> }.into_any(), "Thumbs Down"),
+                (view! { <ThumbsUp/> }.into_any(), "Thumbs Up"),
+                (view! { <TicketCheck/> }.into_any(), "Ticket Check"),
+                (view! { <TicketMinus/> }.into_any(), "Ticket Minus"),
+                (view! { <TicketPercent/> }.into_any(), "Ticket Percent"),
+                (view! { <TicketPlus/> }.into_any(), "Ticket Plus"),
+                (view! { <TicketSlash/> }.into_any(), "Ticket Slash"),
+                (view! { <TicketX/> }.into_any(), "Ticket X"),
+                (view! { <Ticket/> }.into_any(), "Ticket"),
+                (view! { <TicketsPlane/> }.into_any(), "Tickets Plane"),
+                (view! { <Tickets/> }.into_any(), "Tickets"),
+                (view! { <TimerOff/> }.into_any(), "Timer Off"),
+                (view! { <TimerReset/> }.into_any(), "Timer Reset"),
+                (view! { <Timer/> }.into_any(), "Timer"),
+                (view! { <ToggleLeft/> }.into_any(), "Toggle Left"),
+                (view! { <ToggleRight/> }.into_any(), "Toggle Right"),
+                (view! { <Toilet/> }.into_any(), "Toilet"),
+                (view! { <Tornado/> }.into_any(), "Tornado"),
+                (view! { <Torus/> }.into_any(), "Torus"),
+                (view! { <TouchpadOff/> }.into_any(), "Touchpad Off"),
+                (view! { <Touchpad/> }.into_any(), "Touchpad"),
+                (view! { <TowerControl/> }.into_any(), "Tower Control"),
+                (view! { <ToyBrick/> }.into_any(), "Toy Brick"),
+                (view! { <Tractor/> }.into_any(), "Tractor"),
+                (view! { <TrafficCone/> }.into_any(), "Traffic Cone"),
+                (view! { <TrainFrontTunnel/> }.into_any(), "Train Front Tunnel"),
+                (view! { <TrainFront/> }.into_any(), "Train Front"),
+                (view! { <TrainTrack/> }.into_any(), "Train Track"),
+                (view! { <TramFront/> }.into_any(), "Tram Front"),
+                (view! { <Trash2/> }.into_any(), "Trash 2"),
+                (view! { <Trash/> }.into_any(), "Trash"),
+                (view! { <TreeDeciduous/> }.into_any(), "Tree Deciduous"),
+                (view! { <TreePalm/> }.into_any(), "Tree Palm"),
+                (view! { <TreePine/> }.into_any(), "Tree Pine"),
+                (view! { <Trees/> }.into_any(), "Trees"),
+                (view! { <Trello/> }.into_any(), "Trello"),
+                (view! { <TrendingDown/> }.into_any(), "Trending Down"),
+                (view! { <TrendingUpDown/> }.into_any(), "Trending Up Down"),
+                (view! { <TrendingUp/> }.into_any(), "Trending Up"),
+                (view! { <TriangleAlert/> }.into_any(), "Triangle Alert"),
+                (view! { <TriangleRight/> }.into_any(), "Triangle Right"),
+                (view! { <Triangle/> }.into_any(), "Triangle"),
+                (view! { <Trophy/> }.into_any(), "Trophy"),
+                (view! { <Truck/> }.into_any(), "Truck"),
+                (view! { <Turtle/> }.into_any(), "Turtle"),
+                (view! { <TvMinimalPlay/> }.into_any(), "Tv Minimal Play"),
+                (view! { <TvMinimal/> }.into_any(), "Tv Minimal"),
+                (view! { <Tv/> }.into_any(), "Tv"),
+                (view! { <Twitch/> }.into_any(), "Twitch"),
+                (view! { <Twitter/> }.into_any(), "Twitter"),
+                (view! { <TypeOutline/> }.into_any(), "Type Outline"),
+                (view! { <Type/> }.into_any(), "Type"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsU() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <UmbrellaOff/> }.into_any(), "Umbrella Off"),
+                (view! { <Umbrella/> }.into_any(), "Umbrella"),
+                (view! { <Underline/> }.into_any(), "Underline"),
+                (view! { <Undo2/> }.into_any(), "Undo 2"),
+                (view! { <UndoDot/> }.into_any(), "Undo Dot"),
+                (view! { <Undo/> }.into_any(), "Undo"),
+                (view! { <UnfoldHorizontal/> }.into_any(), "Unfold Horizontal"),
+                (view! { <UnfoldVertical/> }.into_any(), "Unfold Vertical"),
+                (view! { <Ungroup/> }.into_any(), "Ungroup"),
+                (view! { <University/> }.into_any(), "University"),
+                (view! { <Unlink2/> }.into_any(), "Unlink 2"),
+                (view! { <Unlink/> }.into_any(), "Unlink"),
+                (view! { <Unplug/> }.into_any(), "Unplug"),
+                (view! { <Upload/> }.into_any(), "Upload"),
+                (view! { <Usb/> }.into_any(), "Usb"),
+                (view! { <UserCheck/> }.into_any(), "User Check"),
+                (view! { <UserCog/> }.into_any(), "User Cog"),
+                (view! { <UserMinus/> }.into_any(), "User Minus"),
+                (view! { <UserPen/> }.into_any(), "User Pen"),
+                (view! { <UserPlus/> }.into_any(), "User Plus"),
+                (view! { <UserRoundCheck/> }.into_any(), "User Round Check"),
+                (view! { <UserRoundCog/> }.into_any(), "User Round Cog"),
+                (view! { <UserRoundMinus/> }.into_any(), "User Round Minus"),
+                (view! { <UserRoundPen/> }.into_any(), "User Round Pen"),
+                (view! { <UserRoundPlus/> }.into_any(), "User Round Plus"),
+                (view! { <UserRoundSearch/> }.into_any(), "User Round Search"),
+                (view! { <UserRoundX/> }.into_any(), "User Round X"),
+                (view! { <UserRound/> }.into_any(), "User Round"),
+                (view! { <UserSearch/> }.into_any(), "User Search"),
+                (view! { <UserX/> }.into_any(), "User X"),
+                (view! { <User/> }.into_any(), "User"),
+                (view! { <UsersRound/> }.into_any(), "Users Round"),
+                (view! { <Users/> }.into_any(), "Users"),
+                (view! { <UtensilsCrossed/> }.into_any(), "Utensils Crossed"),
+                (view! { <Utensils/> }.into_any(), "Utensils"),
+                (view! { <UtilityPole/> }.into_any(), "Utility Pole"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsV() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <Variable/> }.into_any(), "Variable"),
+                (view! { <Vault/> }.into_any(), "Vault"),
+                (view! { <Vegan/> }.into_any(), "Vegan"),
+                (view! { <VenetianMask/> }.into_any(), "Venetian Mask"),
+                (view! { <VibrateOff/> }.into_any(), "Vibrate Off"),
+                (view! { <Vibrate/> }.into_any(), "Vibrate"),
+                (view! { <VideoOff/> }.into_any(), "Video Off"),
+                (view! { <Video/> }.into_any(), "Video"),
+                (view! { <Videotape/> }.into_any(), "Videotape"),
+                (view! { <View/> }.into_any(), "View"),
+                (view! { <Voicemail/> }.into_any(), "Voicemail"),
+                (view! { <Volleyball/> }.into_any(), "Volleyball"),
+                (view! { <Volume1/> }.into_any(), "Volume 1"),
+                (view! { <Volume2/> }.into_any(), "Volume 2"),
+                (view! { <VolumeOff/> }.into_any(), "Volume Off"),
+                (view! { <VolumeX/> }.into_any(), "Volume X"),
+                (view! { <Volume/> }.into_any(), "Volume"),
+                (view! { <Vote/> }.into_any(), "Vote"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsW() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <WalletCards/> }.into_any(), "Wallet Cards"),
+                (view! { <WalletMinimal/> }.into_any(), "Wallet Minimal"),
+                (view! { <Wallet/> }.into_any(), "Wallet"),
+                (view! { <Wallpaper/> }.into_any(), "Wallpaper"),
+                (view! { <WandSparkles/> }.into_any(), "Wand Sparkles"),
+                (view! { <Wand/> }.into_any(), "Wand"),
+                (view! { <Warehouse/> }.into_any(), "Warehouse"),
+                (view! { <WashingMachine/> }.into_any(), "Washing Machine"),
+                (view! { <Watch/> }.into_any(), "Watch"),
+                (view! { <Waves/> }.into_any(), "Waves"),
+                (view! { <Waypoints/> }.into_any(), "Waypoints"),
+                (view! { <Webcam/> }.into_any(), "Webcam"),
+                (view! { <WebhookOff/> }.into_any(), "Webhook Off"),
+                (view! { <Webhook/> }.into_any(), "Webhook"),
+                (view! { <Weight/> }.into_any(), "Weight"),
+                (view! { <WheatOff/> }.into_any(), "Wheat Off"),
+                (view! { <Wheat/> }.into_any(), "Wheat"),
+                (view! { <WholeWord/> }.into_any(), "Whole Word"),
+                (view! { <WifiHigh/> }.into_any(), "Wifi High"),
+                (view! { <WifiLow/> }.into_any(), "Wifi Low"),
+                (view! { <WifiOff/> }.into_any(), "Wifi Off"),
+                (view! { <WifiZero/> }.into_any(), "Wifi Zero"),
+                (view! { <Wifi/> }.into_any(), "Wifi"),
+                (view! { <WindArrowDown/> }.into_any(), "Wind Arrow Down"),
+                (view! { <Wind/> }.into_any(), "Wind"),
+                (view! { <WineOff/> }.into_any(), "Wine Off"),
+                (view! { <Wine/> }.into_any(), "Wine"),
+                (view! { <Workflow/> }.into_any(), "Workflow"),
+                (view! { <Worm/> }.into_any(), "Worm"),
+                (view! { <WrapText/> }.into_any(), "Wrap Text"),
+                (view! { <Wrench/> }.into_any(), "Wrench"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsX() -> impl IntoView {
+    view! {
+        <For
+            each=move || [(view! { <X/> }.into_any(), "X")]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsY() -> impl IntoView {
+    view! {
+        <For
+            each=move || [(view! { <Youtube/> }.into_any(), "Youtube")]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
+}
+#[component]
+pub fn IconsZ() -> impl IntoView {
+    view! {
+        <For
+            each=move || [
+                (view! { <ZapOff/> }.into_any(), "Zap Off"),
+                (view! { <Zap/> }.into_any(), "Zap"),
+                (view! { <ZoomIn/> }.into_any(), "Zoom In"),
+                (view! { <ZoomOut/> }.into_any(), "Zoom Out"),
+            ]
+            key=|icon| icon.1
+            children=move |(icon, name)| {
+                view! {
+                    <div class="flex flex-wrap items-center gap-4 text-sm">
+                        {icon} <span>{name}</span>
+                    </div>
+                }
+            }
+        />
+    }
 }
diff --git a/book-examples/yew/src/icons.rs b/book-examples/yew/src/icons.rs
index 5af8cf3..463f4e1 100644
--- a/book-examples/yew/src/icons.rs
+++ b/book-examples/yew/src/icons.rs
@@ -1,6 +1,2112 @@
+use lucide_yew::{Component, *};
 use yew::prelude::*;
-
 #[function_component]
 pub fn Icons() -> Html {
-    html! {}
+    html! {
+        <div class="w-full max-w-80 py-4">
+            <IconsA />
+            <IconsB />
+            <IconsC />
+            <IconsD />
+            <IconsE />
+            <IconsF />
+            <IconsG />
+            <IconsH />
+            <IconsI />
+            <IconsJ />
+            <IconsK />
+            <IconsL />
+            <IconsM />
+            <IconsN />
+            <IconsO />
+            <IconsP />
+            <IconsQ />
+            <IconsR />
+            <IconsS />
+            <IconsT />
+            <IconsU />
+            <IconsV />
+            <IconsW />
+            <IconsX />
+            <IconsY />
+            <IconsZ />
+        </div>
+    }
+}
+#[function_component]
+pub fn IconsA() -> Html {
+    let icons = [
+        (html! { <AArrowDown /> }, "A Arrow Down"),
+        (html! { <AArrowUp /> }, "A Arrow Up"),
+        (html! { <ALargeSmall /> }, "A Large Small"),
+        (html! { <Accessibility /> }, "Accessibility"),
+        (html! { <Activity /> }, "Activity"),
+        (html! { <AirVent /> }, "Air Vent"),
+        (html! { <Airplay /> }, "Airplay"),
+        (html! { <AlarmClockCheck /> }, "Alarm Clock Check"),
+        (html! { <AlarmClockMinus /> }, "Alarm Clock Minus"),
+        (html! { <AlarmClockOff /> }, "Alarm Clock Off"),
+        (html! { <AlarmClockPlus /> }, "Alarm Clock Plus"),
+        (html! { <AlarmClock /> }, "Alarm Clock"),
+        (html! { <AlarmSmoke /> }, "Alarm Smoke"),
+        (html! { <Album /> }, "Album"),
+        (
+            html! { <AlignCenterHorizontal /> },
+            "Align Center Horizontal",
+        ),
+        (html! { <AlignCenterVertical /> }, "Align Center Vertical"),
+        (html! { <AlignCenter /> }, "Align Center"),
+        (html! { <AlignEndHorizontal /> }, "Align End Horizontal"),
+        (html! { <AlignEndVertical /> }, "Align End Vertical"),
+        (
+            html! { <AlignHorizontalDistributeCenter /> },
+            "Align Horizontal Distribute Center",
+        ),
+        (
+            html! { <AlignHorizontalDistributeEnd /> },
+            "Align Horizontal Distribute End",
+        ),
+        (
+            html! { <AlignHorizontalDistributeStart /> },
+            "Align Horizontal Distribute Start",
+        ),
+        (
+            html! { <AlignHorizontalJustifyCenter /> },
+            "Align Horizontal Justify Center",
+        ),
+        (
+            html! { <AlignHorizontalJustifyEnd /> },
+            "Align Horizontal Justify End",
+        ),
+        (
+            html! { <AlignHorizontalJustifyStart /> },
+            "Align Horizontal Justify Start",
+        ),
+        (
+            html! { <AlignHorizontalSpaceAround /> },
+            "Align Horizontal Space Around",
+        ),
+        (
+            html! { <AlignHorizontalSpaceBetween /> },
+            "Align Horizontal Space Between",
+        ),
+        (html! { <AlignJustify /> }, "Align Justify"),
+        (html! { <AlignLeft /> }, "Align Left"),
+        (html! { <AlignRight /> }, "Align Right"),
+        (html! { <AlignStartHorizontal /> }, "Align Start Horizontal"),
+        (html! { <AlignStartVertical /> }, "Align Start Vertical"),
+        (
+            html! { <AlignVerticalDistributeCenter /> },
+            "Align Vertical Distribute Center",
+        ),
+        (
+            html! { <AlignVerticalDistributeEnd /> },
+            "Align Vertical Distribute End",
+        ),
+        (
+            html! { <AlignVerticalDistributeStart /> },
+            "Align Vertical Distribute Start",
+        ),
+        (
+            html! { <AlignVerticalJustifyCenter /> },
+            "Align Vertical Justify Center",
+        ),
+        (
+            html! { <AlignVerticalJustifyEnd /> },
+            "Align Vertical Justify End",
+        ),
+        (
+            html! { <AlignVerticalJustifyStart /> },
+            "Align Vertical Justify Start",
+        ),
+        (
+            html! { <AlignVerticalSpaceAround /> },
+            "Align Vertical Space Around",
+        ),
+        (
+            html! { <AlignVerticalSpaceBetween /> },
+            "Align Vertical Space Between",
+        ),
+        (html! { <Ambulance /> }, "Ambulance"),
+        (html! { <Ampersand /> }, "Ampersand"),
+        (html! { <Ampersands /> }, "Ampersands"),
+        (html! { <Amphora /> }, "Amphora"),
+        (html! { <Anchor /> }, "Anchor"),
+        (html! { <Angry /> }, "Angry"),
+        (html! { <Annoyed /> }, "Annoyed"),
+        (html! { <Antenna /> }, "Antenna"),
+        (html! { <Anvil /> }, "Anvil"),
+        (html! { <Aperture /> }, "Aperture"),
+        (html! { <AppWindowMac /> }, "App Window Mac"),
+        (html! { <AppWindow /> }, "App Window"),
+        (html! { <Apple /> }, "Apple"),
+        (html! { <ArchiveRestore /> }, "Archive Restore"),
+        (html! { <ArchiveX /> }, "Archive X"),
+        (html! { <Archive /> }, "Archive"),
+        (html! { <Armchair /> }, "Armchair"),
+        (html! { <ArrowBigDownDash /> }, "Arrow Big Down Dash"),
+        (html! { <ArrowBigDown /> }, "Arrow Big Down"),
+        (html! { <ArrowBigLeftDash /> }, "Arrow Big Left Dash"),
+        (html! { <ArrowBigLeft /> }, "Arrow Big Left"),
+        (html! { <ArrowBigRightDash /> }, "Arrow Big Right Dash"),
+        (html! { <ArrowBigRight /> }, "Arrow Big Right"),
+        (html! { <ArrowBigUpDash /> }, "Arrow Big Up Dash"),
+        (html! { <ArrowBigUp /> }, "Arrow Big Up"),
+        (html! { <ArrowDown01 /> }, "Arrow Down 01"),
+        (html! { <ArrowDown10 /> }, "Arrow Down 10"),
+        (html! { <ArrowDownAZ /> }, "Arrow Down Az"),
+        (html! { <ArrowDownFromLine /> }, "Arrow Down From Line"),
+        (html! { <ArrowDownLeft /> }, "Arrow Down Left"),
+        (html! { <ArrowDownNarrowWide /> }, "Arrow Down Narrow Wide"),
+        (html! { <ArrowDownRight /> }, "Arrow Down Right"),
+        (html! { <ArrowDownToDot /> }, "Arrow Down To Dot"),
+        (html! { <ArrowDownToLine /> }, "Arrow Down To Line"),
+        (html! { <ArrowDownUp /> }, "Arrow Down Up"),
+        (html! { <ArrowDownWideNarrow /> }, "Arrow Down Wide Narrow"),
+        (html! { <ArrowDownZA /> }, "Arrow Down Za"),
+        (html! { <ArrowDown /> }, "Arrow Down"),
+        (html! { <ArrowLeftFromLine /> }, "Arrow Left From Line"),
+        (html! { <ArrowLeftRight /> }, "Arrow Left Right"),
+        (html! { <ArrowLeftToLine /> }, "Arrow Left To Line"),
+        (html! { <ArrowLeft /> }, "Arrow Left"),
+        (html! { <ArrowRightFromLine /> }, "Arrow Right From Line"),
+        (html! { <ArrowRightLeft /> }, "Arrow Right Left"),
+        (html! { <ArrowRightToLine /> }, "Arrow Right To Line"),
+        (html! { <ArrowRight /> }, "Arrow Right"),
+        (html! { <ArrowUp01 /> }, "Arrow Up 01"),
+        (html! { <ArrowUp10 /> }, "Arrow Up 10"),
+        (html! { <ArrowUpAZ /> }, "Arrow Up Az"),
+        (html! { <ArrowUpDown /> }, "Arrow Up Down"),
+        (html! { <ArrowUpFromDot /> }, "Arrow Up From Dot"),
+        (html! { <ArrowUpFromLine /> }, "Arrow Up From Line"),
+        (html! { <ArrowUpLeft /> }, "Arrow Up Left"),
+        (html! { <ArrowUpNarrowWide /> }, "Arrow Up Narrow Wide"),
+        (html! { <ArrowUpRight /> }, "Arrow Up Right"),
+        (html! { <ArrowUpToLine /> }, "Arrow Up To Line"),
+        (html! { <ArrowUpWideNarrow /> }, "Arrow Up Wide Narrow"),
+        (html! { <ArrowUpZA /> }, "Arrow Up Za"),
+        (html! { <ArrowUp /> }, "Arrow Up"),
+        (html! { <ArrowsUpFromLine /> }, "Arrows Up From Line"),
+        (html! { <Asterisk /> }, "Asterisk"),
+        (html! { <AtSign /> }, "At Sign"),
+        (html! { <Atom /> }, "Atom"),
+        (html! { <AudioLines /> }, "Audio Lines"),
+        (html! { <AudioWaveform /> }, "Audio Waveform"),
+        (html! { <Award /> }, "Award"),
+        (html! { <Axe /> }, "Axe"),
+        (html! { <Axis3D /> }, "Axis 3 D"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsB() -> Html {
+    let icons = [
+        (html! { <Baby /> }, "Baby"),
+        (html! { <Backpack /> }, "Backpack"),
+        (html! { <BadgeAlert /> }, "Badge Alert"),
+        (html! { <BadgeCent /> }, "Badge Cent"),
+        (html! { <BadgeCheck /> }, "Badge Check"),
+        (html! { <BadgeDollarSign /> }, "Badge Dollar Sign"),
+        (html! { <BadgeEuro /> }, "Badge Euro"),
+        (html! { <BadgeHelp /> }, "Badge Help"),
+        (html! { <BadgeIndianRupee /> }, "Badge Indian Rupee"),
+        (html! { <BadgeInfo /> }, "Badge Info"),
+        (html! { <BadgeJapaneseYen /> }, "Badge Japanese Yen"),
+        (html! { <BadgeMinus /> }, "Badge Minus"),
+        (html! { <BadgePercent /> }, "Badge Percent"),
+        (html! { <BadgePlus /> }, "Badge Plus"),
+        (html! { <BadgePoundSterling /> }, "Badge Pound Sterling"),
+        (html! { <BadgeRussianRuble /> }, "Badge Russian Ruble"),
+        (html! { <BadgeSwissFranc /> }, "Badge Swiss Franc"),
+        (html! { <BadgeX /> }, "Badge X"),
+        (html! { <Badge /> }, "Badge"),
+        (html! { <BaggageClaim /> }, "Baggage Claim"),
+        (html! { <Ban /> }, "Ban"),
+        (html! { <Banana /> }, "Banana"),
+        (html! { <Bandage /> }, "Bandage"),
+        (html! { <Banknote /> }, "Banknote"),
+        (html! { <Barcode /> }, "Barcode"),
+        (html! { <Baseline /> }, "Baseline"),
+        (html! { <Bath /> }, "Bath"),
+        (html! { <BatteryCharging /> }, "Battery Charging"),
+        (html! { <BatteryFull /> }, "Battery Full"),
+        (html! { <BatteryLow /> }, "Battery Low"),
+        (html! { <BatteryMedium /> }, "Battery Medium"),
+        (html! { <BatteryWarning /> }, "Battery Warning"),
+        (html! { <Battery /> }, "Battery"),
+        (html! { <Beaker /> }, "Beaker"),
+        (html! { <BeanOff /> }, "Bean Off"),
+        (html! { <Bean /> }, "Bean"),
+        (html! { <BedDouble /> }, "Bed Double"),
+        (html! { <BedSingle /> }, "Bed Single"),
+        (html! { <Bed /> }, "Bed"),
+        (html! { <Beef /> }, "Beef"),
+        (html! { <BeerOff /> }, "Beer Off"),
+        (html! { <Beer /> }, "Beer"),
+        (html! { <BellDot /> }, "Bell Dot"),
+        (html! { <BellElectric /> }, "Bell Electric"),
+        (html! { <BellMinus /> }, "Bell Minus"),
+        (html! { <BellOff /> }, "Bell Off"),
+        (html! { <BellPlus /> }, "Bell Plus"),
+        (html! { <BellRing /> }, "Bell Ring"),
+        (html! { <Bell /> }, "Bell"),
+        (html! { <BetweenHorizontalEnd /> }, "Between Horizontal End"),
+        (
+            html! { <BetweenHorizontalStart /> },
+            "Between Horizontal Start",
+        ),
+        (html! { <BetweenVerticalEnd /> }, "Between Vertical End"),
+        (html! { <BetweenVerticalStart /> }, "Between Vertical Start"),
+        (html! { <BicepsFlexed /> }, "Biceps Flexed"),
+        (html! { <Bike /> }, "Bike"),
+        (html! { <Binary /> }, "Binary"),
+        (html! { <Binoculars /> }, "Binoculars"),
+        (html! { <Biohazard /> }, "Biohazard"),
+        (html! { <Bird /> }, "Bird"),
+        (html! { <Bitcoin /> }, "Bitcoin"),
+        (html! { <Blend /> }, "Blend"),
+        (html! { <Blinds /> }, "Blinds"),
+        (html! { <Blocks /> }, "Blocks"),
+        (html! { <BluetoothConnected /> }, "Bluetooth Connected"),
+        (html! { <BluetoothOff /> }, "Bluetooth Off"),
+        (html! { <BluetoothSearching /> }, "Bluetooth Searching"),
+        (html! { <Bluetooth /> }, "Bluetooth"),
+        (html! { <Bold /> }, "Bold"),
+        (html! { <Bolt /> }, "Bolt"),
+        (html! { <Bomb /> }, "Bomb"),
+        (html! { <Bone /> }, "Bone"),
+        (html! { <BookA /> }, "Book A"),
+        (html! { <BookAudio /> }, "Book Audio"),
+        (html! { <BookCheck /> }, "Book Check"),
+        (html! { <BookCopy /> }, "Book Copy"),
+        (html! { <BookDashed /> }, "Book Dashed"),
+        (html! { <BookDown /> }, "Book Down"),
+        (html! { <BookHeadphones /> }, "Book Headphones"),
+        (html! { <BookHeart /> }, "Book Heart"),
+        (html! { <BookImage /> }, "Book Image"),
+        (html! { <BookKey /> }, "Book Key"),
+        (html! { <BookLock /> }, "Book Lock"),
+        (html! { <BookMarked /> }, "Book Marked"),
+        (html! { <BookMinus /> }, "Book Minus"),
+        (html! { <BookOpenCheck /> }, "Book Open Check"),
+        (html! { <BookOpenText /> }, "Book Open Text"),
+        (html! { <BookOpen /> }, "Book Open"),
+        (html! { <BookPlus /> }, "Book Plus"),
+        (html! { <BookText /> }, "Book Text"),
+        (html! { <BookType /> }, "Book Type"),
+        (html! { <BookUp2 /> }, "Book Up 2"),
+        (html! { <BookUp /> }, "Book Up"),
+        (html! { <BookUser /> }, "Book User"),
+        (html! { <BookX /> }, "Book X"),
+        (html! { <Book /> }, "Book"),
+        (html! { <BookmarkCheck /> }, "Bookmark Check"),
+        (html! { <BookmarkMinus /> }, "Bookmark Minus"),
+        (html! { <BookmarkPlus /> }, "Bookmark Plus"),
+        (html! { <BookmarkX /> }, "Bookmark X"),
+        (html! { <Bookmark /> }, "Bookmark"),
+        (html! { <BoomBox /> }, "Boom Box"),
+        (html! { <BotMessageSquare /> }, "Bot Message Square"),
+        (html! { <BotOff /> }, "Bot Off"),
+        (html! { <Bot /> }, "Bot"),
+        (html! { <Box /> }, "Box"),
+        (html! { <Boxes /> }, "Boxes"),
+        (html! { <Braces /> }, "Braces"),
+        (html! { <Brackets /> }, "Brackets"),
+        (html! { <BrainCircuit /> }, "Brain Circuit"),
+        (html! { <BrainCog /> }, "Brain Cog"),
+        (html! { <Brain /> }, "Brain"),
+        (html! { <BrickWall /> }, "Brick Wall"),
+        (html! { <BriefcaseBusiness /> }, "Briefcase Business"),
+        (
+            html! { <BriefcaseConveyorBelt /> },
+            "Briefcase Conveyor Belt",
+        ),
+        (html! { <BriefcaseMedical /> }, "Briefcase Medical"),
+        (html! { <Briefcase /> }, "Briefcase"),
+        (html! { <BringToFront /> }, "Bring To Front"),
+        (html! { <Brush /> }, "Brush"),
+        (html! { <BugOff /> }, "Bug Off"),
+        (html! { <BugPlay /> }, "Bug Play"),
+        (html! { <Bug /> }, "Bug"),
+        (html! { <Building2 /> }, "Building 2"),
+        (html! { <Building /> }, "Building"),
+        (html! { <BusFront /> }, "Bus Front"),
+        (html! { <Bus /> }, "Bus"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsC() -> Html {
+    let icons = [
+        (html! { <CableCar /> }, "Cable Car"),
+        (html! { <Cable /> }, "Cable"),
+        (html! { <CakeSlice /> }, "Cake Slice"),
+        (html! { <Cake /> }, "Cake"),
+        (html! { <Calculator /> }, "Calculator"),
+        (html! { <Calendar1 /> }, "Calendar 1"),
+        (html! { <CalendarArrowDown /> }, "Calendar Arrow Down"),
+        (html! { <CalendarArrowUp /> }, "Calendar Arrow Up"),
+        (html! { <CalendarCheck2 /> }, "Calendar Check 2"),
+        (html! { <CalendarCheck /> }, "Calendar Check"),
+        (html! { <CalendarClock /> }, "Calendar Clock"),
+        (html! { <CalendarCog /> }, "Calendar Cog"),
+        (html! { <CalendarDays /> }, "Calendar Days"),
+        (html! { <CalendarFold /> }, "Calendar Fold"),
+        (html! { <CalendarHeart /> }, "Calendar Heart"),
+        (html! { <CalendarMinus2 /> }, "Calendar Minus 2"),
+        (html! { <CalendarMinus /> }, "Calendar Minus"),
+        (html! { <CalendarOff /> }, "Calendar Off"),
+        (html! { <CalendarPlus2 /> }, "Calendar Plus 2"),
+        (html! { <CalendarPlus /> }, "Calendar Plus"),
+        (html! { <CalendarRange /> }, "Calendar Range"),
+        (html! { <CalendarSearch /> }, "Calendar Search"),
+        (html! { <CalendarX2 /> }, "Calendar X 2"),
+        (html! { <CalendarX /> }, "Calendar X"),
+        (html! { <Calendar /> }, "Calendar"),
+        (html! { <CameraOff /> }, "Camera Off"),
+        (html! { <Camera /> }, "Camera"),
+        (html! { <CandyCane /> }, "Candy Cane"),
+        (html! { <CandyOff /> }, "Candy Off"),
+        (html! { <Candy /> }, "Candy"),
+        (html! { <Cannabis /> }, "Cannabis"),
+        (html! { <CaptionsOff /> }, "Captions Off"),
+        (html! { <Captions /> }, "Captions"),
+        (html! { <CarFront /> }, "Car Front"),
+        (html! { <CarTaxiFront /> }, "Car Taxi Front"),
+        (html! { <Car /> }, "Car"),
+        (html! { <Caravan /> }, "Caravan"),
+        (html! { <Carrot /> }, "Carrot"),
+        (html! { <CaseLower /> }, "Case Lower"),
+        (html! { <CaseSensitive /> }, "Case Sensitive"),
+        (html! { <CaseUpper /> }, "Case Upper"),
+        (html! { <CassetteTape /> }, "Cassette Tape"),
+        (html! { <Cast /> }, "Cast"),
+        (html! { <Castle /> }, "Castle"),
+        (html! { <Cat /> }, "Cat"),
+        (html! { <Cctv /> }, "Cctv"),
+        (html! { <ChartArea /> }, "Chart Area"),
+        (html! { <ChartBarBig /> }, "Chart Bar Big"),
+        (html! { <ChartBarDecreasing /> }, "Chart Bar Decreasing"),
+        (html! { <ChartBarIncreasing /> }, "Chart Bar Increasing"),
+        (html! { <ChartBarStacked /> }, "Chart Bar Stacked"),
+        (html! { <ChartBar /> }, "Chart Bar"),
+        (html! { <ChartCandlestick /> }, "Chart Candlestick"),
+        (html! { <ChartColumnBig /> }, "Chart Column Big"),
+        (
+            html! { <ChartColumnDecreasing /> },
+            "Chart Column Decreasing",
+        ),
+        (
+            html! { <ChartColumnIncreasing /> },
+            "Chart Column Increasing",
+        ),
+        (html! { <ChartColumnStacked /> }, "Chart Column Stacked"),
+        (html! { <ChartColumn /> }, "Chart Column"),
+        (html! { <ChartGantt /> }, "Chart Gantt"),
+        (html! { <ChartLine /> }, "Chart Line"),
+        (html! { <ChartNetwork /> }, "Chart Network"),
+        (
+            html! { <ChartNoAxesColumnDecreasing /> },
+            "Chart No Axes Column Decreasing",
+        ),
+        (
+            html! { <ChartNoAxesColumnIncreasing /> },
+            "Chart No Axes Column Increasing",
+        ),
+        (html! { <ChartNoAxesColumn /> }, "Chart No Axes Column"),
+        (html! { <ChartNoAxesCombined /> }, "Chart No Axes Combined"),
+        (html! { <ChartNoAxesGantt /> }, "Chart No Axes Gantt"),
+        (html! { <ChartPie /> }, "Chart Pie"),
+        (html! { <ChartScatter /> }, "Chart Scatter"),
+        (html! { <ChartSpline /> }, "Chart Spline"),
+        (html! { <CheckCheck /> }, "Check Check"),
+        (html! { <Check /> }, "Check"),
+        (html! { <ChefHat /> }, "Chef Hat"),
+        (html! { <Cherry /> }, "Cherry"),
+        (html! { <ChevronDown /> }, "Chevron Down"),
+        (html! { <ChevronFirst /> }, "Chevron First"),
+        (html! { <ChevronLast /> }, "Chevron Last"),
+        (html! { <ChevronLeft /> }, "Chevron Left"),
+        (html! { <ChevronRight /> }, "Chevron Right"),
+        (html! { <ChevronUp /> }, "Chevron Up"),
+        (html! { <ChevronsDownUp /> }, "Chevrons Down Up"),
+        (html! { <ChevronsDown /> }, "Chevrons Down"),
+        (
+            html! { <ChevronsLeftRightEllipsis /> },
+            "Chevrons Left Right Ellipsis",
+        ),
+        (html! { <ChevronsLeftRight /> }, "Chevrons Left Right"),
+        (html! { <ChevronsLeft /> }, "Chevrons Left"),
+        (html! { <ChevronsRightLeft /> }, "Chevrons Right Left"),
+        (html! { <ChevronsRight /> }, "Chevrons Right"),
+        (html! { <ChevronsUpDown /> }, "Chevrons Up Down"),
+        (html! { <ChevronsUp /> }, "Chevrons Up"),
+        (html! { <Chrome /> }, "Chrome"),
+        (html! { <Church /> }, "Church"),
+        (html! { <CigaretteOff /> }, "Cigarette Off"),
+        (html! { <Cigarette /> }, "Cigarette"),
+        (html! { <CircleAlert /> }, "Circle Alert"),
+        (html! { <CircleArrowDown /> }, "Circle Arrow Down"),
+        (html! { <CircleArrowLeft /> }, "Circle Arrow Left"),
+        (
+            html! { <CircleArrowOutDownLeft /> },
+            "Circle Arrow Out Down Left",
+        ),
+        (
+            html! { <CircleArrowOutDownRight /> },
+            "Circle Arrow Out Down Right",
+        ),
+        (
+            html! { <CircleArrowOutUpLeft /> },
+            "Circle Arrow Out Up Left",
+        ),
+        (
+            html! { <CircleArrowOutUpRight /> },
+            "Circle Arrow Out Up Right",
+        ),
+        (html! { <CircleArrowRight /> }, "Circle Arrow Right"),
+        (html! { <CircleArrowUp /> }, "Circle Arrow Up"),
+        (html! { <CircleCheckBig /> }, "Circle Check Big"),
+        (html! { <CircleCheck /> }, "Circle Check"),
+        (html! { <CircleChevronDown /> }, "Circle Chevron Down"),
+        (html! { <CircleChevronLeft /> }, "Circle Chevron Left"),
+        (html! { <CircleChevronRight /> }, "Circle Chevron Right"),
+        (html! { <CircleChevronUp /> }, "Circle Chevron Up"),
+        (html! { <CircleDashed /> }, "Circle Dashed"),
+        (html! { <CircleDivide /> }, "Circle Divide"),
+        (html! { <CircleDollarSign /> }, "Circle Dollar Sign"),
+        (html! { <CircleDotDashed /> }, "Circle Dot Dashed"),
+        (html! { <CircleDot /> }, "Circle Dot"),
+        (html! { <CircleEllipsis /> }, "Circle Ellipsis"),
+        (html! { <CircleEqual /> }, "Circle Equal"),
+        (html! { <CircleFadingArrowUp /> }, "Circle Fading Arrow Up"),
+        (html! { <CircleFadingPlus /> }, "Circle Fading Plus"),
+        (html! { <CircleGauge /> }, "Circle Gauge"),
+        (html! { <CircleHelp /> }, "Circle Help"),
+        (html! { <CircleMinus /> }, "Circle Minus"),
+        (html! { <CircleOff /> }, "Circle Off"),
+        (html! { <CircleParkingOff /> }, "Circle Parking Off"),
+        (html! { <CircleParking /> }, "Circle Parking"),
+        (html! { <CirclePause /> }, "Circle Pause"),
+        (html! { <CirclePercent /> }, "Circle Percent"),
+        (html! { <CirclePlay /> }, "Circle Play"),
+        (html! { <CirclePlus /> }, "Circle Plus"),
+        (html! { <CirclePower /> }, "Circle Power"),
+        (html! { <CircleSlash2 /> }, "Circle Slash 2"),
+        (html! { <CircleSlash /> }, "Circle Slash"),
+        (html! { <CircleStop /> }, "Circle Stop"),
+        (html! { <CircleUserRound /> }, "Circle User Round"),
+        (html! { <CircleUser /> }, "Circle User"),
+        (html! { <CircleX /> }, "Circle X"),
+        (html! { <Circle /> }, "Circle"),
+        (html! { <CircuitBoard /> }, "Circuit Board"),
+        (html! { <Citrus /> }, "Citrus"),
+        (html! { <Clapperboard /> }, "Clapperboard"),
+        (html! { <ClipboardCheck /> }, "Clipboard Check"),
+        (html! { <ClipboardCopy /> }, "Clipboard Copy"),
+        (html! { <ClipboardList /> }, "Clipboard List"),
+        (html! { <ClipboardMinus /> }, "Clipboard Minus"),
+        (html! { <ClipboardPaste /> }, "Clipboard Paste"),
+        (html! { <ClipboardPenLine /> }, "Clipboard Pen Line"),
+        (html! { <ClipboardPen /> }, "Clipboard Pen"),
+        (html! { <ClipboardPlus /> }, "Clipboard Plus"),
+        (html! { <ClipboardType /> }, "Clipboard Type"),
+        (html! { <ClipboardX /> }, "Clipboard X"),
+        (html! { <Clipboard /> }, "Clipboard"),
+        (html! { <Clock1 /> }, "Clock 1"),
+        (html! { <Clock10 /> }, "Clock 10"),
+        (html! { <Clock11 /> }, "Clock 11"),
+        (html! { <Clock12 /> }, "Clock 12"),
+        (html! { <Clock2 /> }, "Clock 2"),
+        (html! { <Clock3 /> }, "Clock 3"),
+        (html! { <Clock4 /> }, "Clock 4"),
+        (html! { <Clock5 /> }, "Clock 5"),
+        (html! { <Clock6 /> }, "Clock 6"),
+        (html! { <Clock7 /> }, "Clock 7"),
+        (html! { <Clock8 /> }, "Clock 8"),
+        (html! { <Clock9 /> }, "Clock 9"),
+        (html! { <ClockAlert /> }, "Clock Alert"),
+        (html! { <ClockArrowDown /> }, "Clock Arrow Down"),
+        (html! { <ClockArrowUp /> }, "Clock Arrow Up"),
+        (html! { <Clock /> }, "Clock"),
+        (html! { <CloudAlert /> }, "Cloud Alert"),
+        (html! { <CloudCog /> }, "Cloud Cog"),
+        (html! { <CloudDownload /> }, "Cloud Download"),
+        (html! { <CloudDrizzle /> }, "Cloud Drizzle"),
+        (html! { <CloudFog /> }, "Cloud Fog"),
+        (html! { <CloudHail /> }, "Cloud Hail"),
+        (html! { <CloudLightning /> }, "Cloud Lightning"),
+        (html! { <CloudMoonRain /> }, "Cloud Moon Rain"),
+        (html! { <CloudMoon /> }, "Cloud Moon"),
+        (html! { <CloudOff /> }, "Cloud Off"),
+        (html! { <CloudRainWind /> }, "Cloud Rain Wind"),
+        (html! { <CloudRain /> }, "Cloud Rain"),
+        (html! { <CloudSnow /> }, "Cloud Snow"),
+        (html! { <CloudSunRain /> }, "Cloud Sun Rain"),
+        (html! { <CloudSun /> }, "Cloud Sun"),
+        (html! { <CloudUpload /> }, "Cloud Upload"),
+        (html! { <Cloud /> }, "Cloud"),
+        (html! { <Cloudy /> }, "Cloudy"),
+        (html! { <Clover /> }, "Clover"),
+        (html! { <Club /> }, "Club"),
+        (html! { <CodeXml /> }, "Code Xml"),
+        (html! { <Code /> }, "Code"),
+        (html! { <Codepen /> }, "Codepen"),
+        (html! { <Codesandbox /> }, "Codesandbox"),
+        (html! { <Coffee /> }, "Coffee"),
+        (html! { <Cog /> }, "Cog"),
+        (html! { <Coins /> }, "Coins"),
+        (html! { <Columns2 /> }, "Columns 2"),
+        (html! { <Columns3 /> }, "Columns 3"),
+        (html! { <Columns4 /> }, "Columns 4"),
+        (html! { <Combine /> }, "Combine"),
+        (html! { <Command /> }, "Command"),
+        (html! { <Compass /> }, "Compass"),
+        (html! { <Component /> }, "Component"),
+        (html! { <Computer /> }, "Computer"),
+        (html! { <ConciergeBell /> }, "Concierge Bell"),
+        (html! { <Cone /> }, "Cone"),
+        (html! { <Construction /> }, "Construction"),
+        (html! { <ContactRound /> }, "Contact Round"),
+        (html! { <Contact /> }, "Contact"),
+        (html! { <Container /> }, "Container"),
+        (html! { <Contrast /> }, "Contrast"),
+        (html! { <Cookie /> }, "Cookie"),
+        (html! { <CookingPot /> }, "Cooking Pot"),
+        (html! { <CopyCheck /> }, "Copy Check"),
+        (html! { <CopyMinus /> }, "Copy Minus"),
+        (html! { <CopyPlus /> }, "Copy Plus"),
+        (html! { <CopySlash /> }, "Copy Slash"),
+        (html! { <CopyX /> }, "Copy X"),
+        (html! { <Copy /> }, "Copy"),
+        (html! { <Copyleft /> }, "Copyleft"),
+        (html! { <Copyright /> }, "Copyright"),
+        (html! { <CornerDownLeft /> }, "Corner Down Left"),
+        (html! { <CornerDownRight /> }, "Corner Down Right"),
+        (html! { <CornerLeftDown /> }, "Corner Left Down"),
+        (html! { <CornerLeftUp /> }, "Corner Left Up"),
+        (html! { <CornerRightDown /> }, "Corner Right Down"),
+        (html! { <CornerRightUp /> }, "Corner Right Up"),
+        (html! { <CornerUpLeft /> }, "Corner Up Left"),
+        (html! { <CornerUpRight /> }, "Corner Up Right"),
+        (html! { <Cpu /> }, "Cpu"),
+        (html! { <CreativeCommons /> }, "Creative Commons"),
+        (html! { <CreditCard /> }, "Credit Card"),
+        (html! { <Croissant /> }, "Croissant"),
+        (html! { <Crop /> }, "Crop"),
+        (html! { <Cross /> }, "Cross"),
+        (html! { <Crosshair /> }, "Crosshair"),
+        (html! { <Crown /> }, "Crown"),
+        (html! { <Cuboid /> }, "Cuboid"),
+        (html! { <CupSoda /> }, "Cup Soda"),
+        (html! { <Currency /> }, "Currency"),
+        (html! { <Cylinder /> }, "Cylinder"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsD() -> Html {
+    let icons = [
+        (html! { <Dam /> }, "Dam"),
+        (html! { <DatabaseBackup /> }, "Database Backup"),
+        (html! { <DatabaseZap /> }, "Database Zap"),
+        (html! { <Database /> }, "Database"),
+        (html! { <Delete /> }, "Delete"),
+        (html! { <Dessert /> }, "Dessert"),
+        (html! { <Diameter /> }, "Diameter"),
+        (html! { <DiamondMinus /> }, "Diamond Minus"),
+        (html! { <DiamondPercent /> }, "Diamond Percent"),
+        (html! { <DiamondPlus /> }, "Diamond Plus"),
+        (html! { <Diamond /> }, "Diamond"),
+        (html! { <Dice1 /> }, "Dice 1"),
+        (html! { <Dice2 /> }, "Dice 2"),
+        (html! { <Dice3 /> }, "Dice 3"),
+        (html! { <Dice4 /> }, "Dice 4"),
+        (html! { <Dice5 /> }, "Dice 5"),
+        (html! { <Dice6 /> }, "Dice 6"),
+        (html! { <Dices /> }, "Dices"),
+        (html! { <Diff /> }, "Diff"),
+        (html! { <Disc2 /> }, "Disc 2"),
+        (html! { <Disc3 /> }, "Disc 3"),
+        (html! { <DiscAlbum /> }, "Disc Album"),
+        (html! { <Disc /> }, "Disc"),
+        (html! { <Divide /> }, "Divide"),
+        (html! { <DnaOff /> }, "Dna Off"),
+        (html! { <Dna /> }, "Dna"),
+        (html! { <Dock /> }, "Dock"),
+        (html! { <Dog /> }, "Dog"),
+        (html! { <DollarSign /> }, "Dollar Sign"),
+        (html! { <Donut /> }, "Donut"),
+        (html! { <DoorClosed /> }, "Door Closed"),
+        (html! { <DoorOpen /> }, "Door Open"),
+        (html! { <Dot /> }, "Dot"),
+        (html! { <Download /> }, "Download"),
+        (html! { <DraftingCompass /> }, "Drafting Compass"),
+        (html! { <Drama /> }, "Drama"),
+        (html! { <Dribbble /> }, "Dribbble"),
+        (html! { <Drill /> }, "Drill"),
+        (html! { <Droplet /> }, "Droplet"),
+        (html! { <Droplets /> }, "Droplets"),
+        (html! { <Drum /> }, "Drum"),
+        (html! { <Drumstick /> }, "Drumstick"),
+        (html! { <Dumbbell /> }, "Dumbbell"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsE() -> Html {
+    let icons = [
+        (html! { <EarOff /> }, "Ear Off"),
+        (html! { <Ear /> }, "Ear"),
+        (html! { <EarthLock /> }, "Earth Lock"),
+        (html! { <Earth /> }, "Earth"),
+        (html! { <Eclipse /> }, "Eclipse"),
+        (html! { <EggFried /> }, "Egg Fried"),
+        (html! { <EggOff /> }, "Egg Off"),
+        (html! { <Egg /> }, "Egg"),
+        (html! { <EllipsisVertical /> }, "Ellipsis Vertical"),
+        (html! { <Ellipsis /> }, "Ellipsis"),
+        (html! { <EqualApproximately /> }, "Equal Approximately"),
+        (html! { <EqualNot /> }, "Equal Not"),
+        (html! { <Equal /> }, "Equal"),
+        (html! { <Eraser /> }, "Eraser"),
+        (html! { <EthernetPort /> }, "Ethernet Port"),
+        (html! { <Euro /> }, "Euro"),
+        (html! { <Expand /> }, "Expand"),
+        (html! { <ExternalLink /> }, "External Link"),
+        (html! { <EyeClosed /> }, "Eye Closed"),
+        (html! { <EyeOff /> }, "Eye Off"),
+        (html! { <Eye /> }, "Eye"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsF() -> Html {
+    let icons = [
+        (html! { <Facebook /> }, "Facebook"),
+        (html! { <Factory /> }, "Factory"),
+        (html! { <Fan /> }, "Fan"),
+        (html! { <FastForward /> }, "Fast Forward"),
+        (html! { <Feather /> }, "Feather"),
+        (html! { <Fence /> }, "Fence"),
+        (html! { <FerrisWheel /> }, "Ferris Wheel"),
+        (html! { <Figma /> }, "Figma"),
+        (html! { <FileArchive /> }, "File Archive"),
+        (html! { <FileAudio2 /> }, "File Audio 2"),
+        (html! { <FileAudio /> }, "File Audio"),
+        (html! { <FileAxis3D /> }, "File Axis 3 D"),
+        (html! { <FileBadge2 /> }, "File Badge 2"),
+        (html! { <FileBadge /> }, "File Badge"),
+        (html! { <FileBox /> }, "File Box"),
+        (
+            html! { <FileChartColumnIncreasing /> },
+            "File Chart Column Increasing",
+        ),
+        (html! { <FileChartColumn /> }, "File Chart Column"),
+        (html! { <FileChartLine /> }, "File Chart Line"),
+        (html! { <FileChartPie /> }, "File Chart Pie"),
+        (html! { <FileCheck2 /> }, "File Check 2"),
+        (html! { <FileCheck /> }, "File Check"),
+        (html! { <FileClock /> }, "File Clock"),
+        (html! { <FileCode2 /> }, "File Code 2"),
+        (html! { <FileCode /> }, "File Code"),
+        (html! { <FileCog /> }, "File Cog"),
+        (html! { <FileDiff /> }, "File Diff"),
+        (html! { <FileDigit /> }, "File Digit"),
+        (html! { <FileDown /> }, "File Down"),
+        (html! { <FileHeart /> }, "File Heart"),
+        (html! { <FileImage /> }, "File Image"),
+        (html! { <FileInput /> }, "File Input"),
+        (html! { <FileJson2 /> }, "File Json 2"),
+        (html! { <FileJson /> }, "File Json"),
+        (html! { <FileKey2 /> }, "File Key 2"),
+        (html! { <FileKey /> }, "File Key"),
+        (html! { <FileLock2 /> }, "File Lock 2"),
+        (html! { <FileLock /> }, "File Lock"),
+        (html! { <FileMinus2 /> }, "File Minus 2"),
+        (html! { <FileMinus /> }, "File Minus"),
+        (html! { <FileMusic /> }, "File Music"),
+        (html! { <FileOutput /> }, "File Output"),
+        (html! { <FilePenLine /> }, "File Pen Line"),
+        (html! { <FilePen /> }, "File Pen"),
+        (html! { <FilePlus2 /> }, "File Plus 2"),
+        (html! { <FilePlus /> }, "File Plus"),
+        (html! { <FileQuestion /> }, "File Question"),
+        (html! { <FileScan /> }, "File Scan"),
+        (html! { <FileSearch2 /> }, "File Search 2"),
+        (html! { <FileSearch /> }, "File Search"),
+        (html! { <FileSliders /> }, "File Sliders"),
+        (html! { <FileSpreadsheet /> }, "File Spreadsheet"),
+        (html! { <FileStack /> }, "File Stack"),
+        (html! { <FileSymlink /> }, "File Symlink"),
+        (html! { <FileTerminal /> }, "File Terminal"),
+        (html! { <FileText /> }, "File Text"),
+        (html! { <FileType2 /> }, "File Type 2"),
+        (html! { <FileType /> }, "File Type"),
+        (html! { <FileUp /> }, "File Up"),
+        (html! { <FileUser /> }, "File User"),
+        (html! { <FileVideo2 /> }, "File Video 2"),
+        (html! { <FileVideo /> }, "File Video"),
+        (html! { <FileVolume2 /> }, "File Volume 2"),
+        (html! { <FileVolume /> }, "File Volume"),
+        (html! { <FileWarning /> }, "File Warning"),
+        (html! { <FileX2 /> }, "File X 2"),
+        (html! { <FileX /> }, "File X"),
+        (html! { <File /> }, "File"),
+        (html! { <Files /> }, "Files"),
+        (html! { <Film /> }, "Film"),
+        (html! { <FilterX /> }, "Filter X"),
+        (html! { <Filter /> }, "Filter"),
+        (html! { <Fingerprint /> }, "Fingerprint"),
+        (html! { <FireExtinguisher /> }, "Fire Extinguisher"),
+        (html! { <FishOff /> }, "Fish Off"),
+        (html! { <FishSymbol /> }, "Fish Symbol"),
+        (html! { <Fish /> }, "Fish"),
+        (html! { <FlagOff /> }, "Flag Off"),
+        (html! { <FlagTriangleLeft /> }, "Flag Triangle Left"),
+        (html! { <FlagTriangleRight /> }, "Flag Triangle Right"),
+        (html! { <Flag /> }, "Flag"),
+        (html! { <FlameKindling /> }, "Flame Kindling"),
+        (html! { <Flame /> }, "Flame"),
+        (html! { <FlashlightOff /> }, "Flashlight Off"),
+        (html! { <Flashlight /> }, "Flashlight"),
+        (html! { <FlaskConicalOff /> }, "Flask Conical Off"),
+        (html! { <FlaskConical /> }, "Flask Conical"),
+        (html! { <FlaskRound /> }, "Flask Round"),
+        (html! { <FlipHorizontal2 /> }, "Flip Horizontal 2"),
+        (html! { <FlipHorizontal /> }, "Flip Horizontal"),
+        (html! { <FlipVertical2 /> }, "Flip Vertical 2"),
+        (html! { <FlipVertical /> }, "Flip Vertical"),
+        (html! { <Flower2 /> }, "Flower 2"),
+        (html! { <Flower /> }, "Flower"),
+        (html! { <Focus /> }, "Focus"),
+        (html! { <FoldHorizontal /> }, "Fold Horizontal"),
+        (html! { <FoldVertical /> }, "Fold Vertical"),
+        (html! { <FolderArchive /> }, "Folder Archive"),
+        (html! { <FolderCheck /> }, "Folder Check"),
+        (html! { <FolderClock /> }, "Folder Clock"),
+        (html! { <FolderClosed /> }, "Folder Closed"),
+        (html! { <FolderCode /> }, "Folder Code"),
+        (html! { <FolderCog /> }, "Folder Cog"),
+        (html! { <FolderDot /> }, "Folder Dot"),
+        (html! { <FolderDown /> }, "Folder Down"),
+        (html! { <FolderGit2 /> }, "Folder Git 2"),
+        (html! { <FolderGit /> }, "Folder Git"),
+        (html! { <FolderHeart /> }, "Folder Heart"),
+        (html! { <FolderInput /> }, "Folder Input"),
+        (html! { <FolderKanban /> }, "Folder Kanban"),
+        (html! { <FolderKey /> }, "Folder Key"),
+        (html! { <FolderLock /> }, "Folder Lock"),
+        (html! { <FolderMinus /> }, "Folder Minus"),
+        (html! { <FolderOpenDot /> }, "Folder Open Dot"),
+        (html! { <FolderOpen /> }, "Folder Open"),
+        (html! { <FolderOutput /> }, "Folder Output"),
+        (html! { <FolderPen /> }, "Folder Pen"),
+        (html! { <FolderPlus /> }, "Folder Plus"),
+        (html! { <FolderRoot /> }, "Folder Root"),
+        (html! { <FolderSearch2 /> }, "Folder Search 2"),
+        (html! { <FolderSearch /> }, "Folder Search"),
+        (html! { <FolderSymlink /> }, "Folder Symlink"),
+        (html! { <FolderSync /> }, "Folder Sync"),
+        (html! { <FolderTree /> }, "Folder Tree"),
+        (html! { <FolderUp /> }, "Folder Up"),
+        (html! { <FolderX /> }, "Folder X"),
+        (html! { <Folder /> }, "Folder"),
+        (html! { <Folders /> }, "Folders"),
+        (html! { <Footprints /> }, "Footprints"),
+        (html! { <Forklift /> }, "Forklift"),
+        (html! { <Forward /> }, "Forward"),
+        (html! { <Frame /> }, "Frame"),
+        (html! { <Framer /> }, "Framer"),
+        (html! { <Frown /> }, "Frown"),
+        (html! { <Fuel /> }, "Fuel"),
+        (html! { <Fullscreen /> }, "Fullscreen"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsG() -> Html {
+    let icons = [
+        (html! { <GalleryHorizontalEnd /> }, "Gallery Horizontal End"),
+        (html! { <GalleryHorizontal /> }, "Gallery Horizontal"),
+        (html! { <GalleryThumbnails /> }, "Gallery Thumbnails"),
+        (html! { <GalleryVerticalEnd /> }, "Gallery Vertical End"),
+        (html! { <GalleryVertical /> }, "Gallery Vertical"),
+        (html! { <Gamepad2 /> }, "Gamepad 2"),
+        (html! { <Gamepad /> }, "Gamepad"),
+        (html! { <Gauge /> }, "Gauge"),
+        (html! { <Gavel /> }, "Gavel"),
+        (html! { <Gem /> }, "Gem"),
+        (html! { <Ghost /> }, "Ghost"),
+        (html! { <Gift /> }, "Gift"),
+        (html! { <GitBranchPlus /> }, "Git Branch Plus"),
+        (html! { <GitBranch /> }, "Git Branch"),
+        (html! { <GitCommitHorizontal /> }, "Git Commit Horizontal"),
+        (html! { <GitCommitVertical /> }, "Git Commit Vertical"),
+        (html! { <GitCompareArrows /> }, "Git Compare Arrows"),
+        (html! { <GitCompare /> }, "Git Compare"),
+        (html! { <GitFork /> }, "Git Fork"),
+        (html! { <GitGraph /> }, "Git Graph"),
+        (html! { <GitMerge /> }, "Git Merge"),
+        (html! { <GitPullRequestArrow /> }, "Git Pull Request Arrow"),
+        (
+            html! { <GitPullRequestClosed /> },
+            "Git Pull Request Closed",
+        ),
+        (
+            html! { <GitPullRequestCreateArrow /> },
+            "Git Pull Request Create Arrow",
+        ),
+        (
+            html! { <GitPullRequestCreate /> },
+            "Git Pull Request Create",
+        ),
+        (html! { <GitPullRequestDraft /> }, "Git Pull Request Draft"),
+        (html! { <GitPullRequest /> }, "Git Pull Request"),
+        (html! { <Github /> }, "Github"),
+        (html! { <Gitlab /> }, "Gitlab"),
+        (html! { <GlassWater /> }, "Glass Water"),
+        (html! { <Glasses /> }, "Glasses"),
+        (html! { <GlobeLock /> }, "Globe Lock"),
+        (html! { <Globe /> }, "Globe"),
+        (html! { <Goal /> }, "Goal"),
+        (html! { <Grab /> }, "Grab"),
+        (html! { <GraduationCap /> }, "Graduation Cap"),
+        (html! { <Grape /> }, "Grape"),
+        (html! { <Grid2X2Check /> }, "Grid 2 X 2 Check"),
+        (html! { <Grid2X2Plus /> }, "Grid 2 X 2 Plus"),
+        (html! { <Grid2X2X /> }, "Grid 2 X 2 X"),
+        (html! { <Grid2X2 /> }, "Grid 2 X 2"),
+        (html! { <Grid3X3 /> }, "Grid 3 X 3"),
+        (html! { <GripHorizontal /> }, "Grip Horizontal"),
+        (html! { <GripVertical /> }, "Grip Vertical"),
+        (html! { <Grip /> }, "Grip"),
+        (html! { <Group /> }, "Group"),
+        (html! { <Guitar /> }, "Guitar"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsH() -> Html {
+    let icons = [
+        (html! { <Ham /> }, "Ham"),
+        (html! { <Hammer /> }, "Hammer"),
+        (html! { <HandCoins /> }, "Hand Coins"),
+        (html! { <HandHeart /> }, "Hand Heart"),
+        (html! { <HandHelping /> }, "Hand Helping"),
+        (html! { <HandMetal /> }, "Hand Metal"),
+        (html! { <HandPlatter /> }, "Hand Platter"),
+        (html! { <Hand /> }, "Hand"),
+        (html! { <Handshake /> }, "Handshake"),
+        (html! { <HardDriveDownload /> }, "Hard Drive Download"),
+        (html! { <HardDriveUpload /> }, "Hard Drive Upload"),
+        (html! { <HardDrive /> }, "Hard Drive"),
+        (html! { <HardHat /> }, "Hard Hat"),
+        (html! { <Hash /> }, "Hash"),
+        (html! { <Haze /> }, "Haze"),
+        (html! { <HdmiPort /> }, "Hdmi Port"),
+        (html! { <Heading1 /> }, "Heading 1"),
+        (html! { <Heading2 /> }, "Heading 2"),
+        (html! { <Heading3 /> }, "Heading 3"),
+        (html! { <Heading4 /> }, "Heading 4"),
+        (html! { <Heading5 /> }, "Heading 5"),
+        (html! { <Heading6 /> }, "Heading 6"),
+        (html! { <Heading /> }, "Heading"),
+        (html! { <HeadphoneOff /> }, "Headphone Off"),
+        (html! { <Headphones /> }, "Headphones"),
+        (html! { <Headset /> }, "Headset"),
+        (html! { <HeartCrack /> }, "Heart Crack"),
+        (html! { <HeartHandshake /> }, "Heart Handshake"),
+        (html! { <HeartOff /> }, "Heart Off"),
+        (html! { <HeartPulse /> }, "Heart Pulse"),
+        (html! { <Heart /> }, "Heart"),
+        (html! { <Heater /> }, "Heater"),
+        (html! { <Hexagon /> }, "Hexagon"),
+        (html! { <Highlighter /> }, "Highlighter"),
+        (html! { <History /> }, "History"),
+        (html! { <HopOff /> }, "Hop Off"),
+        (html! { <Hop /> }, "Hop"),
+        (html! { <Hospital /> }, "Hospital"),
+        (html! { <Hotel /> }, "Hotel"),
+        (html! { <Hourglass /> }, "Hourglass"),
+        (html! { <HousePlug /> }, "House Plug"),
+        (html! { <HousePlus /> }, "House Plus"),
+        (html! { <House /> }, "House"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsI() -> Html {
+    let icons = [
+        (html! { <IceCreamBowl /> }, "Ice Cream Bowl"),
+        (html! { <IceCreamCone /> }, "Ice Cream Cone"),
+        (html! { <IdCard /> }, "Id Card"),
+        (html! { <ImageDown /> }, "Image Down"),
+        (html! { <ImageMinus /> }, "Image Minus"),
+        (html! { <ImageOff /> }, "Image Off"),
+        (html! { <ImagePlay /> }, "Image Play"),
+        (html! { <ImagePlus /> }, "Image Plus"),
+        (html! { <ImageUp /> }, "Image Up"),
+        (html! { <Image /> }, "Image"),
+        (html! { <Images /> }, "Images"),
+        (html! { <Import /> }, "Import"),
+        (html! { <Inbox /> }, "Inbox"),
+        (html! { <IndentDecrease /> }, "Indent Decrease"),
+        (html! { <IndentIncrease /> }, "Indent Increase"),
+        (html! { <IndianRupee /> }, "Indian Rupee"),
+        (html! { <Infinity /> }, "Infinity"),
+        (html! { <Info /> }, "Info"),
+        (html! { <InspectionPanel /> }, "Inspection Panel"),
+        (html! { <Instagram /> }, "Instagram"),
+        (html! { <Italic /> }, "Italic"),
+        (html! { <IterationCcw /> }, "Iteration Ccw"),
+        (html! { <IterationCw /> }, "Iteration Cw"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsJ() -> Html {
+    let icons = [
+        (html! { <JapaneseYen /> }, "Japanese Yen"),
+        (html! { <Joystick /> }, "Joystick"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsK() -> Html {
+    let icons = [
+        (html! { <Kanban /> }, "Kanban"),
+        (html! { <KeyRound /> }, "Key Round"),
+        (html! { <KeySquare /> }, "Key Square"),
+        (html! { <Key /> }, "Key"),
+        (html! { <KeyboardMusic /> }, "Keyboard Music"),
+        (html! { <KeyboardOff /> }, "Keyboard Off"),
+        (html! { <Keyboard /> }, "Keyboard"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsL() -> Html {
+    let icons = [
+        (html! { <LampCeiling /> }, "Lamp Ceiling"),
+        (html! { <LampDesk /> }, "Lamp Desk"),
+        (html! { <LampFloor /> }, "Lamp Floor"),
+        (html! { <LampWallDown /> }, "Lamp Wall Down"),
+        (html! { <LampWallUp /> }, "Lamp Wall Up"),
+        (html! { <Lamp /> }, "Lamp"),
+        (html! { <LandPlot /> }, "Land Plot"),
+        (html! { <Landmark /> }, "Landmark"),
+        (html! { <Languages /> }, "Languages"),
+        (html! { <LaptopMinimalCheck /> }, "Laptop Minimal Check"),
+        (html! { <LaptopMinimal /> }, "Laptop Minimal"),
+        (html! { <Laptop /> }, "Laptop"),
+        (html! { <LassoSelect /> }, "Lasso Select"),
+        (html! { <Lasso /> }, "Lasso"),
+        (html! { <Laugh /> }, "Laugh"),
+        (html! { <Layers2 /> }, "Layers 2"),
+        (html! { <Layers3 /> }, "Layers 3"),
+        (html! { <Layers /> }, "Layers"),
+        (html! { <LayoutDashboard /> }, "Layout Dashboard"),
+        (html! { <LayoutGrid /> }, "Layout Grid"),
+        (html! { <LayoutList /> }, "Layout List"),
+        (html! { <LayoutPanelLeft /> }, "Layout Panel Left"),
+        (html! { <LayoutPanelTop /> }, "Layout Panel Top"),
+        (html! { <LayoutTemplate /> }, "Layout Template"),
+        (html! { <Leaf /> }, "Leaf"),
+        (html! { <LeafyGreen /> }, "Leafy Green"),
+        (html! { <Lectern /> }, "Lectern"),
+        (html! { <LetterText /> }, "Letter Text"),
+        (html! { <LibraryBig /> }, "Library Big"),
+        (html! { <Library /> }, "Library"),
+        (html! { <LifeBuoy /> }, "Life Buoy"),
+        (html! { <Ligature /> }, "Ligature"),
+        (html! { <LightbulbOff /> }, "Lightbulb Off"),
+        (html! { <Lightbulb /> }, "Lightbulb"),
+        (html! { <Link2Off /> }, "Link 2 Off"),
+        (html! { <Link2 /> }, "Link 2"),
+        (html! { <Link /> }, "Link"),
+        (html! { <Linkedin /> }, "Linkedin"),
+        (html! { <ListCheck /> }, "List Check"),
+        (html! { <ListChecks /> }, "List Checks"),
+        (html! { <ListCollapse /> }, "List Collapse"),
+        (html! { <ListEnd /> }, "List End"),
+        (html! { <ListFilter /> }, "List Filter"),
+        (html! { <ListMinus /> }, "List Minus"),
+        (html! { <ListMusic /> }, "List Music"),
+        (html! { <ListOrdered /> }, "List Ordered"),
+        (html! { <ListPlus /> }, "List Plus"),
+        (html! { <ListRestart /> }, "List Restart"),
+        (html! { <ListStart /> }, "List Start"),
+        (html! { <ListTodo /> }, "List Todo"),
+        (html! { <ListTree /> }, "List Tree"),
+        (html! { <ListVideo /> }, "List Video"),
+        (html! { <ListX /> }, "List X"),
+        (html! { <List /> }, "List"),
+        (html! { <LoaderCircle /> }, "Loader Circle"),
+        (html! { <LoaderPinwheel /> }, "Loader Pinwheel"),
+        (html! { <Loader /> }, "Loader"),
+        (html! { <LocateFixed /> }, "Locate Fixed"),
+        (html! { <LocateOff /> }, "Locate Off"),
+        (html! { <Locate /> }, "Locate"),
+        (html! { <LockKeyholeOpen /> }, "Lock Keyhole Open"),
+        (html! { <LockKeyhole /> }, "Lock Keyhole"),
+        (html! { <LockOpen /> }, "Lock Open"),
+        (html! { <Lock /> }, "Lock"),
+        (html! { <LogIn /> }, "Log In"),
+        (html! { <LogOut /> }, "Log Out"),
+        (html! { <Logs /> }, "Logs"),
+        (html! { <Lollipop /> }, "Lollipop"),
+        (html! { <Luggage /> }, "Luggage"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsM() -> Html {
+    let icons = [
+        (html! { <Magnet /> }, "Magnet"),
+        (html! { <MailCheck /> }, "Mail Check"),
+        (html! { <MailMinus /> }, "Mail Minus"),
+        (html! { <MailOpen /> }, "Mail Open"),
+        (html! { <MailPlus /> }, "Mail Plus"),
+        (html! { <MailQuestion /> }, "Mail Question"),
+        (html! { <MailSearch /> }, "Mail Search"),
+        (html! { <MailWarning /> }, "Mail Warning"),
+        (html! { <MailX /> }, "Mail X"),
+        (html! { <Mail /> }, "Mail"),
+        (html! { <Mailbox /> }, "Mailbox"),
+        (html! { <Mails /> }, "Mails"),
+        (html! { <MapPinCheckInside /> }, "Map Pin Check Inside"),
+        (html! { <MapPinCheck /> }, "Map Pin Check"),
+        (html! { <MapPinHouse /> }, "Map Pin House"),
+        (html! { <MapPinMinusInside /> }, "Map Pin Minus Inside"),
+        (html! { <MapPinMinus /> }, "Map Pin Minus"),
+        (html! { <MapPinOff /> }, "Map Pin Off"),
+        (html! { <MapPinPlusInside /> }, "Map Pin Plus Inside"),
+        (html! { <MapPinPlus /> }, "Map Pin Plus"),
+        (html! { <MapPinXInside /> }, "Map Pin X Inside"),
+        (html! { <MapPinX /> }, "Map Pin X"),
+        (html! { <MapPin /> }, "Map Pin"),
+        (html! { <MapPinned /> }, "Map Pinned"),
+        (html! { <Map /> }, "Map"),
+        (html! { <Martini /> }, "Martini"),
+        (html! { <Maximize2 /> }, "Maximize 2"),
+        (html! { <Maximize /> }, "Maximize"),
+        (html! { <Medal /> }, "Medal"),
+        (html! { <MegaphoneOff /> }, "Megaphone Off"),
+        (html! { <Megaphone /> }, "Megaphone"),
+        (html! { <Meh /> }, "Meh"),
+        (html! { <MemoryStick /> }, "Memory Stick"),
+        (html! { <Menu /> }, "Menu"),
+        (html! { <Merge /> }, "Merge"),
+        (html! { <MessageCircleCode /> }, "Message Circle Code"),
+        (html! { <MessageCircleDashed /> }, "Message Circle Dashed"),
+        (html! { <MessageCircleHeart /> }, "Message Circle Heart"),
+        (html! { <MessageCircleMore /> }, "Message Circle More"),
+        (html! { <MessageCircleOff /> }, "Message Circle Off"),
+        (html! { <MessageCirclePlus /> }, "Message Circle Plus"),
+        (
+            html! { <MessageCircleQuestion /> },
+            "Message Circle Question",
+        ),
+        (html! { <MessageCircleReply /> }, "Message Circle Reply"),
+        (html! { <MessageCircleWarning /> }, "Message Circle Warning"),
+        (html! { <MessageCircleX /> }, "Message Circle X"),
+        (html! { <MessageCircle /> }, "Message Circle"),
+        (html! { <MessageSquareCode /> }, "Message Square Code"),
+        (html! { <MessageSquareDashed /> }, "Message Square Dashed"),
+        (html! { <MessageSquareDiff /> }, "Message Square Diff"),
+        (html! { <MessageSquareDot /> }, "Message Square Dot"),
+        (html! { <MessageSquareHeart /> }, "Message Square Heart"),
+        (html! { <MessageSquareLock /> }, "Message Square Lock"),
+        (html! { <MessageSquareMore /> }, "Message Square More"),
+        (html! { <MessageSquareOff /> }, "Message Square Off"),
+        (html! { <MessageSquarePlus /> }, "Message Square Plus"),
+        (html! { <MessageSquareQuote /> }, "Message Square Quote"),
+        (html! { <MessageSquareReply /> }, "Message Square Reply"),
+        (html! { <MessageSquareShare /> }, "Message Square Share"),
+        (html! { <MessageSquareText /> }, "Message Square Text"),
+        (html! { <MessageSquareWarning /> }, "Message Square Warning"),
+        (html! { <MessageSquareX /> }, "Message Square X"),
+        (html! { <MessageSquare /> }, "Message Square"),
+        (html! { <MessagesSquare /> }, "Messages Square"),
+        (html! { <MicOff /> }, "Mic Off"),
+        (html! { <MicVocal /> }, "Mic Vocal"),
+        (html! { <Mic /> }, "Mic"),
+        (html! { <Microchip /> }, "Microchip"),
+        (html! { <Microscope /> }, "Microscope"),
+        (html! { <Microwave /> }, "Microwave"),
+        (html! { <Milestone /> }, "Milestone"),
+        (html! { <MilkOff /> }, "Milk Off"),
+        (html! { <Milk /> }, "Milk"),
+        (html! { <Minimize2 /> }, "Minimize 2"),
+        (html! { <Minimize /> }, "Minimize"),
+        (html! { <Minus /> }, "Minus"),
+        (html! { <MonitorCheck /> }, "Monitor Check"),
+        (html! { <MonitorCog /> }, "Monitor Cog"),
+        (html! { <MonitorDot /> }, "Monitor Dot"),
+        (html! { <MonitorDown /> }, "Monitor Down"),
+        (html! { <MonitorOff /> }, "Monitor Off"),
+        (html! { <MonitorPause /> }, "Monitor Pause"),
+        (html! { <MonitorPlay /> }, "Monitor Play"),
+        (html! { <MonitorSmartphone /> }, "Monitor Smartphone"),
+        (html! { <MonitorSpeaker /> }, "Monitor Speaker"),
+        (html! { <MonitorStop /> }, "Monitor Stop"),
+        (html! { <MonitorUp /> }, "Monitor Up"),
+        (html! { <MonitorX /> }, "Monitor X"),
+        (html! { <Monitor /> }, "Monitor"),
+        (html! { <MoonStar /> }, "Moon Star"),
+        (html! { <Moon /> }, "Moon"),
+        (html! { <MountainSnow /> }, "Mountain Snow"),
+        (html! { <Mountain /> }, "Mountain"),
+        (html! { <MouseOff /> }, "Mouse Off"),
+        (html! { <MousePointer2 /> }, "Mouse Pointer 2"),
+        (html! { <MousePointerBan /> }, "Mouse Pointer Ban"),
+        (html! { <MousePointerClick /> }, "Mouse Pointer Click"),
+        (html! { <MousePointer /> }, "Mouse Pointer"),
+        (html! { <Mouse /> }, "Mouse"),
+        (html! { <Move3D /> }, "Move 3 D"),
+        (html! { <MoveDiagonal2 /> }, "Move Diagonal 2"),
+        (html! { <MoveDiagonal /> }, "Move Diagonal"),
+        (html! { <MoveDownLeft /> }, "Move Down Left"),
+        (html! { <MoveDownRight /> }, "Move Down Right"),
+        (html! { <MoveDown /> }, "Move Down"),
+        (html! { <MoveHorizontal /> }, "Move Horizontal"),
+        (html! { <MoveLeft /> }, "Move Left"),
+        (html! { <MoveRight /> }, "Move Right"),
+        (html! { <MoveUpLeft /> }, "Move Up Left"),
+        (html! { <MoveUpRight /> }, "Move Up Right"),
+        (html! { <MoveUp /> }, "Move Up"),
+        (html! { <MoveVertical /> }, "Move Vertical"),
+        (html! { <Move /> }, "Move"),
+        (html! { <Music2 /> }, "Music 2"),
+        (html! { <Music3 /> }, "Music 3"),
+        (html! { <Music4 /> }, "Music 4"),
+        (html! { <Music /> }, "Music"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsN() -> Html {
+    let icons = [
+        (html! { <Navigation2Off /> }, "Navigation 2 Off"),
+        (html! { <Navigation2 /> }, "Navigation 2"),
+        (html! { <NavigationOff /> }, "Navigation Off"),
+        (html! { <Navigation /> }, "Navigation"),
+        (html! { <Network /> }, "Network"),
+        (html! { <Newspaper /> }, "Newspaper"),
+        (html! { <Nfc /> }, "Nfc"),
+        (html! { <NotebookPen /> }, "Notebook Pen"),
+        (html! { <NotebookTabs /> }, "Notebook Tabs"),
+        (html! { <NotebookText /> }, "Notebook Text"),
+        (html! { <Notebook /> }, "Notebook"),
+        (html! { <NotepadTextDashed /> }, "Notepad Text Dashed"),
+        (html! { <NotepadText /> }, "Notepad Text"),
+        (html! { <NutOff /> }, "Nut Off"),
+        (html! { <Nut /> }, "Nut"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsO() -> Html {
+    let icons = [
+        (html! { <OctagonAlert /> }, "Octagon Alert"),
+        (html! { <OctagonMinus /> }, "Octagon Minus"),
+        (html! { <OctagonPause /> }, "Octagon Pause"),
+        (html! { <OctagonX /> }, "Octagon X"),
+        (html! { <Octagon /> }, "Octagon"),
+        (html! { <Omega /> }, "Omega"),
+        (html! { <Option /> }, "Option"),
+        (html! { <Orbit /> }, "Orbit"),
+        (html! { <Origami /> }, "Origami"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsP() -> Html {
+    let icons = [
+        (html! { <Package2 /> }, "Package 2"),
+        (html! { <PackageCheck /> }, "Package Check"),
+        (html! { <PackageMinus /> }, "Package Minus"),
+        (html! { <PackageOpen /> }, "Package Open"),
+        (html! { <PackagePlus /> }, "Package Plus"),
+        (html! { <PackageSearch /> }, "Package Search"),
+        (html! { <PackageX /> }, "Package X"),
+        (html! { <Package /> }, "Package"),
+        (html! { <PaintBucket /> }, "Paint Bucket"),
+        (html! { <PaintRoller /> }, "Paint Roller"),
+        (html! { <PaintbrushVertical /> }, "Paintbrush Vertical"),
+        (html! { <Paintbrush /> }, "Paintbrush"),
+        (html! { <Palette /> }, "Palette"),
+        (html! { <PanelBottomClose /> }, "Panel Bottom Close"),
+        (html! { <PanelBottomDashed /> }, "Panel Bottom Dashed"),
+        (html! { <PanelBottomOpen /> }, "Panel Bottom Open"),
+        (html! { <PanelBottom /> }, "Panel Bottom"),
+        (html! { <PanelLeftClose /> }, "Panel Left Close"),
+        (html! { <PanelLeftDashed /> }, "Panel Left Dashed"),
+        (html! { <PanelLeftOpen /> }, "Panel Left Open"),
+        (html! { <PanelLeft /> }, "Panel Left"),
+        (html! { <PanelRightClose /> }, "Panel Right Close"),
+        (html! { <PanelRightDashed /> }, "Panel Right Dashed"),
+        (html! { <PanelRightOpen /> }, "Panel Right Open"),
+        (html! { <PanelRight /> }, "Panel Right"),
+        (html! { <PanelTopClose /> }, "Panel Top Close"),
+        (html! { <PanelTopDashed /> }, "Panel Top Dashed"),
+        (html! { <PanelTopOpen /> }, "Panel Top Open"),
+        (html! { <PanelTop /> }, "Panel Top"),
+        (html! { <PanelsLeftBottom /> }, "Panels Left Bottom"),
+        (html! { <PanelsRightBottom /> }, "Panels Right Bottom"),
+        (html! { <PanelsTopLeft /> }, "Panels Top Left"),
+        (html! { <Paperclip /> }, "Paperclip"),
+        (html! { <Parentheses /> }, "Parentheses"),
+        (html! { <ParkingMeter /> }, "Parking Meter"),
+        (html! { <PartyPopper /> }, "Party Popper"),
+        (html! { <Pause /> }, "Pause"),
+        (html! { <PawPrint /> }, "Paw Print"),
+        (html! { <PcCase /> }, "Pc Case"),
+        (html! { <PenLine /> }, "Pen Line"),
+        (html! { <PenOff /> }, "Pen Off"),
+        (html! { <PenTool /> }, "Pen Tool"),
+        (html! { <Pen /> }, "Pen"),
+        (html! { <PencilLine /> }, "Pencil Line"),
+        (html! { <PencilOff /> }, "Pencil Off"),
+        (html! { <PencilRuler /> }, "Pencil Ruler"),
+        (html! { <Pencil /> }, "Pencil"),
+        (html! { <Pentagon /> }, "Pentagon"),
+        (html! { <Percent /> }, "Percent"),
+        (html! { <PersonStanding /> }, "Person Standing"),
+        (html! { <PhilippinePeso /> }, "Philippine Peso"),
+        (html! { <PhoneCall /> }, "Phone Call"),
+        (html! { <PhoneForwarded /> }, "Phone Forwarded"),
+        (html! { <PhoneIncoming /> }, "Phone Incoming"),
+        (html! { <PhoneMissed /> }, "Phone Missed"),
+        (html! { <PhoneOff /> }, "Phone Off"),
+        (html! { <PhoneOutgoing /> }, "Phone Outgoing"),
+        (html! { <Phone /> }, "Phone"),
+        (html! { <Pi /> }, "Pi"),
+        (html! { <Piano /> }, "Piano"),
+        (html! { <Pickaxe /> }, "Pickaxe"),
+        (html! { <PictureInPicture2 /> }, "Picture In Picture 2"),
+        (html! { <PictureInPicture /> }, "Picture In Picture"),
+        (html! { <PiggyBank /> }, "Piggy Bank"),
+        (html! { <PilcrowLeft /> }, "Pilcrow Left"),
+        (html! { <PilcrowRight /> }, "Pilcrow Right"),
+        (html! { <Pilcrow /> }, "Pilcrow"),
+        (html! { <PillBottle /> }, "Pill Bottle"),
+        (html! { <Pill /> }, "Pill"),
+        (html! { <PinOff /> }, "Pin Off"),
+        (html! { <Pin /> }, "Pin"),
+        (html! { <Pipette /> }, "Pipette"),
+        (html! { <Pizza /> }, "Pizza"),
+        (html! { <PlaneLanding /> }, "Plane Landing"),
+        (html! { <PlaneTakeoff /> }, "Plane Takeoff"),
+        (html! { <Plane /> }, "Plane"),
+        (html! { <Play /> }, "Play"),
+        (html! { <Plug2 /> }, "Plug 2"),
+        (html! { <PlugZap /> }, "Plug Zap"),
+        (html! { <Plug /> }, "Plug"),
+        (html! { <Plus /> }, "Plus"),
+        (html! { <PocketKnife /> }, "Pocket Knife"),
+        (html! { <Pocket /> }, "Pocket"),
+        (html! { <Podcast /> }, "Podcast"),
+        (html! { <PointerOff /> }, "Pointer Off"),
+        (html! { <Pointer /> }, "Pointer"),
+        (html! { <Popcorn /> }, "Popcorn"),
+        (html! { <Popsicle /> }, "Popsicle"),
+        (html! { <PoundSterling /> }, "Pound Sterling"),
+        (html! { <PowerOff /> }, "Power Off"),
+        (html! { <Power /> }, "Power"),
+        (html! { <Presentation /> }, "Presentation"),
+        (html! { <PrinterCheck /> }, "Printer Check"),
+        (html! { <Printer /> }, "Printer"),
+        (html! { <Projector /> }, "Projector"),
+        (html! { <Proportions /> }, "Proportions"),
+        (html! { <Puzzle /> }, "Puzzle"),
+        (html! { <Pyramid /> }, "Pyramid"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsQ() -> Html {
+    let icons = [
+        (html! { <QrCode /> }, "Qr Code"),
+        (html! { <Quote /> }, "Quote"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsR() -> Html {
+    let icons = [
+        (html! { <Rabbit /> }, "Rabbit"),
+        (html! { <Radar /> }, "Radar"),
+        (html! { <Radiation /> }, "Radiation"),
+        (html! { <Radical /> }, "Radical"),
+        (html! { <RadioReceiver /> }, "Radio Receiver"),
+        (html! { <RadioTower /> }, "Radio Tower"),
+        (html! { <Radio /> }, "Radio"),
+        (html! { <Radius /> }, "Radius"),
+        (html! { <RailSymbol /> }, "Rail Symbol"),
+        (html! { <Rainbow /> }, "Rainbow"),
+        (html! { <Rat /> }, "Rat"),
+        (html! { <Ratio /> }, "Ratio"),
+        (html! { <ReceiptCent /> }, "Receipt Cent"),
+        (html! { <ReceiptEuro /> }, "Receipt Euro"),
+        (html! { <ReceiptIndianRupee /> }, "Receipt Indian Rupee"),
+        (html! { <ReceiptJapaneseYen /> }, "Receipt Japanese Yen"),
+        (html! { <ReceiptPoundSterling /> }, "Receipt Pound Sterling"),
+        (html! { <ReceiptRussianRuble /> }, "Receipt Russian Ruble"),
+        (html! { <ReceiptSwissFranc /> }, "Receipt Swiss Franc"),
+        (html! { <ReceiptText /> }, "Receipt Text"),
+        (html! { <Receipt /> }, "Receipt"),
+        (html! { <RectangleEllipsis /> }, "Rectangle Ellipsis"),
+        (html! { <RectangleHorizontal /> }, "Rectangle Horizontal"),
+        (html! { <RectangleVertical /> }, "Rectangle Vertical"),
+        (html! { <Recycle /> }, "Recycle"),
+        (html! { <Redo2 /> }, "Redo 2"),
+        (html! { <RedoDot /> }, "Redo Dot"),
+        (html! { <Redo /> }, "Redo"),
+        (html! { <RefreshCcwDot /> }, "Refresh Ccw Dot"),
+        (html! { <RefreshCcw /> }, "Refresh Ccw"),
+        (html! { <RefreshCwOff /> }, "Refresh Cw Off"),
+        (html! { <RefreshCw /> }, "Refresh Cw"),
+        (html! { <Refrigerator /> }, "Refrigerator"),
+        (html! { <Regex /> }, "Regex"),
+        (html! { <RemoveFormatting /> }, "Remove Formatting"),
+        (html! { <Repeat1 /> }, "Repeat 1"),
+        (html! { <Repeat2 /> }, "Repeat 2"),
+        (html! { <Repeat /> }, "Repeat"),
+        (html! { <ReplaceAll /> }, "Replace All"),
+        (html! { <Replace /> }, "Replace"),
+        (html! { <ReplyAll /> }, "Reply All"),
+        (html! { <Reply /> }, "Reply"),
+        (html! { <Rewind /> }, "Rewind"),
+        (html! { <Ribbon /> }, "Ribbon"),
+        (html! { <Rocket /> }, "Rocket"),
+        (html! { <RockingChair /> }, "Rocking Chair"),
+        (html! { <RollerCoaster /> }, "Roller Coaster"),
+        (html! { <Rotate3D /> }, "Rotate 3 D"),
+        (html! { <RotateCcwSquare /> }, "Rotate Ccw Square"),
+        (html! { <RotateCcw /> }, "Rotate Ccw"),
+        (html! { <RotateCwSquare /> }, "Rotate Cw Square"),
+        (html! { <RotateCw /> }, "Rotate Cw"),
+        (html! { <RouteOff /> }, "Route Off"),
+        (html! { <Route /> }, "Route"),
+        (html! { <Router /> }, "Router"),
+        (html! { <Rows2 /> }, "Rows 2"),
+        (html! { <Rows3 /> }, "Rows 3"),
+        (html! { <Rows4 /> }, "Rows 4"),
+        (html! { <Rss /> }, "Rss"),
+        (html! { <Ruler /> }, "Ruler"),
+        (html! { <RussianRuble /> }, "Russian Ruble"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsS() -> Html {
+    let icons = [
+        (html! { <Sailboat /> }, "Sailboat"),
+        (html! { <Salad /> }, "Salad"),
+        (html! { <Sandwich /> }, "Sandwich"),
+        (html! { <SatelliteDish /> }, "Satellite Dish"),
+        (html! { <Satellite /> }, "Satellite"),
+        (html! { <SaveAll /> }, "Save All"),
+        (html! { <SaveOff /> }, "Save Off"),
+        (html! { <Save /> }, "Save"),
+        (html! { <Scale3D /> }, "Scale 3 D"),
+        (html! { <Scale /> }, "Scale"),
+        (html! { <Scaling /> }, "Scaling"),
+        (html! { <ScanBarcode /> }, "Scan Barcode"),
+        (html! { <ScanEye /> }, "Scan Eye"),
+        (html! { <ScanFace /> }, "Scan Face"),
+        (html! { <ScanLine /> }, "Scan Line"),
+        (html! { <ScanQrCode /> }, "Scan Qr Code"),
+        (html! { <ScanSearch /> }, "Scan Search"),
+        (html! { <ScanText /> }, "Scan Text"),
+        (html! { <Scan /> }, "Scan"),
+        (html! { <School /> }, "School"),
+        (html! { <ScissorsLineDashed /> }, "Scissors Line Dashed"),
+        (html! { <Scissors /> }, "Scissors"),
+        (html! { <ScreenShareOff /> }, "Screen Share Off"),
+        (html! { <ScreenShare /> }, "Screen Share"),
+        (html! { <ScrollText /> }, "Scroll Text"),
+        (html! { <Scroll /> }, "Scroll"),
+        (html! { <SearchCheck /> }, "Search Check"),
+        (html! { <SearchCode /> }, "Search Code"),
+        (html! { <SearchSlash /> }, "Search Slash"),
+        (html! { <SearchX /> }, "Search X"),
+        (html! { <Search /> }, "Search"),
+        (html! { <Section /> }, "Section"),
+        (html! { <SendHorizontal /> }, "Send Horizontal"),
+        (html! { <SendToBack /> }, "Send To Back"),
+        (html! { <Send /> }, "Send"),
+        (html! { <SeparatorHorizontal /> }, "Separator Horizontal"),
+        (html! { <SeparatorVertical /> }, "Separator Vertical"),
+        (html! { <ServerCog /> }, "Server Cog"),
+        (html! { <ServerCrash /> }, "Server Crash"),
+        (html! { <ServerOff /> }, "Server Off"),
+        (html! { <Server /> }, "Server"),
+        (html! { <Settings2 /> }, "Settings 2"),
+        (html! { <Settings /> }, "Settings"),
+        (html! { <Shapes /> }, "Shapes"),
+        (html! { <Share2 /> }, "Share 2"),
+        (html! { <Share /> }, "Share"),
+        (html! { <Sheet /> }, "Sheet"),
+        (html! { <Shell /> }, "Shell"),
+        (html! { <ShieldAlert /> }, "Shield Alert"),
+        (html! { <ShieldBan /> }, "Shield Ban"),
+        (html! { <ShieldCheck /> }, "Shield Check"),
+        (html! { <ShieldEllipsis /> }, "Shield Ellipsis"),
+        (html! { <ShieldHalf /> }, "Shield Half"),
+        (html! { <ShieldMinus /> }, "Shield Minus"),
+        (html! { <ShieldOff /> }, "Shield Off"),
+        (html! { <ShieldPlus /> }, "Shield Plus"),
+        (html! { <ShieldQuestion /> }, "Shield Question"),
+        (html! { <ShieldX /> }, "Shield X"),
+        (html! { <Shield /> }, "Shield"),
+        (html! { <ShipWheel /> }, "Ship Wheel"),
+        (html! { <Ship /> }, "Ship"),
+        (html! { <Shirt /> }, "Shirt"),
+        (html! { <ShoppingBag /> }, "Shopping Bag"),
+        (html! { <ShoppingBasket /> }, "Shopping Basket"),
+        (html! { <ShoppingCart /> }, "Shopping Cart"),
+        (html! { <Shovel /> }, "Shovel"),
+        (html! { <ShowerHead /> }, "Shower Head"),
+        (html! { <Shrink /> }, "Shrink"),
+        (html! { <Shrub /> }, "Shrub"),
+        (html! { <Shuffle /> }, "Shuffle"),
+        (html! { <Sigma /> }, "Sigma"),
+        (html! { <SignalHigh /> }, "Signal High"),
+        (html! { <SignalLow /> }, "Signal Low"),
+        (html! { <SignalMedium /> }, "Signal Medium"),
+        (html! { <SignalZero /> }, "Signal Zero"),
+        (html! { <Signal /> }, "Signal"),
+        (html! { <Signature /> }, "Signature"),
+        (html! { <SignpostBig /> }, "Signpost Big"),
+        (html! { <Signpost /> }, "Signpost"),
+        (html! { <Siren /> }, "Siren"),
+        (html! { <SkipBack /> }, "Skip Back"),
+        (html! { <SkipForward /> }, "Skip Forward"),
+        (html! { <Skull /> }, "Skull"),
+        (html! { <Slack /> }, "Slack"),
+        (html! { <Slash /> }, "Slash"),
+        (html! { <Slice /> }, "Slice"),
+        (html! { <SlidersHorizontal /> }, "Sliders Horizontal"),
+        (html! { <SlidersVertical /> }, "Sliders Vertical"),
+        (html! { <SmartphoneCharging /> }, "Smartphone Charging"),
+        (html! { <SmartphoneNfc /> }, "Smartphone Nfc"),
+        (html! { <Smartphone /> }, "Smartphone"),
+        (html! { <SmilePlus /> }, "Smile Plus"),
+        (html! { <Smile /> }, "Smile"),
+        (html! { <Snail /> }, "Snail"),
+        (html! { <Snowflake /> }, "Snowflake"),
+        (html! { <Sofa /> }, "Sofa"),
+        (html! { <Soup /> }, "Soup"),
+        (html! { <Space /> }, "Space"),
+        (html! { <Spade /> }, "Spade"),
+        (html! { <Sparkle /> }, "Sparkle"),
+        (html! { <Sparkles /> }, "Sparkles"),
+        (html! { <Speaker /> }, "Speaker"),
+        (html! { <Speech /> }, "Speech"),
+        (html! { <SpellCheck2 /> }, "Spell Check 2"),
+        (html! { <SpellCheck /> }, "Spell Check"),
+        (html! { <Spline /> }, "Spline"),
+        (html! { <Split /> }, "Split"),
+        (html! { <SprayCan /> }, "Spray Can"),
+        (html! { <Sprout /> }, "Sprout"),
+        (html! { <SquareActivity /> }, "Square Activity"),
+        (html! { <SquareArrowDownLeft /> }, "Square Arrow Down Left"),
+        (
+            html! { <SquareArrowDownRight /> },
+            "Square Arrow Down Right",
+        ),
+        (html! { <SquareArrowDown /> }, "Square Arrow Down"),
+        (html! { <SquareArrowLeft /> }, "Square Arrow Left"),
+        (
+            html! { <SquareArrowOutDownLeft /> },
+            "Square Arrow Out Down Left",
+        ),
+        (
+            html! { <SquareArrowOutDownRight /> },
+            "Square Arrow Out Down Right",
+        ),
+        (
+            html! { <SquareArrowOutUpLeft /> },
+            "Square Arrow Out Up Left",
+        ),
+        (
+            html! { <SquareArrowOutUpRight /> },
+            "Square Arrow Out Up Right",
+        ),
+        (html! { <SquareArrowRight /> }, "Square Arrow Right"),
+        (html! { <SquareArrowUpLeft /> }, "Square Arrow Up Left"),
+        (html! { <SquareArrowUpRight /> }, "Square Arrow Up Right"),
+        (html! { <SquareArrowUp /> }, "Square Arrow Up"),
+        (html! { <SquareAsterisk /> }, "Square Asterisk"),
+        (
+            html! { <SquareBottomDashedScissors /> },
+            "Square Bottom Dashed Scissors",
+        ),
+        (html! { <SquareChartGantt /> }, "Square Chart Gantt"),
+        (html! { <SquareCheckBig /> }, "Square Check Big"),
+        (html! { <SquareCheck /> }, "Square Check"),
+        (html! { <SquareChevronDown /> }, "Square Chevron Down"),
+        (html! { <SquareChevronLeft /> }, "Square Chevron Left"),
+        (html! { <SquareChevronRight /> }, "Square Chevron Right"),
+        (html! { <SquareChevronUp /> }, "Square Chevron Up"),
+        (html! { <SquareCode /> }, "Square Code"),
+        (
+            html! { <SquareDashedBottomCode /> },
+            "Square Dashed Bottom Code",
+        ),
+        (html! { <SquareDashedBottom /> }, "Square Dashed Bottom"),
+        (html! { <SquareDashedKanban /> }, "Square Dashed Kanban"),
+        (
+            html! { <SquareDashedMousePointer /> },
+            "Square Dashed Mouse Pointer",
+        ),
+        (html! { <SquareDashed /> }, "Square Dashed"),
+        (html! { <SquareDivide /> }, "Square Divide"),
+        (html! { <SquareDot /> }, "Square Dot"),
+        (html! { <SquareEqual /> }, "Square Equal"),
+        (html! { <SquareFunction /> }, "Square Function"),
+        (html! { <SquareKanban /> }, "Square Kanban"),
+        (html! { <SquareLibrary /> }, "Square Library"),
+        (html! { <SquareM /> }, "Square M"),
+        (html! { <SquareMenu /> }, "Square Menu"),
+        (html! { <SquareMinus /> }, "Square Minus"),
+        (html! { <SquareMousePointer /> }, "Square Mouse Pointer"),
+        (html! { <SquareParkingOff /> }, "Square Parking Off"),
+        (html! { <SquareParking /> }, "Square Parking"),
+        (html! { <SquarePen /> }, "Square Pen"),
+        (html! { <SquarePercent /> }, "Square Percent"),
+        (html! { <SquarePi /> }, "Square Pi"),
+        (html! { <SquarePilcrow /> }, "Square Pilcrow"),
+        (html! { <SquarePlay /> }, "Square Play"),
+        (html! { <SquarePlus /> }, "Square Plus"),
+        (html! { <SquarePower /> }, "Square Power"),
+        (html! { <SquareRadical /> }, "Square Radical"),
+        (html! { <SquareScissors /> }, "Square Scissors"),
+        (html! { <SquareSigma /> }, "Square Sigma"),
+        (html! { <SquareSlash /> }, "Square Slash"),
+        (
+            html! { <SquareSplitHorizontal /> },
+            "Square Split Horizontal",
+        ),
+        (html! { <SquareSplitVertical /> }, "Square Split Vertical"),
+        (html! { <SquareSquare /> }, "Square Square"),
+        (html! { <SquareStack /> }, "Square Stack"),
+        (html! { <SquareTerminal /> }, "Square Terminal"),
+        (html! { <SquareUserRound /> }, "Square User Round"),
+        (html! { <SquareUser /> }, "Square User"),
+        (html! { <SquareX /> }, "Square X"),
+        (html! { <Square /> }, "Square"),
+        (html! { <Squircle /> }, "Squircle"),
+        (html! { <Squirrel /> }, "Squirrel"),
+        (html! { <Stamp /> }, "Stamp"),
+        (html! { <StarHalf /> }, "Star Half"),
+        (html! { <StarOff /> }, "Star Off"),
+        (html! { <Star /> }, "Star"),
+        (html! { <StepBack /> }, "Step Back"),
+        (html! { <StepForward /> }, "Step Forward"),
+        (html! { <Stethoscope /> }, "Stethoscope"),
+        (html! { <Sticker /> }, "Sticker"),
+        (html! { <StickyNote /> }, "Sticky Note"),
+        (html! { <Store /> }, "Store"),
+        (html! { <StretchHorizontal /> }, "Stretch Horizontal"),
+        (html! { <StretchVertical /> }, "Stretch Vertical"),
+        (html! { <Strikethrough /> }, "Strikethrough"),
+        (html! { <Subscript /> }, "Subscript"),
+        (html! { <SunDim /> }, "Sun Dim"),
+        (html! { <SunMedium /> }, "Sun Medium"),
+        (html! { <SunMoon /> }, "Sun Moon"),
+        (html! { <SunSnow /> }, "Sun Snow"),
+        (html! { <Sun /> }, "Sun"),
+        (html! { <Sunrise /> }, "Sunrise"),
+        (html! { <Sunset /> }, "Sunset"),
+        (html! { <Superscript /> }, "Superscript"),
+        (html! { <SwatchBook /> }, "Swatch Book"),
+        (html! { <SwissFranc /> }, "Swiss Franc"),
+        (html! { <SwitchCamera /> }, "Switch Camera"),
+        (html! { <Sword /> }, "Sword"),
+        (html! { <Swords /> }, "Swords"),
+        (html! { <Syringe /> }, "Syringe"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsT() -> Html {
+    let icons = [
+        (html! { <Table2 /> }, "Table 2"),
+        (html! { <TableCellsMerge /> }, "Table Cells Merge"),
+        (html! { <TableCellsSplit /> }, "Table Cells Split"),
+        (html! { <TableColumnsSplit /> }, "Table Columns Split"),
+        (html! { <TableOfContents /> }, "Table Of Contents"),
+        (html! { <TableProperties /> }, "Table Properties"),
+        (html! { <TableRowsSplit /> }, "Table Rows Split"),
+        (html! { <Table /> }, "Table"),
+        (html! { <TabletSmartphone /> }, "Tablet Smartphone"),
+        (html! { <Tablet /> }, "Tablet"),
+        (html! { <Tablets /> }, "Tablets"),
+        (html! { <Tag /> }, "Tag"),
+        (html! { <Tags /> }, "Tags"),
+        (html! { <Tally1 /> }, "Tally 1"),
+        (html! { <Tally2 /> }, "Tally 2"),
+        (html! { <Tally3 /> }, "Tally 3"),
+        (html! { <Tally4 /> }, "Tally 4"),
+        (html! { <Tally5 /> }, "Tally 5"),
+        (html! { <Tangent /> }, "Tangent"),
+        (html! { <Target /> }, "Target"),
+        (html! { <Telescope /> }, "Telescope"),
+        (html! { <TentTree /> }, "Tent Tree"),
+        (html! { <Tent /> }, "Tent"),
+        (html! { <Terminal /> }, "Terminal"),
+        (html! { <TestTubeDiagonal /> }, "Test Tube Diagonal"),
+        (html! { <TestTube /> }, "Test Tube"),
+        (html! { <TestTubes /> }, "Test Tubes"),
+        (html! { <TextCursorInput /> }, "Text Cursor Input"),
+        (html! { <TextCursor /> }, "Text Cursor"),
+        (html! { <TextQuote /> }, "Text Quote"),
+        (html! { <TextSearch /> }, "Text Search"),
+        (html! { <TextSelect /> }, "Text Select"),
+        (html! { <Text /> }, "Text"),
+        (html! { <Theater /> }, "Theater"),
+        (html! { <ThermometerSnowflake /> }, "Thermometer Snowflake"),
+        (html! { <ThermometerSun /> }, "Thermometer Sun"),
+        (html! { <Thermometer /> }, "Thermometer"),
+        (html! { <ThumbsDown /> }, "Thumbs Down"),
+        (html! { <ThumbsUp /> }, "Thumbs Up"),
+        (html! { <TicketCheck /> }, "Ticket Check"),
+        (html! { <TicketMinus /> }, "Ticket Minus"),
+        (html! { <TicketPercent /> }, "Ticket Percent"),
+        (html! { <TicketPlus /> }, "Ticket Plus"),
+        (html! { <TicketSlash /> }, "Ticket Slash"),
+        (html! { <TicketX /> }, "Ticket X"),
+        (html! { <Ticket /> }, "Ticket"),
+        (html! { <TicketsPlane /> }, "Tickets Plane"),
+        (html! { <Tickets /> }, "Tickets"),
+        (html! { <TimerOff /> }, "Timer Off"),
+        (html! { <TimerReset /> }, "Timer Reset"),
+        (html! { <Timer /> }, "Timer"),
+        (html! { <ToggleLeft /> }, "Toggle Left"),
+        (html! { <ToggleRight /> }, "Toggle Right"),
+        (html! { <Toilet /> }, "Toilet"),
+        (html! { <Tornado /> }, "Tornado"),
+        (html! { <Torus /> }, "Torus"),
+        (html! { <TouchpadOff /> }, "Touchpad Off"),
+        (html! { <Touchpad /> }, "Touchpad"),
+        (html! { <TowerControl /> }, "Tower Control"),
+        (html! { <ToyBrick /> }, "Toy Brick"),
+        (html! { <Tractor /> }, "Tractor"),
+        (html! { <TrafficCone /> }, "Traffic Cone"),
+        (html! { <TrainFrontTunnel /> }, "Train Front Tunnel"),
+        (html! { <TrainFront /> }, "Train Front"),
+        (html! { <TrainTrack /> }, "Train Track"),
+        (html! { <TramFront /> }, "Tram Front"),
+        (html! { <Trash2 /> }, "Trash 2"),
+        (html! { <Trash /> }, "Trash"),
+        (html! { <TreeDeciduous /> }, "Tree Deciduous"),
+        (html! { <TreePalm /> }, "Tree Palm"),
+        (html! { <TreePine /> }, "Tree Pine"),
+        (html! { <Trees /> }, "Trees"),
+        (html! { <Trello /> }, "Trello"),
+        (html! { <TrendingDown /> }, "Trending Down"),
+        (html! { <TrendingUpDown /> }, "Trending Up Down"),
+        (html! { <TrendingUp /> }, "Trending Up"),
+        (html! { <TriangleAlert /> }, "Triangle Alert"),
+        (html! { <TriangleRight /> }, "Triangle Right"),
+        (html! { <Triangle /> }, "Triangle"),
+        (html! { <Trophy /> }, "Trophy"),
+        (html! { <Truck /> }, "Truck"),
+        (html! { <Turtle /> }, "Turtle"),
+        (html! { <TvMinimalPlay /> }, "Tv Minimal Play"),
+        (html! { <TvMinimal /> }, "Tv Minimal"),
+        (html! { <Tv /> }, "Tv"),
+        (html! { <Twitch /> }, "Twitch"),
+        (html! { <Twitter /> }, "Twitter"),
+        (html! { <TypeOutline /> }, "Type Outline"),
+        (html! { <Type /> }, "Type"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsU() -> Html {
+    let icons = [
+        (html! { <UmbrellaOff /> }, "Umbrella Off"),
+        (html! { <Umbrella /> }, "Umbrella"),
+        (html! { <Underline /> }, "Underline"),
+        (html! { <Undo2 /> }, "Undo 2"),
+        (html! { <UndoDot /> }, "Undo Dot"),
+        (html! { <Undo /> }, "Undo"),
+        (html! { <UnfoldHorizontal /> }, "Unfold Horizontal"),
+        (html! { <UnfoldVertical /> }, "Unfold Vertical"),
+        (html! { <Ungroup /> }, "Ungroup"),
+        (html! { <University /> }, "University"),
+        (html! { <Unlink2 /> }, "Unlink 2"),
+        (html! { <Unlink /> }, "Unlink"),
+        (html! { <Unplug /> }, "Unplug"),
+        (html! { <Upload /> }, "Upload"),
+        (html! { <Usb /> }, "Usb"),
+        (html! { <UserCheck /> }, "User Check"),
+        (html! { <UserCog /> }, "User Cog"),
+        (html! { <UserMinus /> }, "User Minus"),
+        (html! { <UserPen /> }, "User Pen"),
+        (html! { <UserPlus /> }, "User Plus"),
+        (html! { <UserRoundCheck /> }, "User Round Check"),
+        (html! { <UserRoundCog /> }, "User Round Cog"),
+        (html! { <UserRoundMinus /> }, "User Round Minus"),
+        (html! { <UserRoundPen /> }, "User Round Pen"),
+        (html! { <UserRoundPlus /> }, "User Round Plus"),
+        (html! { <UserRoundSearch /> }, "User Round Search"),
+        (html! { <UserRoundX /> }, "User Round X"),
+        (html! { <UserRound /> }, "User Round"),
+        (html! { <UserSearch /> }, "User Search"),
+        (html! { <UserX /> }, "User X"),
+        (html! { <User /> }, "User"),
+        (html! { <UsersRound /> }, "Users Round"),
+        (html! { <Users /> }, "Users"),
+        (html! { <UtensilsCrossed /> }, "Utensils Crossed"),
+        (html! { <Utensils /> }, "Utensils"),
+        (html! { <UtilityPole /> }, "Utility Pole"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsV() -> Html {
+    let icons = [
+        (html! { <Variable /> }, "Variable"),
+        (html! { <Vault /> }, "Vault"),
+        (html! { <Vegan /> }, "Vegan"),
+        (html! { <VenetianMask /> }, "Venetian Mask"),
+        (html! { <VibrateOff /> }, "Vibrate Off"),
+        (html! { <Vibrate /> }, "Vibrate"),
+        (html! { <VideoOff /> }, "Video Off"),
+        (html! { <Video /> }, "Video"),
+        (html! { <Videotape /> }, "Videotape"),
+        (html! { <View /> }, "View"),
+        (html! { <Voicemail /> }, "Voicemail"),
+        (html! { <Volleyball /> }, "Volleyball"),
+        (html! { <Volume1 /> }, "Volume 1"),
+        (html! { <Volume2 /> }, "Volume 2"),
+        (html! { <VolumeOff /> }, "Volume Off"),
+        (html! { <VolumeX /> }, "Volume X"),
+        (html! { <Volume /> }, "Volume"),
+        (html! { <Vote /> }, "Vote"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsW() -> Html {
+    let icons = [
+        (html! { <WalletCards /> }, "Wallet Cards"),
+        (html! { <WalletMinimal /> }, "Wallet Minimal"),
+        (html! { <Wallet /> }, "Wallet"),
+        (html! { <Wallpaper /> }, "Wallpaper"),
+        (html! { <WandSparkles /> }, "Wand Sparkles"),
+        (html! { <Wand /> }, "Wand"),
+        (html! { <Warehouse /> }, "Warehouse"),
+        (html! { <WashingMachine /> }, "Washing Machine"),
+        (html! { <Watch /> }, "Watch"),
+        (html! { <Waves /> }, "Waves"),
+        (html! { <Waypoints /> }, "Waypoints"),
+        (html! { <Webcam /> }, "Webcam"),
+        (html! { <WebhookOff /> }, "Webhook Off"),
+        (html! { <Webhook /> }, "Webhook"),
+        (html! { <Weight /> }, "Weight"),
+        (html! { <WheatOff /> }, "Wheat Off"),
+        (html! { <Wheat /> }, "Wheat"),
+        (html! { <WholeWord /> }, "Whole Word"),
+        (html! { <WifiHigh /> }, "Wifi High"),
+        (html! { <WifiLow /> }, "Wifi Low"),
+        (html! { <WifiOff /> }, "Wifi Off"),
+        (html! { <WifiZero /> }, "Wifi Zero"),
+        (html! { <Wifi /> }, "Wifi"),
+        (html! { <WindArrowDown /> }, "Wind Arrow Down"),
+        (html! { <Wind /> }, "Wind"),
+        (html! { <WineOff /> }, "Wine Off"),
+        (html! { <Wine /> }, "Wine"),
+        (html! { <Workflow /> }, "Workflow"),
+        (html! { <Worm /> }, "Worm"),
+        (html! { <WrapText /> }, "Wrap Text"),
+        (html! { <Wrench /> }, "Wrench"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsX() -> Html {
+    let icons = [(html! { <X /> }, "X")];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsY() -> Html {
+    let icons = [(html! { <Youtube /> }, "Youtube")];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
+}
+#[function_component]
+pub fn IconsZ() -> Html {
+    let icons = [
+        (html! { <ZapOff /> }, "Zap Off"),
+        (html! { <Zap /> }, "Zap"),
+        (html! { <ZoomIn /> }, "Zoom In"),
+        (html! { <ZoomOut /> }, "Zoom Out"),
+    ];
+    icons
+        .into_iter()
+        .map(|(icon, name)| {
+            html! {
+                <div class="flex flex-wrap items-center gap-4 text-sm">
+                    { icon }
+                    <span>{ name }</span>
+                </div>
+            }
+        })
+        .collect::<Html>()
 }
diff --git a/book/src/frameworks/dioxus.md b/book/src/frameworks/dioxus.md
index 523c6d7..6811bd8 100644
--- a/book/src/frameworks/dioxus.md
+++ b/book/src/frameworks/dioxus.md
@@ -1,8 +1,30 @@
 # Lucide Dioxus
 
+Implementation of the Lucide icon library for [Dioxus](https://dioxuslabs.com/) applications.
+
+## Installation
+
+```shell
+# Selective Icons
+cargo add lucide-dioxus --features camera,file-image,moon,sun
+
+# All Icons
+cargo add lucide-dioxus --features full
+```
+
+-   [View on crates.io](https://crates.io/crates/lucide-dioxus)
+-   [View on docs.rs](https://docs.rs/lucide-dioxus/latest/lucide_dioxus/)
+-   [View source](https://github.com/RustForWeb/lucide/tree/main/packages/dioxus)
+
+## Usage
+
 TODO
 
-## Example
+## Props
+
+TODO
+
+## Icons
 
 ```toml,trunk
 package = "lucide-dioxus-book"
diff --git a/book/src/frameworks/leptos.md b/book/src/frameworks/leptos.md
index 3c21433..f3e671a 100644
--- a/book/src/frameworks/leptos.md
+++ b/book/src/frameworks/leptos.md
@@ -1,8 +1,48 @@
 # Lucide Leptos
 
-TODO
+Implementation of the Lucide icon library for [Leptos](https://leptos.dev/) applications.
 
-## Example
+## Installation
+
+Install the icons from your command line.
+
+```shell
+# Selective Icons
+cargo add lucide-leptos --features camera,file-image,moon,sun
+
+# All Icons
+cargo add lucide-leptos --features full
+```
+
+-   [View on crates.io](https://crates.io/crates/lucide-leptos)
+-   [View on docs.rs](https://docs.rs/lucide-leptos/latest/lucide_leptos/)
+-   [View source](https://github.com/RustForWeb/lucide/tree/main/packages/leptos)
+
+## Usage
+
+```rust,ignore
+use leptos::prelude::*;
+use lucide_leptos::Camera;
+
+#[component]
+fn App() -> impl IntoView {
+    view! {
+        <Camera color="red" size=48 />
+    }
+}
+```
+
+## Props
+
+| Name                    | Type             | Default          |
+| ----------------------- | ---------------- | ---------------- |
+| `size`                  | `Signal<usize>`  | `24`             |
+| `color`                 | `Signal<String>` | `"currentColor"` |
+| `fill`                  | `Signal<String>` | `"none"`         |
+| `stroke_width`          | `Signal<usize>`  | `2`              |
+| `absolute_stroke_width` | `Signal<bool>`   | `false`          |
+
+## Icons
 
 ```toml,trunk
 package = "lucide-leptos-book"
diff --git a/book/src/frameworks/yew.md b/book/src/frameworks/yew.md
index eb0a833..0d2b698 100644
--- a/book/src/frameworks/yew.md
+++ b/book/src/frameworks/yew.md
@@ -1,8 +1,48 @@
 # Lucide Yew
 
-TODO
+Implementation of the Lucide icon library for [Yew](https://yew.rs/) applications.
 
-## Example
+## Installation
+
+Install the icons from your command line.
+
+```shell
+# Selective Icons
+cargo add lucide-yew --features camera,file-image,moon,sun
+
+# All Icons
+cargo add lucide-yew --features full
+```
+
+-   [View on crates.io](https://crates.io/crates/lucide-yew)
+-   [View on docs.rs](https://docs.rs/lucide-yew/latest/lucide_yew/)
+-   [View source](https://github.com/RustForWeb/lucide/tree/main/packages/yew)
+
+## Usage
+
+```rust,ignore
+use lucide_yew::Camera;
+use yew::prelude::*;
+
+#[component]
+fn App() -> Html {
+    html! {
+        <Camera color="red" size=48 />
+    }
+}
+```
+
+## Props
+
+| Name                    | Type     | Default          |
+| ----------------------- | -------- | ---------------- |
+| `size`                  | `usize`  | `24`             |
+| `color`                 | `String` | `"currentColor"` |
+| `fill`                  | `String` | `"none"`         |
+| `stroke_width`          | `usize`  | `2`              |
+| `absolute_stroke_width` | `bool`   | `false`          |
+
+## Icons
 
 ```toml,trunk
 package = "lucide-yew-book"
diff --git a/packages/leptos/Cargo.toml b/packages/leptos/Cargo.toml
index d24dc2b..63692a1 100644
--- a/packages/leptos/Cargo.toml
+++ b/packages/leptos/Cargo.toml
@@ -14,4 +14,3083 @@ leptos.workspace = true
 
 [features]
 default = []
-full = []
+a-arrow-down = []
+a-arrow-up = []
+a-large-small = []
+accessibility = []
+activity = []
+air-vent = []
+airplay = []
+alarm-clock-check = []
+alarm-clock-minus = []
+alarm-clock-off = []
+alarm-clock-plus = []
+alarm-clock = []
+alarm-smoke = []
+album = []
+align-center-horizontal = []
+align-center-vertical = []
+align-center = []
+align-end-horizontal = []
+align-end-vertical = []
+align-horizontal-distribute-center = []
+align-horizontal-distribute-end = []
+align-horizontal-distribute-start = []
+align-horizontal-justify-center = []
+align-horizontal-justify-end = []
+align-horizontal-justify-start = []
+align-horizontal-space-around = []
+align-horizontal-space-between = []
+align-justify = []
+align-left = []
+align-right = []
+align-start-horizontal = []
+align-start-vertical = []
+align-vertical-distribute-center = []
+align-vertical-distribute-end = []
+align-vertical-distribute-start = []
+align-vertical-justify-center = []
+align-vertical-justify-end = []
+align-vertical-justify-start = []
+align-vertical-space-around = []
+align-vertical-space-between = []
+ambulance = []
+ampersand = []
+ampersands = []
+amphora = []
+anchor = []
+angry = []
+annoyed = []
+antenna = []
+anvil = []
+aperture = []
+app-window-mac = []
+app-window = []
+apple = []
+archive-restore = []
+archive-x = []
+archive = []
+armchair = []
+arrow-big-down-dash = []
+arrow-big-down = []
+arrow-big-left-dash = []
+arrow-big-left = []
+arrow-big-right-dash = []
+arrow-big-right = []
+arrow-big-up-dash = []
+arrow-big-up = []
+arrow-down-0-1 = []
+arrow-down-1-0 = []
+arrow-down-a-z = []
+arrow-down-from-line = []
+arrow-down-left = []
+arrow-down-narrow-wide = []
+arrow-down-right = []
+arrow-down-to-dot = []
+arrow-down-to-line = []
+arrow-down-up = []
+arrow-down-wide-narrow = []
+arrow-down-z-a = []
+arrow-down = []
+arrow-left-from-line = []
+arrow-left-right = []
+arrow-left-to-line = []
+arrow-left = []
+arrow-right-from-line = []
+arrow-right-left = []
+arrow-right-to-line = []
+arrow-right = []
+arrow-up-0-1 = []
+arrow-up-1-0 = []
+arrow-up-a-z = []
+arrow-up-down = []
+arrow-up-from-dot = []
+arrow-up-from-line = []
+arrow-up-left = []
+arrow-up-narrow-wide = []
+arrow-up-right = []
+arrow-up-to-line = []
+arrow-up-wide-narrow = []
+arrow-up-z-a = []
+arrow-up = []
+arrows-up-from-line = []
+asterisk = []
+at-sign = []
+atom = []
+audio-lines = []
+audio-waveform = []
+award = []
+axe = []
+axis-3-d = []
+baby = []
+backpack = []
+badge-alert = []
+badge-cent = []
+badge-check = []
+badge-dollar-sign = []
+badge-euro = []
+badge-help = []
+badge-indian-rupee = []
+badge-info = []
+badge-japanese-yen = []
+badge-minus = []
+badge-percent = []
+badge-plus = []
+badge-pound-sterling = []
+badge-russian-ruble = []
+badge-swiss-franc = []
+badge-x = []
+badge = []
+baggage-claim = []
+ban = []
+banana = []
+bandage = []
+banknote = []
+barcode = []
+baseline = []
+bath = []
+battery-charging = []
+battery-full = []
+battery-low = []
+battery-medium = []
+battery-warning = []
+battery = []
+beaker = []
+bean-off = []
+bean = []
+bed-double = []
+bed-single = []
+bed = []
+beef = []
+beer-off = []
+beer = []
+bell-dot = []
+bell-electric = []
+bell-minus = []
+bell-off = []
+bell-plus = []
+bell-ring = []
+bell = []
+between-horizontal-end = []
+between-horizontal-start = []
+between-vertical-end = []
+between-vertical-start = []
+biceps-flexed = []
+bike = []
+binary = []
+binoculars = []
+biohazard = []
+bird = []
+bitcoin = []
+blend = []
+blinds = []
+blocks = []
+bluetooth-connected = []
+bluetooth-off = []
+bluetooth-searching = []
+bluetooth = []
+bold = []
+bolt = []
+bomb = []
+bone = []
+book-a = []
+book-audio = []
+book-check = []
+book-copy = []
+book-dashed = []
+book-down = []
+book-headphones = []
+book-heart = []
+book-image = []
+book-key = []
+book-lock = []
+book-marked = []
+book-minus = []
+book-open-check = []
+book-open-text = []
+book-open = []
+book-plus = []
+book-text = []
+book-type = []
+book-up-2 = []
+book-up = []
+book-user = []
+book-x = []
+book = []
+bookmark-check = []
+bookmark-minus = []
+bookmark-plus = []
+bookmark-x = []
+bookmark = []
+boom-box = []
+bot-message-square = []
+bot-off = []
+bot = []
+box = []
+boxes = []
+braces = []
+brackets = []
+brain-circuit = []
+brain-cog = []
+brain = []
+brick-wall = []
+briefcase-business = []
+briefcase-conveyor-belt = []
+briefcase-medical = []
+briefcase = []
+bring-to-front = []
+brush = []
+bug-off = []
+bug-play = []
+bug = []
+building-2 = []
+building = []
+bus-front = []
+bus = []
+cable-car = []
+cable = []
+cake-slice = []
+cake = []
+calculator = []
+calendar-1 = []
+calendar-arrow-down = []
+calendar-arrow-up = []
+calendar-check-2 = []
+calendar-check = []
+calendar-clock = []
+calendar-cog = []
+calendar-days = []
+calendar-fold = []
+calendar-heart = []
+calendar-minus-2 = []
+calendar-minus = []
+calendar-off = []
+calendar-plus-2 = []
+calendar-plus = []
+calendar-range = []
+calendar-search = []
+calendar-x-2 = []
+calendar-x = []
+calendar = []
+camera-off = []
+camera = []
+candy-cane = []
+candy-off = []
+candy = []
+cannabis = []
+captions-off = []
+captions = []
+car-front = []
+car-taxi-front = []
+car = []
+caravan = []
+carrot = []
+case-lower = []
+case-sensitive = []
+case-upper = []
+cassette-tape = []
+cast = []
+castle = []
+cat = []
+cctv = []
+chart-area = []
+chart-bar-big = []
+chart-bar-decreasing = []
+chart-bar-increasing = []
+chart-bar-stacked = []
+chart-bar = []
+chart-candlestick = []
+chart-column-big = []
+chart-column-decreasing = []
+chart-column-increasing = []
+chart-column-stacked = []
+chart-column = []
+chart-gantt = []
+chart-line = []
+chart-network = []
+chart-no-axes-column-decreasing = []
+chart-no-axes-column-increasing = []
+chart-no-axes-column = []
+chart-no-axes-combined = []
+chart-no-axes-gantt = []
+chart-pie = []
+chart-scatter = []
+chart-spline = []
+check-check = []
+check = []
+chef-hat = []
+cherry = []
+chevron-down = []
+chevron-first = []
+chevron-last = []
+chevron-left = []
+chevron-right = []
+chevron-up = []
+chevrons-down-up = []
+chevrons-down = []
+chevrons-left-right-ellipsis = []
+chevrons-left-right = []
+chevrons-left = []
+chevrons-right-left = []
+chevrons-right = []
+chevrons-up-down = []
+chevrons-up = []
+chrome = []
+church = []
+cigarette-off = []
+cigarette = []
+circle-alert = []
+circle-arrow-down = []
+circle-arrow-left = []
+circle-arrow-out-down-left = []
+circle-arrow-out-down-right = []
+circle-arrow-out-up-left = []
+circle-arrow-out-up-right = []
+circle-arrow-right = []
+circle-arrow-up = []
+circle-check-big = []
+circle-check = []
+circle-chevron-down = []
+circle-chevron-left = []
+circle-chevron-right = []
+circle-chevron-up = []
+circle-dashed = []
+circle-divide = []
+circle-dollar-sign = []
+circle-dot-dashed = []
+circle-dot = []
+circle-ellipsis = []
+circle-equal = []
+circle-fading-arrow-up = []
+circle-fading-plus = []
+circle-gauge = []
+circle-help = []
+circle-minus = []
+circle-off = []
+circle-parking-off = []
+circle-parking = []
+circle-pause = []
+circle-percent = []
+circle-play = []
+circle-plus = []
+circle-power = []
+circle-slash-2 = []
+circle-slash = []
+circle-stop = []
+circle-user-round = []
+circle-user = []
+circle-x = []
+circle = []
+circuit-board = []
+citrus = []
+clapperboard = []
+clipboard-check = []
+clipboard-copy = []
+clipboard-list = []
+clipboard-minus = []
+clipboard-paste = []
+clipboard-pen-line = []
+clipboard-pen = []
+clipboard-plus = []
+clipboard-type = []
+clipboard-x = []
+clipboard = []
+clock-1 = []
+clock-10 = []
+clock-11 = []
+clock-12 = []
+clock-2 = []
+clock-3 = []
+clock-4 = []
+clock-5 = []
+clock-6 = []
+clock-7 = []
+clock-8 = []
+clock-9 = []
+clock-alert = []
+clock-arrow-down = []
+clock-arrow-up = []
+clock = []
+cloud-alert = []
+cloud-cog = []
+cloud-download = []
+cloud-drizzle = []
+cloud-fog = []
+cloud-hail = []
+cloud-lightning = []
+cloud-moon-rain = []
+cloud-moon = []
+cloud-off = []
+cloud-rain-wind = []
+cloud-rain = []
+cloud-snow = []
+cloud-sun-rain = []
+cloud-sun = []
+cloud-upload = []
+cloud = []
+cloudy = []
+clover = []
+club = []
+code-xml = []
+code = []
+codepen = []
+codesandbox = []
+coffee = []
+cog = []
+coins = []
+columns-2 = []
+columns-3 = []
+columns-4 = []
+combine = []
+command = []
+compass = []
+component = []
+computer = []
+concierge-bell = []
+cone = []
+construction = []
+contact-round = []
+contact = []
+container = []
+contrast = []
+cookie = []
+cooking-pot = []
+copy-check = []
+copy-minus = []
+copy-plus = []
+copy-slash = []
+copy-x = []
+copy = []
+copyleft = []
+copyright = []
+corner-down-left = []
+corner-down-right = []
+corner-left-down = []
+corner-left-up = []
+corner-right-down = []
+corner-right-up = []
+corner-up-left = []
+corner-up-right = []
+cpu = []
+creative-commons = []
+credit-card = []
+croissant = []
+crop = []
+cross = []
+crosshair = []
+crown = []
+cuboid = []
+cup-soda = []
+currency = []
+cylinder = []
+dam = []
+database-backup = []
+database-zap = []
+database = []
+delete = []
+dessert = []
+diameter = []
+diamond-minus = []
+diamond-percent = []
+diamond-plus = []
+diamond = []
+dice-1 = []
+dice-2 = []
+dice-3 = []
+dice-4 = []
+dice-5 = []
+dice-6 = []
+dices = []
+diff = []
+disc-2 = []
+disc-3 = []
+disc-album = []
+disc = []
+divide = []
+dna-off = []
+dna = []
+dock = []
+dog = []
+dollar-sign = []
+donut = []
+door-closed = []
+door-open = []
+dot = []
+download = []
+drafting-compass = []
+drama = []
+dribbble = []
+drill = []
+droplet = []
+droplets = []
+drum = []
+drumstick = []
+dumbbell = []
+ear-off = []
+ear = []
+earth-lock = []
+earth = []
+eclipse = []
+egg-fried = []
+egg-off = []
+egg = []
+ellipsis-vertical = []
+ellipsis = []
+equal-approximately = []
+equal-not = []
+equal = []
+eraser = []
+ethernet-port = []
+euro = []
+expand = []
+external-link = []
+eye-closed = []
+eye-off = []
+eye = []
+facebook = []
+factory = []
+fan = []
+fast-forward = []
+feather = []
+fence = []
+ferris-wheel = []
+figma = []
+file-archive = []
+file-audio-2 = []
+file-audio = []
+file-axis-3-d = []
+file-badge-2 = []
+file-badge = []
+file-box = []
+file-chart-column-increasing = []
+file-chart-column = []
+file-chart-line = []
+file-chart-pie = []
+file-check-2 = []
+file-check = []
+file-clock = []
+file-code-2 = []
+file-code = []
+file-cog = []
+file-diff = []
+file-digit = []
+file-down = []
+file-heart = []
+file-image = []
+file-input = []
+file-json-2 = []
+file-json = []
+file-key-2 = []
+file-key = []
+file-lock-2 = []
+file-lock = []
+file-minus-2 = []
+file-minus = []
+file-music = []
+file-output = []
+file-pen-line = []
+file-pen = []
+file-plus-2 = []
+file-plus = []
+file-question = []
+file-scan = []
+file-search-2 = []
+file-search = []
+file-sliders = []
+file-spreadsheet = []
+file-stack = []
+file-symlink = []
+file-terminal = []
+file-text = []
+file-type-2 = []
+file-type = []
+file-up = []
+file-user = []
+file-video-2 = []
+file-video = []
+file-volume-2 = []
+file-volume = []
+file-warning = []
+file-x-2 = []
+file-x = []
+file = []
+files = []
+film = []
+filter-x = []
+filter = []
+fingerprint = []
+fire-extinguisher = []
+fish-off = []
+fish-symbol = []
+fish = []
+flag-off = []
+flag-triangle-left = []
+flag-triangle-right = []
+flag = []
+flame-kindling = []
+flame = []
+flashlight-off = []
+flashlight = []
+flask-conical-off = []
+flask-conical = []
+flask-round = []
+flip-horizontal-2 = []
+flip-horizontal = []
+flip-vertical-2 = []
+flip-vertical = []
+flower-2 = []
+flower = []
+focus = []
+fold-horizontal = []
+fold-vertical = []
+folder-archive = []
+folder-check = []
+folder-clock = []
+folder-closed = []
+folder-code = []
+folder-cog = []
+folder-dot = []
+folder-down = []
+folder-git-2 = []
+folder-git = []
+folder-heart = []
+folder-input = []
+folder-kanban = []
+folder-key = []
+folder-lock = []
+folder-minus = []
+folder-open-dot = []
+folder-open = []
+folder-output = []
+folder-pen = []
+folder-plus = []
+folder-root = []
+folder-search-2 = []
+folder-search = []
+folder-symlink = []
+folder-sync = []
+folder-tree = []
+folder-up = []
+folder-x = []
+folder = []
+folders = []
+footprints = []
+forklift = []
+forward = []
+frame = []
+framer = []
+frown = []
+fuel = []
+fullscreen = []
+gallery-horizontal-end = []
+gallery-horizontal = []
+gallery-thumbnails = []
+gallery-vertical-end = []
+gallery-vertical = []
+gamepad-2 = []
+gamepad = []
+gauge = []
+gavel = []
+gem = []
+ghost = []
+gift = []
+git-branch-plus = []
+git-branch = []
+git-commit-horizontal = []
+git-commit-vertical = []
+git-compare-arrows = []
+git-compare = []
+git-fork = []
+git-graph = []
+git-merge = []
+git-pull-request-arrow = []
+git-pull-request-closed = []
+git-pull-request-create-arrow = []
+git-pull-request-create = []
+git-pull-request-draft = []
+git-pull-request = []
+github = []
+gitlab = []
+glass-water = []
+glasses = []
+globe-lock = []
+globe = []
+goal = []
+grab = []
+graduation-cap = []
+grape = []
+grid-2-x-2-check = []
+grid-2-x-2-plus = []
+grid-2-x-2-x = []
+grid-2-x-2 = []
+grid-3-x-3 = []
+grip-horizontal = []
+grip-vertical = []
+grip = []
+group = []
+guitar = []
+ham = []
+hammer = []
+hand-coins = []
+hand-heart = []
+hand-helping = []
+hand-metal = []
+hand-platter = []
+hand = []
+handshake = []
+hard-drive-download = []
+hard-drive-upload = []
+hard-drive = []
+hard-hat = []
+hash = []
+haze = []
+hdmi-port = []
+heading-1 = []
+heading-2 = []
+heading-3 = []
+heading-4 = []
+heading-5 = []
+heading-6 = []
+heading = []
+headphone-off = []
+headphones = []
+headset = []
+heart-crack = []
+heart-handshake = []
+heart-off = []
+heart-pulse = []
+heart = []
+heater = []
+hexagon = []
+highlighter = []
+history = []
+hop-off = []
+hop = []
+hospital = []
+hotel = []
+hourglass = []
+house-plug = []
+house-plus = []
+house = []
+ice-cream-bowl = []
+ice-cream-cone = []
+id-card = []
+image-down = []
+image-minus = []
+image-off = []
+image-play = []
+image-plus = []
+image-up = []
+image = []
+images = []
+import = []
+inbox = []
+indent-decrease = []
+indent-increase = []
+indian-rupee = []
+infinity = []
+info = []
+inspection-panel = []
+instagram = []
+italic = []
+iteration-ccw = []
+iteration-cw = []
+japanese-yen = []
+joystick = []
+kanban = []
+key-round = []
+key-square = []
+key = []
+keyboard-music = []
+keyboard-off = []
+keyboard = []
+lamp-ceiling = []
+lamp-desk = []
+lamp-floor = []
+lamp-wall-down = []
+lamp-wall-up = []
+lamp = []
+land-plot = []
+landmark = []
+languages = []
+laptop-minimal-check = []
+laptop-minimal = []
+laptop = []
+lasso-select = []
+lasso = []
+laugh = []
+layers-2 = []
+layers-3 = []
+layers = []
+layout-dashboard = []
+layout-grid = []
+layout-list = []
+layout-panel-left = []
+layout-panel-top = []
+layout-template = []
+leaf = []
+leafy-green = []
+lectern = []
+letter-text = []
+library-big = []
+library = []
+life-buoy = []
+ligature = []
+lightbulb-off = []
+lightbulb = []
+link-2-off = []
+link-2 = []
+link = []
+linkedin = []
+list-check = []
+list-checks = []
+list-collapse = []
+list-end = []
+list-filter = []
+list-minus = []
+list-music = []
+list-ordered = []
+list-plus = []
+list-restart = []
+list-start = []
+list-todo = []
+list-tree = []
+list-video = []
+list-x = []
+list = []
+loader-circle = []
+loader-pinwheel = []
+loader = []
+locate-fixed = []
+locate-off = []
+locate = []
+lock-keyhole-open = []
+lock-keyhole = []
+lock-open = []
+lock = []
+log-in = []
+log-out = []
+logs = []
+lollipop = []
+luggage = []
+magnet = []
+mail-check = []
+mail-minus = []
+mail-open = []
+mail-plus = []
+mail-question = []
+mail-search = []
+mail-warning = []
+mail-x = []
+mail = []
+mailbox = []
+mails = []
+map-pin-check-inside = []
+map-pin-check = []
+map-pin-house = []
+map-pin-minus-inside = []
+map-pin-minus = []
+map-pin-off = []
+map-pin-plus-inside = []
+map-pin-plus = []
+map-pin-x-inside = []
+map-pin-x = []
+map-pin = []
+map-pinned = []
+map = []
+martini = []
+maximize-2 = []
+maximize = []
+medal = []
+megaphone-off = []
+megaphone = []
+meh = []
+memory-stick = []
+menu = []
+merge = []
+message-circle-code = []
+message-circle-dashed = []
+message-circle-heart = []
+message-circle-more = []
+message-circle-off = []
+message-circle-plus = []
+message-circle-question = []
+message-circle-reply = []
+message-circle-warning = []
+message-circle-x = []
+message-circle = []
+message-square-code = []
+message-square-dashed = []
+message-square-diff = []
+message-square-dot = []
+message-square-heart = []
+message-square-lock = []
+message-square-more = []
+message-square-off = []
+message-square-plus = []
+message-square-quote = []
+message-square-reply = []
+message-square-share = []
+message-square-text = []
+message-square-warning = []
+message-square-x = []
+message-square = []
+messages-square = []
+mic-off = []
+mic-vocal = []
+mic = []
+microchip = []
+microscope = []
+microwave = []
+milestone = []
+milk-off = []
+milk = []
+minimize-2 = []
+minimize = []
+minus = []
+monitor-check = []
+monitor-cog = []
+monitor-dot = []
+monitor-down = []
+monitor-off = []
+monitor-pause = []
+monitor-play = []
+monitor-smartphone = []
+monitor-speaker = []
+monitor-stop = []
+monitor-up = []
+monitor-x = []
+monitor = []
+moon-star = []
+moon = []
+mountain-snow = []
+mountain = []
+mouse-off = []
+mouse-pointer-2 = []
+mouse-pointer-ban = []
+mouse-pointer-click = []
+mouse-pointer = []
+mouse = []
+move-3-d = []
+move-diagonal-2 = []
+move-diagonal = []
+move-down-left = []
+move-down-right = []
+move-down = []
+move-horizontal = []
+move-left = []
+move-right = []
+move-up-left = []
+move-up-right = []
+move-up = []
+move-vertical = []
+move = []
+music-2 = []
+music-3 = []
+music-4 = []
+music = []
+navigation-2-off = []
+navigation-2 = []
+navigation-off = []
+navigation = []
+network = []
+newspaper = []
+nfc = []
+notebook-pen = []
+notebook-tabs = []
+notebook-text = []
+notebook = []
+notepad-text-dashed = []
+notepad-text = []
+nut-off = []
+nut = []
+octagon-alert = []
+octagon-minus = []
+octagon-pause = []
+octagon-x = []
+octagon = []
+omega = []
+option = []
+orbit = []
+origami = []
+package-2 = []
+package-check = []
+package-minus = []
+package-open = []
+package-plus = []
+package-search = []
+package-x = []
+package = []
+paint-bucket = []
+paint-roller = []
+paintbrush-vertical = []
+paintbrush = []
+palette = []
+panel-bottom-close = []
+panel-bottom-dashed = []
+panel-bottom-open = []
+panel-bottom = []
+panel-left-close = []
+panel-left-dashed = []
+panel-left-open = []
+panel-left = []
+panel-right-close = []
+panel-right-dashed = []
+panel-right-open = []
+panel-right = []
+panel-top-close = []
+panel-top-dashed = []
+panel-top-open = []
+panel-top = []
+panels-left-bottom = []
+panels-right-bottom = []
+panels-top-left = []
+paperclip = []
+parentheses = []
+parking-meter = []
+party-popper = []
+pause = []
+paw-print = []
+pc-case = []
+pen-line = []
+pen-off = []
+pen-tool = []
+pen = []
+pencil-line = []
+pencil-off = []
+pencil-ruler = []
+pencil = []
+pentagon = []
+percent = []
+person-standing = []
+philippine-peso = []
+phone-call = []
+phone-forwarded = []
+phone-incoming = []
+phone-missed = []
+phone-off = []
+phone-outgoing = []
+phone = []
+pi = []
+piano = []
+pickaxe = []
+picture-in-picture-2 = []
+picture-in-picture = []
+piggy-bank = []
+pilcrow-left = []
+pilcrow-right = []
+pilcrow = []
+pill-bottle = []
+pill = []
+pin-off = []
+pin = []
+pipette = []
+pizza = []
+plane-landing = []
+plane-takeoff = []
+plane = []
+play = []
+plug-2 = []
+plug-zap = []
+plug = []
+plus = []
+pocket-knife = []
+pocket = []
+podcast = []
+pointer-off = []
+pointer = []
+popcorn = []
+popsicle = []
+pound-sterling = []
+power-off = []
+power = []
+presentation = []
+printer-check = []
+printer = []
+projector = []
+proportions = []
+puzzle = []
+pyramid = []
+qr-code = []
+quote = []
+rabbit = []
+radar = []
+radiation = []
+radical = []
+radio-receiver = []
+radio-tower = []
+radio = []
+radius = []
+rail-symbol = []
+rainbow = []
+rat = []
+ratio = []
+receipt-cent = []
+receipt-euro = []
+receipt-indian-rupee = []
+receipt-japanese-yen = []
+receipt-pound-sterling = []
+receipt-russian-ruble = []
+receipt-swiss-franc = []
+receipt-text = []
+receipt = []
+rectangle-ellipsis = []
+rectangle-horizontal = []
+rectangle-vertical = []
+recycle = []
+redo-2 = []
+redo-dot = []
+redo = []
+refresh-ccw-dot = []
+refresh-ccw = []
+refresh-cw-off = []
+refresh-cw = []
+refrigerator = []
+regex = []
+remove-formatting = []
+repeat-1 = []
+repeat-2 = []
+repeat = []
+replace-all = []
+replace = []
+reply-all = []
+reply = []
+rewind = []
+ribbon = []
+rocket = []
+rocking-chair = []
+roller-coaster = []
+rotate-3-d = []
+rotate-ccw-square = []
+rotate-ccw = []
+rotate-cw-square = []
+rotate-cw = []
+route-off = []
+route = []
+router = []
+rows-2 = []
+rows-3 = []
+rows-4 = []
+rss = []
+ruler = []
+russian-ruble = []
+sailboat = []
+salad = []
+sandwich = []
+satellite-dish = []
+satellite = []
+save-all = []
+save-off = []
+save = []
+scale-3-d = []
+scale = []
+scaling = []
+scan-barcode = []
+scan-eye = []
+scan-face = []
+scan-line = []
+scan-qr-code = []
+scan-search = []
+scan-text = []
+scan = []
+school = []
+scissors-line-dashed = []
+scissors = []
+screen-share-off = []
+screen-share = []
+scroll-text = []
+scroll = []
+search-check = []
+search-code = []
+search-slash = []
+search-x = []
+search = []
+section = []
+send-horizontal = []
+send-to-back = []
+send = []
+separator-horizontal = []
+separator-vertical = []
+server-cog = []
+server-crash = []
+server-off = []
+server = []
+settings-2 = []
+settings = []
+shapes = []
+share-2 = []
+share = []
+sheet = []
+shell = []
+shield-alert = []
+shield-ban = []
+shield-check = []
+shield-ellipsis = []
+shield-half = []
+shield-minus = []
+shield-off = []
+shield-plus = []
+shield-question = []
+shield-x = []
+shield = []
+ship-wheel = []
+ship = []
+shirt = []
+shopping-bag = []
+shopping-basket = []
+shopping-cart = []
+shovel = []
+shower-head = []
+shrink = []
+shrub = []
+shuffle = []
+sigma = []
+signal-high = []
+signal-low = []
+signal-medium = []
+signal-zero = []
+signal = []
+signature = []
+signpost-big = []
+signpost = []
+siren = []
+skip-back = []
+skip-forward = []
+skull = []
+slack = []
+slash = []
+slice = []
+sliders-horizontal = []
+sliders-vertical = []
+smartphone-charging = []
+smartphone-nfc = []
+smartphone = []
+smile-plus = []
+smile = []
+snail = []
+snowflake = []
+sofa = []
+soup = []
+space = []
+spade = []
+sparkle = []
+sparkles = []
+speaker = []
+speech = []
+spell-check-2 = []
+spell-check = []
+spline = []
+split = []
+spray-can = []
+sprout = []
+square-activity = []
+square-arrow-down-left = []
+square-arrow-down-right = []
+square-arrow-down = []
+square-arrow-left = []
+square-arrow-out-down-left = []
+square-arrow-out-down-right = []
+square-arrow-out-up-left = []
+square-arrow-out-up-right = []
+square-arrow-right = []
+square-arrow-up-left = []
+square-arrow-up-right = []
+square-arrow-up = []
+square-asterisk = []
+square-bottom-dashed-scissors = []
+square-chart-gantt = []
+square-check-big = []
+square-check = []
+square-chevron-down = []
+square-chevron-left = []
+square-chevron-right = []
+square-chevron-up = []
+square-code = []
+square-dashed-bottom-code = []
+square-dashed-bottom = []
+square-dashed-kanban = []
+square-dashed-mouse-pointer = []
+square-dashed = []
+square-divide = []
+square-dot = []
+square-equal = []
+square-function = []
+square-kanban = []
+square-library = []
+square-m = []
+square-menu = []
+square-minus = []
+square-mouse-pointer = []
+square-parking-off = []
+square-parking = []
+square-pen = []
+square-percent = []
+square-pi = []
+square-pilcrow = []
+square-play = []
+square-plus = []
+square-power = []
+square-radical = []
+square-scissors = []
+square-sigma = []
+square-slash = []
+square-split-horizontal = []
+square-split-vertical = []
+square-square = []
+square-stack = []
+square-terminal = []
+square-user-round = []
+square-user = []
+square-x = []
+square = []
+squircle = []
+squirrel = []
+stamp = []
+star-half = []
+star-off = []
+star = []
+step-back = []
+step-forward = []
+stethoscope = []
+sticker = []
+sticky-note = []
+store = []
+stretch-horizontal = []
+stretch-vertical = []
+strikethrough = []
+subscript = []
+sun-dim = []
+sun-medium = []
+sun-moon = []
+sun-snow = []
+sun = []
+sunrise = []
+sunset = []
+superscript = []
+swatch-book = []
+swiss-franc = []
+switch-camera = []
+sword = []
+swords = []
+syringe = []
+table-2 = []
+table-cells-merge = []
+table-cells-split = []
+table-columns-split = []
+table-of-contents = []
+table-properties = []
+table-rows-split = []
+table = []
+tablet-smartphone = []
+tablet = []
+tablets = []
+tag = []
+tags = []
+tally-1 = []
+tally-2 = []
+tally-3 = []
+tally-4 = []
+tally-5 = []
+tangent = []
+target = []
+telescope = []
+tent-tree = []
+tent = []
+terminal = []
+test-tube-diagonal = []
+test-tube = []
+test-tubes = []
+text-cursor-input = []
+text-cursor = []
+text-quote = []
+text-search = []
+text-select = []
+text = []
+theater = []
+thermometer-snowflake = []
+thermometer-sun = []
+thermometer = []
+thumbs-down = []
+thumbs-up = []
+ticket-check = []
+ticket-minus = []
+ticket-percent = []
+ticket-plus = []
+ticket-slash = []
+ticket-x = []
+ticket = []
+tickets-plane = []
+tickets = []
+timer-off = []
+timer-reset = []
+timer = []
+toggle-left = []
+toggle-right = []
+toilet = []
+tornado = []
+torus = []
+touchpad-off = []
+touchpad = []
+tower-control = []
+toy-brick = []
+tractor = []
+traffic-cone = []
+train-front-tunnel = []
+train-front = []
+train-track = []
+tram-front = []
+trash-2 = []
+trash = []
+tree-deciduous = []
+tree-palm = []
+tree-pine = []
+trees = []
+trello = []
+trending-down = []
+trending-up-down = []
+trending-up = []
+triangle-alert = []
+triangle-right = []
+triangle = []
+trophy = []
+truck = []
+turtle = []
+tv-minimal-play = []
+tv-minimal = []
+tv = []
+twitch = []
+twitter = []
+type-outline = []
+type = []
+umbrella-off = []
+umbrella = []
+underline = []
+undo-2 = []
+undo-dot = []
+undo = []
+unfold-horizontal = []
+unfold-vertical = []
+ungroup = []
+university = []
+unlink-2 = []
+unlink = []
+unplug = []
+upload = []
+usb = []
+user-check = []
+user-cog = []
+user-minus = []
+user-pen = []
+user-plus = []
+user-round-check = []
+user-round-cog = []
+user-round-minus = []
+user-round-pen = []
+user-round-plus = []
+user-round-search = []
+user-round-x = []
+user-round = []
+user-search = []
+user-x = []
+user = []
+users-round = []
+users = []
+utensils-crossed = []
+utensils = []
+utility-pole = []
+variable = []
+vault = []
+vegan = []
+venetian-mask = []
+vibrate-off = []
+vibrate = []
+video-off = []
+video = []
+videotape = []
+view = []
+voicemail = []
+volleyball = []
+volume-1 = []
+volume-2 = []
+volume-off = []
+volume-x = []
+volume = []
+vote = []
+wallet-cards = []
+wallet-minimal = []
+wallet = []
+wallpaper = []
+wand-sparkles = []
+wand = []
+warehouse = []
+washing-machine = []
+watch = []
+waves = []
+waypoints = []
+webcam = []
+webhook-off = []
+webhook = []
+weight = []
+wheat-off = []
+wheat = []
+whole-word = []
+wifi-high = []
+wifi-low = []
+wifi-off = []
+wifi-zero = []
+wifi = []
+wind-arrow-down = []
+wind = []
+wine-off = []
+wine = []
+workflow = []
+worm = []
+wrap-text = []
+wrench = []
+x = []
+youtube = []
+zap-off = []
+zap = []
+zoom-in = []
+zoom-out = []
+full = [
+    "a-arrow-down",
+    "a-arrow-up",
+    "a-large-small",
+    "accessibility",
+    "activity",
+    "air-vent",
+    "airplay",
+    "alarm-clock-check",
+    "alarm-clock-minus",
+    "alarm-clock-off",
+    "alarm-clock-plus",
+    "alarm-clock",
+    "alarm-smoke",
+    "album",
+    "align-center-horizontal",
+    "align-center-vertical",
+    "align-center",
+    "align-end-horizontal",
+    "align-end-vertical",
+    "align-horizontal-distribute-center",
+    "align-horizontal-distribute-end",
+    "align-horizontal-distribute-start",
+    "align-horizontal-justify-center",
+    "align-horizontal-justify-end",
+    "align-horizontal-justify-start",
+    "align-horizontal-space-around",
+    "align-horizontal-space-between",
+    "align-justify",
+    "align-left",
+    "align-right",
+    "align-start-horizontal",
+    "align-start-vertical",
+    "align-vertical-distribute-center",
+    "align-vertical-distribute-end",
+    "align-vertical-distribute-start",
+    "align-vertical-justify-center",
+    "align-vertical-justify-end",
+    "align-vertical-justify-start",
+    "align-vertical-space-around",
+    "align-vertical-space-between",
+    "ambulance",
+    "ampersand",
+    "ampersands",
+    "amphora",
+    "anchor",
+    "angry",
+    "annoyed",
+    "antenna",
+    "anvil",
+    "aperture",
+    "app-window-mac",
+    "app-window",
+    "apple",
+    "archive-restore",
+    "archive-x",
+    "archive",
+    "armchair",
+    "arrow-big-down-dash",
+    "arrow-big-down",
+    "arrow-big-left-dash",
+    "arrow-big-left",
+    "arrow-big-right-dash",
+    "arrow-big-right",
+    "arrow-big-up-dash",
+    "arrow-big-up",
+    "arrow-down-0-1",
+    "arrow-down-1-0",
+    "arrow-down-a-z",
+    "arrow-down-from-line",
+    "arrow-down-left",
+    "arrow-down-narrow-wide",
+    "arrow-down-right",
+    "arrow-down-to-dot",
+    "arrow-down-to-line",
+    "arrow-down-up",
+    "arrow-down-wide-narrow",
+    "arrow-down-z-a",
+    "arrow-down",
+    "arrow-left-from-line",
+    "arrow-left-right",
+    "arrow-left-to-line",
+    "arrow-left",
+    "arrow-right-from-line",
+    "arrow-right-left",
+    "arrow-right-to-line",
+    "arrow-right",
+    "arrow-up-0-1",
+    "arrow-up-1-0",
+    "arrow-up-a-z",
+    "arrow-up-down",
+    "arrow-up-from-dot",
+    "arrow-up-from-line",
+    "arrow-up-left",
+    "arrow-up-narrow-wide",
+    "arrow-up-right",
+    "arrow-up-to-line",
+    "arrow-up-wide-narrow",
+    "arrow-up-z-a",
+    "arrow-up",
+    "arrows-up-from-line",
+    "asterisk",
+    "at-sign",
+    "atom",
+    "audio-lines",
+    "audio-waveform",
+    "award",
+    "axe",
+    "axis-3-d",
+    "baby",
+    "backpack",
+    "badge-alert",
+    "badge-cent",
+    "badge-check",
+    "badge-dollar-sign",
+    "badge-euro",
+    "badge-help",
+    "badge-indian-rupee",
+    "badge-info",
+    "badge-japanese-yen",
+    "badge-minus",
+    "badge-percent",
+    "badge-plus",
+    "badge-pound-sterling",
+    "badge-russian-ruble",
+    "badge-swiss-franc",
+    "badge-x",
+    "badge",
+    "baggage-claim",
+    "ban",
+    "banana",
+    "bandage",
+    "banknote",
+    "barcode",
+    "baseline",
+    "bath",
+    "battery-charging",
+    "battery-full",
+    "battery-low",
+    "battery-medium",
+    "battery-warning",
+    "battery",
+    "beaker",
+    "bean-off",
+    "bean",
+    "bed-double",
+    "bed-single",
+    "bed",
+    "beef",
+    "beer-off",
+    "beer",
+    "bell-dot",
+    "bell-electric",
+    "bell-minus",
+    "bell-off",
+    "bell-plus",
+    "bell-ring",
+    "bell",
+    "between-horizontal-end",
+    "between-horizontal-start",
+    "between-vertical-end",
+    "between-vertical-start",
+    "biceps-flexed",
+    "bike",
+    "binary",
+    "binoculars",
+    "biohazard",
+    "bird",
+    "bitcoin",
+    "blend",
+    "blinds",
+    "blocks",
+    "bluetooth-connected",
+    "bluetooth-off",
+    "bluetooth-searching",
+    "bluetooth",
+    "bold",
+    "bolt",
+    "bomb",
+    "bone",
+    "book-a",
+    "book-audio",
+    "book-check",
+    "book-copy",
+    "book-dashed",
+    "book-down",
+    "book-headphones",
+    "book-heart",
+    "book-image",
+    "book-key",
+    "book-lock",
+    "book-marked",
+    "book-minus",
+    "book-open-check",
+    "book-open-text",
+    "book-open",
+    "book-plus",
+    "book-text",
+    "book-type",
+    "book-up-2",
+    "book-up",
+    "book-user",
+    "book-x",
+    "book",
+    "bookmark-check",
+    "bookmark-minus",
+    "bookmark-plus",
+    "bookmark-x",
+    "bookmark",
+    "boom-box",
+    "bot-message-square",
+    "bot-off",
+    "bot",
+    "box",
+    "boxes",
+    "braces",
+    "brackets",
+    "brain-circuit",
+    "brain-cog",
+    "brain",
+    "brick-wall",
+    "briefcase-business",
+    "briefcase-conveyor-belt",
+    "briefcase-medical",
+    "briefcase",
+    "bring-to-front",
+    "brush",
+    "bug-off",
+    "bug-play",
+    "bug",
+    "building-2",
+    "building",
+    "bus-front",
+    "bus",
+    "cable-car",
+    "cable",
+    "cake-slice",
+    "cake",
+    "calculator",
+    "calendar-1",
+    "calendar-arrow-down",
+    "calendar-arrow-up",
+    "calendar-check-2",
+    "calendar-check",
+    "calendar-clock",
+    "calendar-cog",
+    "calendar-days",
+    "calendar-fold",
+    "calendar-heart",
+    "calendar-minus-2",
+    "calendar-minus",
+    "calendar-off",
+    "calendar-plus-2",
+    "calendar-plus",
+    "calendar-range",
+    "calendar-search",
+    "calendar-x-2",
+    "calendar-x",
+    "calendar",
+    "camera-off",
+    "camera",
+    "candy-cane",
+    "candy-off",
+    "candy",
+    "cannabis",
+    "captions-off",
+    "captions",
+    "car-front",
+    "car-taxi-front",
+    "car",
+    "caravan",
+    "carrot",
+    "case-lower",
+    "case-sensitive",
+    "case-upper",
+    "cassette-tape",
+    "cast",
+    "castle",
+    "cat",
+    "cctv",
+    "chart-area",
+    "chart-bar-big",
+    "chart-bar-decreasing",
+    "chart-bar-increasing",
+    "chart-bar-stacked",
+    "chart-bar",
+    "chart-candlestick",
+    "chart-column-big",
+    "chart-column-decreasing",
+    "chart-column-increasing",
+    "chart-column-stacked",
+    "chart-column",
+    "chart-gantt",
+    "chart-line",
+    "chart-network",
+    "chart-no-axes-column-decreasing",
+    "chart-no-axes-column-increasing",
+    "chart-no-axes-column",
+    "chart-no-axes-combined",
+    "chart-no-axes-gantt",
+    "chart-pie",
+    "chart-scatter",
+    "chart-spline",
+    "check-check",
+    "check",
+    "chef-hat",
+    "cherry",
+    "chevron-down",
+    "chevron-first",
+    "chevron-last",
+    "chevron-left",
+    "chevron-right",
+    "chevron-up",
+    "chevrons-down-up",
+    "chevrons-down",
+    "chevrons-left-right-ellipsis",
+    "chevrons-left-right",
+    "chevrons-left",
+    "chevrons-right-left",
+    "chevrons-right",
+    "chevrons-up-down",
+    "chevrons-up",
+    "chrome",
+    "church",
+    "cigarette-off",
+    "cigarette",
+    "circle-alert",
+    "circle-arrow-down",
+    "circle-arrow-left",
+    "circle-arrow-out-down-left",
+    "circle-arrow-out-down-right",
+    "circle-arrow-out-up-left",
+    "circle-arrow-out-up-right",
+    "circle-arrow-right",
+    "circle-arrow-up",
+    "circle-check-big",
+    "circle-check",
+    "circle-chevron-down",
+    "circle-chevron-left",
+    "circle-chevron-right",
+    "circle-chevron-up",
+    "circle-dashed",
+    "circle-divide",
+    "circle-dollar-sign",
+    "circle-dot-dashed",
+    "circle-dot",
+    "circle-ellipsis",
+    "circle-equal",
+    "circle-fading-arrow-up",
+    "circle-fading-plus",
+    "circle-gauge",
+    "circle-help",
+    "circle-minus",
+    "circle-off",
+    "circle-parking-off",
+    "circle-parking",
+    "circle-pause",
+    "circle-percent",
+    "circle-play",
+    "circle-plus",
+    "circle-power",
+    "circle-slash-2",
+    "circle-slash",
+    "circle-stop",
+    "circle-user-round",
+    "circle-user",
+    "circle-x",
+    "circle",
+    "circuit-board",
+    "citrus",
+    "clapperboard",
+    "clipboard-check",
+    "clipboard-copy",
+    "clipboard-list",
+    "clipboard-minus",
+    "clipboard-paste",
+    "clipboard-pen-line",
+    "clipboard-pen",
+    "clipboard-plus",
+    "clipboard-type",
+    "clipboard-x",
+    "clipboard",
+    "clock-1",
+    "clock-10",
+    "clock-11",
+    "clock-12",
+    "clock-2",
+    "clock-3",
+    "clock-4",
+    "clock-5",
+    "clock-6",
+    "clock-7",
+    "clock-8",
+    "clock-9",
+    "clock-alert",
+    "clock-arrow-down",
+    "clock-arrow-up",
+    "clock",
+    "cloud-alert",
+    "cloud-cog",
+    "cloud-download",
+    "cloud-drizzle",
+    "cloud-fog",
+    "cloud-hail",
+    "cloud-lightning",
+    "cloud-moon-rain",
+    "cloud-moon",
+    "cloud-off",
+    "cloud-rain-wind",
+    "cloud-rain",
+    "cloud-snow",
+    "cloud-sun-rain",
+    "cloud-sun",
+    "cloud-upload",
+    "cloud",
+    "cloudy",
+    "clover",
+    "club",
+    "code-xml",
+    "code",
+    "codepen",
+    "codesandbox",
+    "coffee",
+    "cog",
+    "coins",
+    "columns-2",
+    "columns-3",
+    "columns-4",
+    "combine",
+    "command",
+    "compass",
+    "component",
+    "computer",
+    "concierge-bell",
+    "cone",
+    "construction",
+    "contact-round",
+    "contact",
+    "container",
+    "contrast",
+    "cookie",
+    "cooking-pot",
+    "copy-check",
+    "copy-minus",
+    "copy-plus",
+    "copy-slash",
+    "copy-x",
+    "copy",
+    "copyleft",
+    "copyright",
+    "corner-down-left",
+    "corner-down-right",
+    "corner-left-down",
+    "corner-left-up",
+    "corner-right-down",
+    "corner-right-up",
+    "corner-up-left",
+    "corner-up-right",
+    "cpu",
+    "creative-commons",
+    "credit-card",
+    "croissant",
+    "crop",
+    "cross",
+    "crosshair",
+    "crown",
+    "cuboid",
+    "cup-soda",
+    "currency",
+    "cylinder",
+    "dam",
+    "database-backup",
+    "database-zap",
+    "database",
+    "delete",
+    "dessert",
+    "diameter",
+    "diamond-minus",
+    "diamond-percent",
+    "diamond-plus",
+    "diamond",
+    "dice-1",
+    "dice-2",
+    "dice-3",
+    "dice-4",
+    "dice-5",
+    "dice-6",
+    "dices",
+    "diff",
+    "disc-2",
+    "disc-3",
+    "disc-album",
+    "disc",
+    "divide",
+    "dna-off",
+    "dna",
+    "dock",
+    "dog",
+    "dollar-sign",
+    "donut",
+    "door-closed",
+    "door-open",
+    "dot",
+    "download",
+    "drafting-compass",
+    "drama",
+    "dribbble",
+    "drill",
+    "droplet",
+    "droplets",
+    "drum",
+    "drumstick",
+    "dumbbell",
+    "ear-off",
+    "ear",
+    "earth-lock",
+    "earth",
+    "eclipse",
+    "egg-fried",
+    "egg-off",
+    "egg",
+    "ellipsis-vertical",
+    "ellipsis",
+    "equal-approximately",
+    "equal-not",
+    "equal",
+    "eraser",
+    "ethernet-port",
+    "euro",
+    "expand",
+    "external-link",
+    "eye-closed",
+    "eye-off",
+    "eye",
+    "facebook",
+    "factory",
+    "fan",
+    "fast-forward",
+    "feather",
+    "fence",
+    "ferris-wheel",
+    "figma",
+    "file-archive",
+    "file-audio-2",
+    "file-audio",
+    "file-axis-3-d",
+    "file-badge-2",
+    "file-badge",
+    "file-box",
+    "file-chart-column-increasing",
+    "file-chart-column",
+    "file-chart-line",
+    "file-chart-pie",
+    "file-check-2",
+    "file-check",
+    "file-clock",
+    "file-code-2",
+    "file-code",
+    "file-cog",
+    "file-diff",
+    "file-digit",
+    "file-down",
+    "file-heart",
+    "file-image",
+    "file-input",
+    "file-json-2",
+    "file-json",
+    "file-key-2",
+    "file-key",
+    "file-lock-2",
+    "file-lock",
+    "file-minus-2",
+    "file-minus",
+    "file-music",
+    "file-output",
+    "file-pen-line",
+    "file-pen",
+    "file-plus-2",
+    "file-plus",
+    "file-question",
+    "file-scan",
+    "file-search-2",
+    "file-search",
+    "file-sliders",
+    "file-spreadsheet",
+    "file-stack",
+    "file-symlink",
+    "file-terminal",
+    "file-text",
+    "file-type-2",
+    "file-type",
+    "file-up",
+    "file-user",
+    "file-video-2",
+    "file-video",
+    "file-volume-2",
+    "file-volume",
+    "file-warning",
+    "file-x-2",
+    "file-x",
+    "file",
+    "files",
+    "film",
+    "filter-x",
+    "filter",
+    "fingerprint",
+    "fire-extinguisher",
+    "fish-off",
+    "fish-symbol",
+    "fish",
+    "flag-off",
+    "flag-triangle-left",
+    "flag-triangle-right",
+    "flag",
+    "flame-kindling",
+    "flame",
+    "flashlight-off",
+    "flashlight",
+    "flask-conical-off",
+    "flask-conical",
+    "flask-round",
+    "flip-horizontal-2",
+    "flip-horizontal",
+    "flip-vertical-2",
+    "flip-vertical",
+    "flower-2",
+    "flower",
+    "focus",
+    "fold-horizontal",
+    "fold-vertical",
+    "folder-archive",
+    "folder-check",
+    "folder-clock",
+    "folder-closed",
+    "folder-code",
+    "folder-cog",
+    "folder-dot",
+    "folder-down",
+    "folder-git-2",
+    "folder-git",
+    "folder-heart",
+    "folder-input",
+    "folder-kanban",
+    "folder-key",
+    "folder-lock",
+    "folder-minus",
+    "folder-open-dot",
+    "folder-open",
+    "folder-output",
+    "folder-pen",
+    "folder-plus",
+    "folder-root",
+    "folder-search-2",
+    "folder-search",
+    "folder-symlink",
+    "folder-sync",
+    "folder-tree",
+    "folder-up",
+    "folder-x",
+    "folder",
+    "folders",
+    "footprints",
+    "forklift",
+    "forward",
+    "frame",
+    "framer",
+    "frown",
+    "fuel",
+    "fullscreen",
+    "gallery-horizontal-end",
+    "gallery-horizontal",
+    "gallery-thumbnails",
+    "gallery-vertical-end",
+    "gallery-vertical",
+    "gamepad-2",
+    "gamepad",
+    "gauge",
+    "gavel",
+    "gem",
+    "ghost",
+    "gift",
+    "git-branch-plus",
+    "git-branch",
+    "git-commit-horizontal",
+    "git-commit-vertical",
+    "git-compare-arrows",
+    "git-compare",
+    "git-fork",
+    "git-graph",
+    "git-merge",
+    "git-pull-request-arrow",
+    "git-pull-request-closed",
+    "git-pull-request-create-arrow",
+    "git-pull-request-create",
+    "git-pull-request-draft",
+    "git-pull-request",
+    "github",
+    "gitlab",
+    "glass-water",
+    "glasses",
+    "globe-lock",
+    "globe",
+    "goal",
+    "grab",
+    "graduation-cap",
+    "grape",
+    "grid-2-x-2-check",
+    "grid-2-x-2-plus",
+    "grid-2-x-2-x",
+    "grid-2-x-2",
+    "grid-3-x-3",
+    "grip-horizontal",
+    "grip-vertical",
+    "grip",
+    "group",
+    "guitar",
+    "ham",
+    "hammer",
+    "hand-coins",
+    "hand-heart",
+    "hand-helping",
+    "hand-metal",
+    "hand-platter",
+    "hand",
+    "handshake",
+    "hard-drive-download",
+    "hard-drive-upload",
+    "hard-drive",
+    "hard-hat",
+    "hash",
+    "haze",
+    "hdmi-port",
+    "heading-1",
+    "heading-2",
+    "heading-3",
+    "heading-4",
+    "heading-5",
+    "heading-6",
+    "heading",
+    "headphone-off",
+    "headphones",
+    "headset",
+    "heart-crack",
+    "heart-handshake",
+    "heart-off",
+    "heart-pulse",
+    "heart",
+    "heater",
+    "hexagon",
+    "highlighter",
+    "history",
+    "hop-off",
+    "hop",
+    "hospital",
+    "hotel",
+    "hourglass",
+    "house-plug",
+    "house-plus",
+    "house",
+    "ice-cream-bowl",
+    "ice-cream-cone",
+    "id-card",
+    "image-down",
+    "image-minus",
+    "image-off",
+    "image-play",
+    "image-plus",
+    "image-up",
+    "image",
+    "images",
+    "import",
+    "inbox",
+    "indent-decrease",
+    "indent-increase",
+    "indian-rupee",
+    "infinity",
+    "info",
+    "inspection-panel",
+    "instagram",
+    "italic",
+    "iteration-ccw",
+    "iteration-cw",
+    "japanese-yen",
+    "joystick",
+    "kanban",
+    "key-round",
+    "key-square",
+    "key",
+    "keyboard-music",
+    "keyboard-off",
+    "keyboard",
+    "lamp-ceiling",
+    "lamp-desk",
+    "lamp-floor",
+    "lamp-wall-down",
+    "lamp-wall-up",
+    "lamp",
+    "land-plot",
+    "landmark",
+    "languages",
+    "laptop-minimal-check",
+    "laptop-minimal",
+    "laptop",
+    "lasso-select",
+    "lasso",
+    "laugh",
+    "layers-2",
+    "layers-3",
+    "layers",
+    "layout-dashboard",
+    "layout-grid",
+    "layout-list",
+    "layout-panel-left",
+    "layout-panel-top",
+    "layout-template",
+    "leaf",
+    "leafy-green",
+    "lectern",
+    "letter-text",
+    "library-big",
+    "library",
+    "life-buoy",
+    "ligature",
+    "lightbulb-off",
+    "lightbulb",
+    "link-2-off",
+    "link-2",
+    "link",
+    "linkedin",
+    "list-check",
+    "list-checks",
+    "list-collapse",
+    "list-end",
+    "list-filter",
+    "list-minus",
+    "list-music",
+    "list-ordered",
+    "list-plus",
+    "list-restart",
+    "list-start",
+    "list-todo",
+    "list-tree",
+    "list-video",
+    "list-x",
+    "list",
+    "loader-circle",
+    "loader-pinwheel",
+    "loader",
+    "locate-fixed",
+    "locate-off",
+    "locate",
+    "lock-keyhole-open",
+    "lock-keyhole",
+    "lock-open",
+    "lock",
+    "log-in",
+    "log-out",
+    "logs",
+    "lollipop",
+    "luggage",
+    "magnet",
+    "mail-check",
+    "mail-minus",
+    "mail-open",
+    "mail-plus",
+    "mail-question",
+    "mail-search",
+    "mail-warning",
+    "mail-x",
+    "mail",
+    "mailbox",
+    "mails",
+    "map-pin-check-inside",
+    "map-pin-check",
+    "map-pin-house",
+    "map-pin-minus-inside",
+    "map-pin-minus",
+    "map-pin-off",
+    "map-pin-plus-inside",
+    "map-pin-plus",
+    "map-pin-x-inside",
+    "map-pin-x",
+    "map-pin",
+    "map-pinned",
+    "map",
+    "martini",
+    "maximize-2",
+    "maximize",
+    "medal",
+    "megaphone-off",
+    "megaphone",
+    "meh",
+    "memory-stick",
+    "menu",
+    "merge",
+    "message-circle-code",
+    "message-circle-dashed",
+    "message-circle-heart",
+    "message-circle-more",
+    "message-circle-off",
+    "message-circle-plus",
+    "message-circle-question",
+    "message-circle-reply",
+    "message-circle-warning",
+    "message-circle-x",
+    "message-circle",
+    "message-square-code",
+    "message-square-dashed",
+    "message-square-diff",
+    "message-square-dot",
+    "message-square-heart",
+    "message-square-lock",
+    "message-square-more",
+    "message-square-off",
+    "message-square-plus",
+    "message-square-quote",
+    "message-square-reply",
+    "message-square-share",
+    "message-square-text",
+    "message-square-warning",
+    "message-square-x",
+    "message-square",
+    "messages-square",
+    "mic-off",
+    "mic-vocal",
+    "mic",
+    "microchip",
+    "microscope",
+    "microwave",
+    "milestone",
+    "milk-off",
+    "milk",
+    "minimize-2",
+    "minimize",
+    "minus",
+    "monitor-check",
+    "monitor-cog",
+    "monitor-dot",
+    "monitor-down",
+    "monitor-off",
+    "monitor-pause",
+    "monitor-play",
+    "monitor-smartphone",
+    "monitor-speaker",
+    "monitor-stop",
+    "monitor-up",
+    "monitor-x",
+    "monitor",
+    "moon-star",
+    "moon",
+    "mountain-snow",
+    "mountain",
+    "mouse-off",
+    "mouse-pointer-2",
+    "mouse-pointer-ban",
+    "mouse-pointer-click",
+    "mouse-pointer",
+    "mouse",
+    "move-3-d",
+    "move-diagonal-2",
+    "move-diagonal",
+    "move-down-left",
+    "move-down-right",
+    "move-down",
+    "move-horizontal",
+    "move-left",
+    "move-right",
+    "move-up-left",
+    "move-up-right",
+    "move-up",
+    "move-vertical",
+    "move",
+    "music-2",
+    "music-3",
+    "music-4",
+    "music",
+    "navigation-2-off",
+    "navigation-2",
+    "navigation-off",
+    "navigation",
+    "network",
+    "newspaper",
+    "nfc",
+    "notebook-pen",
+    "notebook-tabs",
+    "notebook-text",
+    "notebook",
+    "notepad-text-dashed",
+    "notepad-text",
+    "nut-off",
+    "nut",
+    "octagon-alert",
+    "octagon-minus",
+    "octagon-pause",
+    "octagon-x",
+    "octagon",
+    "omega",
+    "option",
+    "orbit",
+    "origami",
+    "package-2",
+    "package-check",
+    "package-minus",
+    "package-open",
+    "package-plus",
+    "package-search",
+    "package-x",
+    "package",
+    "paint-bucket",
+    "paint-roller",
+    "paintbrush-vertical",
+    "paintbrush",
+    "palette",
+    "panel-bottom-close",
+    "panel-bottom-dashed",
+    "panel-bottom-open",
+    "panel-bottom",
+    "panel-left-close",
+    "panel-left-dashed",
+    "panel-left-open",
+    "panel-left",
+    "panel-right-close",
+    "panel-right-dashed",
+    "panel-right-open",
+    "panel-right",
+    "panel-top-close",
+    "panel-top-dashed",
+    "panel-top-open",
+    "panel-top",
+    "panels-left-bottom",
+    "panels-right-bottom",
+    "panels-top-left",
+    "paperclip",
+    "parentheses",
+    "parking-meter",
+    "party-popper",
+    "pause",
+    "paw-print",
+    "pc-case",
+    "pen-line",
+    "pen-off",
+    "pen-tool",
+    "pen",
+    "pencil-line",
+    "pencil-off",
+    "pencil-ruler",
+    "pencil",
+    "pentagon",
+    "percent",
+    "person-standing",
+    "philippine-peso",
+    "phone-call",
+    "phone-forwarded",
+    "phone-incoming",
+    "phone-missed",
+    "phone-off",
+    "phone-outgoing",
+    "phone",
+    "pi",
+    "piano",
+    "pickaxe",
+    "picture-in-picture-2",
+    "picture-in-picture",
+    "piggy-bank",
+    "pilcrow-left",
+    "pilcrow-right",
+    "pilcrow",
+    "pill-bottle",
+    "pill",
+    "pin-off",
+    "pin",
+    "pipette",
+    "pizza",
+    "plane-landing",
+    "plane-takeoff",
+    "plane",
+    "play",
+    "plug-2",
+    "plug-zap",
+    "plug",
+    "plus",
+    "pocket-knife",
+    "pocket",
+    "podcast",
+    "pointer-off",
+    "pointer",
+    "popcorn",
+    "popsicle",
+    "pound-sterling",
+    "power-off",
+    "power",
+    "presentation",
+    "printer-check",
+    "printer",
+    "projector",
+    "proportions",
+    "puzzle",
+    "pyramid",
+    "qr-code",
+    "quote",
+    "rabbit",
+    "radar",
+    "radiation",
+    "radical",
+    "radio-receiver",
+    "radio-tower",
+    "radio",
+    "radius",
+    "rail-symbol",
+    "rainbow",
+    "rat",
+    "ratio",
+    "receipt-cent",
+    "receipt-euro",
+    "receipt-indian-rupee",
+    "receipt-japanese-yen",
+    "receipt-pound-sterling",
+    "receipt-russian-ruble",
+    "receipt-swiss-franc",
+    "receipt-text",
+    "receipt",
+    "rectangle-ellipsis",
+    "rectangle-horizontal",
+    "rectangle-vertical",
+    "recycle",
+    "redo-2",
+    "redo-dot",
+    "redo",
+    "refresh-ccw-dot",
+    "refresh-ccw",
+    "refresh-cw-off",
+    "refresh-cw",
+    "refrigerator",
+    "regex",
+    "remove-formatting",
+    "repeat-1",
+    "repeat-2",
+    "repeat",
+    "replace-all",
+    "replace",
+    "reply-all",
+    "reply",
+    "rewind",
+    "ribbon",
+    "rocket",
+    "rocking-chair",
+    "roller-coaster",
+    "rotate-3-d",
+    "rotate-ccw-square",
+    "rotate-ccw",
+    "rotate-cw-square",
+    "rotate-cw",
+    "route-off",
+    "route",
+    "router",
+    "rows-2",
+    "rows-3",
+    "rows-4",
+    "rss",
+    "ruler",
+    "russian-ruble",
+    "sailboat",
+    "salad",
+    "sandwich",
+    "satellite-dish",
+    "satellite",
+    "save-all",
+    "save-off",
+    "save",
+    "scale-3-d",
+    "scale",
+    "scaling",
+    "scan-barcode",
+    "scan-eye",
+    "scan-face",
+    "scan-line",
+    "scan-qr-code",
+    "scan-search",
+    "scan-text",
+    "scan",
+    "school",
+    "scissors-line-dashed",
+    "scissors",
+    "screen-share-off",
+    "screen-share",
+    "scroll-text",
+    "scroll",
+    "search-check",
+    "search-code",
+    "search-slash",
+    "search-x",
+    "search",
+    "section",
+    "send-horizontal",
+    "send-to-back",
+    "send",
+    "separator-horizontal",
+    "separator-vertical",
+    "server-cog",
+    "server-crash",
+    "server-off",
+    "server",
+    "settings-2",
+    "settings",
+    "shapes",
+    "share-2",
+    "share",
+    "sheet",
+    "shell",
+    "shield-alert",
+    "shield-ban",
+    "shield-check",
+    "shield-ellipsis",
+    "shield-half",
+    "shield-minus",
+    "shield-off",
+    "shield-plus",
+    "shield-question",
+    "shield-x",
+    "shield",
+    "ship-wheel",
+    "ship",
+    "shirt",
+    "shopping-bag",
+    "shopping-basket",
+    "shopping-cart",
+    "shovel",
+    "shower-head",
+    "shrink",
+    "shrub",
+    "shuffle",
+    "sigma",
+    "signal-high",
+    "signal-low",
+    "signal-medium",
+    "signal-zero",
+    "signal",
+    "signature",
+    "signpost-big",
+    "signpost",
+    "siren",
+    "skip-back",
+    "skip-forward",
+    "skull",
+    "slack",
+    "slash",
+    "slice",
+    "sliders-horizontal",
+    "sliders-vertical",
+    "smartphone-charging",
+    "smartphone-nfc",
+    "smartphone",
+    "smile-plus",
+    "smile",
+    "snail",
+    "snowflake",
+    "sofa",
+    "soup",
+    "space",
+    "spade",
+    "sparkle",
+    "sparkles",
+    "speaker",
+    "speech",
+    "spell-check-2",
+    "spell-check",
+    "spline",
+    "split",
+    "spray-can",
+    "sprout",
+    "square-activity",
+    "square-arrow-down-left",
+    "square-arrow-down-right",
+    "square-arrow-down",
+    "square-arrow-left",
+    "square-arrow-out-down-left",
+    "square-arrow-out-down-right",
+    "square-arrow-out-up-left",
+    "square-arrow-out-up-right",
+    "square-arrow-right",
+    "square-arrow-up-left",
+    "square-arrow-up-right",
+    "square-arrow-up",
+    "square-asterisk",
+    "square-bottom-dashed-scissors",
+    "square-chart-gantt",
+    "square-check-big",
+    "square-check",
+    "square-chevron-down",
+    "square-chevron-left",
+    "square-chevron-right",
+    "square-chevron-up",
+    "square-code",
+    "square-dashed-bottom-code",
+    "square-dashed-bottom",
+    "square-dashed-kanban",
+    "square-dashed-mouse-pointer",
+    "square-dashed",
+    "square-divide",
+    "square-dot",
+    "square-equal",
+    "square-function",
+    "square-kanban",
+    "square-library",
+    "square-m",
+    "square-menu",
+    "square-minus",
+    "square-mouse-pointer",
+    "square-parking-off",
+    "square-parking",
+    "square-pen",
+    "square-percent",
+    "square-pi",
+    "square-pilcrow",
+    "square-play",
+    "square-plus",
+    "square-power",
+    "square-radical",
+    "square-scissors",
+    "square-sigma",
+    "square-slash",
+    "square-split-horizontal",
+    "square-split-vertical",
+    "square-square",
+    "square-stack",
+    "square-terminal",
+    "square-user-round",
+    "square-user",
+    "square-x",
+    "square",
+    "squircle",
+    "squirrel",
+    "stamp",
+    "star-half",
+    "star-off",
+    "star",
+    "step-back",
+    "step-forward",
+    "stethoscope",
+    "sticker",
+    "sticky-note",
+    "store",
+    "stretch-horizontal",
+    "stretch-vertical",
+    "strikethrough",
+    "subscript",
+    "sun-dim",
+    "sun-medium",
+    "sun-moon",
+    "sun-snow",
+    "sun",
+    "sunrise",
+    "sunset",
+    "superscript",
+    "swatch-book",
+    "swiss-franc",
+    "switch-camera",
+    "sword",
+    "swords",
+    "syringe",
+    "table-2",
+    "table-cells-merge",
+    "table-cells-split",
+    "table-columns-split",
+    "table-of-contents",
+    "table-properties",
+    "table-rows-split",
+    "table",
+    "tablet-smartphone",
+    "tablet",
+    "tablets",
+    "tag",
+    "tags",
+    "tally-1",
+    "tally-2",
+    "tally-3",
+    "tally-4",
+    "tally-5",
+    "tangent",
+    "target",
+    "telescope",
+    "tent-tree",
+    "tent",
+    "terminal",
+    "test-tube-diagonal",
+    "test-tube",
+    "test-tubes",
+    "text-cursor-input",
+    "text-cursor",
+    "text-quote",
+    "text-search",
+    "text-select",
+    "text",
+    "theater",
+    "thermometer-snowflake",
+    "thermometer-sun",
+    "thermometer",
+    "thumbs-down",
+    "thumbs-up",
+    "ticket-check",
+    "ticket-minus",
+    "ticket-percent",
+    "ticket-plus",
+    "ticket-slash",
+    "ticket-x",
+    "ticket",
+    "tickets-plane",
+    "tickets",
+    "timer-off",
+    "timer-reset",
+    "timer",
+    "toggle-left",
+    "toggle-right",
+    "toilet",
+    "tornado",
+    "torus",
+    "touchpad-off",
+    "touchpad",
+    "tower-control",
+    "toy-brick",
+    "tractor",
+    "traffic-cone",
+    "train-front-tunnel",
+    "train-front",
+    "train-track",
+    "tram-front",
+    "trash-2",
+    "trash",
+    "tree-deciduous",
+    "tree-palm",
+    "tree-pine",
+    "trees",
+    "trello",
+    "trending-down",
+    "trending-up-down",
+    "trending-up",
+    "triangle-alert",
+    "triangle-right",
+    "triangle",
+    "trophy",
+    "truck",
+    "turtle",
+    "tv-minimal-play",
+    "tv-minimal",
+    "tv",
+    "twitch",
+    "twitter",
+    "type-outline",
+    "type",
+    "umbrella-off",
+    "umbrella",
+    "underline",
+    "undo-2",
+    "undo-dot",
+    "undo",
+    "unfold-horizontal",
+    "unfold-vertical",
+    "ungroup",
+    "university",
+    "unlink-2",
+    "unlink",
+    "unplug",
+    "upload",
+    "usb",
+    "user-check",
+    "user-cog",
+    "user-minus",
+    "user-pen",
+    "user-plus",
+    "user-round-check",
+    "user-round-cog",
+    "user-round-minus",
+    "user-round-pen",
+    "user-round-plus",
+    "user-round-search",
+    "user-round-x",
+    "user-round",
+    "user-search",
+    "user-x",
+    "user",
+    "users-round",
+    "users",
+    "utensils-crossed",
+    "utensils",
+    "utility-pole",
+    "variable",
+    "vault",
+    "vegan",
+    "venetian-mask",
+    "vibrate-off",
+    "vibrate",
+    "video-off",
+    "video",
+    "videotape",
+    "view",
+    "voicemail",
+    "volleyball",
+    "volume-1",
+    "volume-2",
+    "volume-off",
+    "volume-x",
+    "volume",
+    "vote",
+    "wallet-cards",
+    "wallet-minimal",
+    "wallet",
+    "wallpaper",
+    "wand-sparkles",
+    "wand",
+    "warehouse",
+    "washing-machine",
+    "watch",
+    "waves",
+    "waypoints",
+    "webcam",
+    "webhook-off",
+    "webhook",
+    "weight",
+    "wheat-off",
+    "wheat",
+    "whole-word",
+    "wifi-high",
+    "wifi-low",
+    "wifi-off",
+    "wifi-zero",
+    "wifi",
+    "wind-arrow-down",
+    "wind",
+    "wine-off",
+    "wine",
+    "workflow",
+    "worm",
+    "wrap-text",
+    "wrench",
+    "x",
+    "youtube",
+    "zap-off",
+    "zap",
+    "zoom-in",
+    "zoom-out",
+]
diff --git a/packages/leptos/src/a_arrow_down.rs b/packages/leptos/src/a_arrow_down.rs
new file mode 100644
index 0000000..ee0a5ac
--- /dev/null
+++ b/packages/leptos/src/a_arrow_down.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AArrowDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.5 13h6"></path>
+            <path d="m2 16 4.5-9 4.5 9"></path>
+            <path d="M18 7v9"></path>
+            <path d="m14 12 4 4 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/a_arrow_up.rs b/packages/leptos/src/a_arrow_up.rs
new file mode 100644
index 0000000..13e3fd3
--- /dev/null
+++ b/packages/leptos/src/a_arrow_up.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AArrowUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.5 13h6"></path>
+            <path d="m2 16 4.5-9 4.5 9"></path>
+            <path d="M18 16V7"></path>
+            <path d="m14 11 4-4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/a_large_small.rs b/packages/leptos/src/a_large_small.rs
new file mode 100644
index 0000000..509823d
--- /dev/null
+++ b/packages/leptos/src/a_large_small.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ALargeSmall(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 14h-5"></path>
+            <path d="M16 16v-3.5a2.5 2.5 0 0 1 5 0V16"></path>
+            <path d="M4.5 13h6"></path>
+            <path d="m3 16 4.5-9 4.5 9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/accessibility.rs b/packages/leptos/src/accessibility.rs
new file mode 100644
index 0000000..577560a
--- /dev/null
+++ b/packages/leptos/src/accessibility.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Accessibility(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="16" cy="4" r="1"></circle>
+            <path d="m18 19 1-7-6 1"></path>
+            <path d="m5 8 3-3 5.5 3-2.36 3.5"></path>
+            <path d="M4.24 14.5a5 5 0 0 0 6.88 6"></path>
+            <path d="M13.76 17.5a5 5 0 0 0-6.88-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/activity.rs b/packages/leptos/src/activity.rs
new file mode 100644
index 0000000..6e6c8fd
--- /dev/null
+++ b/packages/leptos/src/activity.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Activity(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12h-2.48a2 2 0 0 0-1.93 1.46l-2.35 8.36a.25.25 0 0 1-.48 0L9.24 2.18a.25.25 0 0 0-.48 0l-2.35 8.36A2 2 0 0 1 4.49 12H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/air_vent.rs b/packages/leptos/src/air_vent.rs
new file mode 100644
index 0000000..5f80175
--- /dev/null
+++ b/packages/leptos/src/air_vent.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AirVent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 12H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"></path>
+            <path d="M6 8h12"></path>
+            <path d="M18.3 17.7a2.5 2.5 0 0 1-3.16 3.83 2.53 2.53 0 0 1-1.14-2V12"></path>
+            <path d="M6.6 15.6A2 2 0 1 0 10 17v-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/airplay.rs b/packages/leptos/src/airplay.rs
new file mode 100644
index 0000000..8cc2013
--- /dev/null
+++ b/packages/leptos/src/airplay.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Airplay(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1"></path>
+            <path d="m12 15 5 6H7Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/alarm_clock.rs b/packages/leptos/src/alarm_clock.rs
new file mode 100644
index 0000000..775bdcf
--- /dev/null
+++ b/packages/leptos/src/alarm_clock.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlarmClock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="8"></circle>
+            <path d="M12 9v4l2 2"></path>
+            <path d="M5 3 2 6"></path>
+            <path d="m22 6-3-3"></path>
+            <path d="M6.38 18.7 4 21"></path>
+            <path d="M17.64 18.67 20 21"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/alarm_clock_check.rs b/packages/leptos/src/alarm_clock_check.rs
new file mode 100644
index 0000000..5f0ba32
--- /dev/null
+++ b/packages/leptos/src/alarm_clock_check.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlarmClockCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="8"></circle>
+            <path d="M5 3 2 6"></path>
+            <path d="m22 6-3-3"></path>
+            <path d="M6.38 18.7 4 21"></path>
+            <path d="M17.64 18.67 20 21"></path>
+            <path d="m9 13 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/alarm_clock_minus.rs b/packages/leptos/src/alarm_clock_minus.rs
new file mode 100644
index 0000000..385537c
--- /dev/null
+++ b/packages/leptos/src/alarm_clock_minus.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlarmClockMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="8"></circle>
+            <path d="M5 3 2 6"></path>
+            <path d="m22 6-3-3"></path>
+            <path d="M6.38 18.7 4 21"></path>
+            <path d="M17.64 18.67 20 21"></path>
+            <path d="M9 13h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/alarm_clock_off.rs b/packages/leptos/src/alarm_clock_off.rs
new file mode 100644
index 0000000..77bea88
--- /dev/null
+++ b/packages/leptos/src/alarm_clock_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlarmClockOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6.87 6.87a8 8 0 1 0 11.26 11.26"></path>
+            <path d="M19.9 14.25a8 8 0 0 0-9.15-9.15"></path>
+            <path d="m22 6-3-3"></path>
+            <path d="M6.26 18.67 4 21"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M4 4 2 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/alarm_clock_plus.rs b/packages/leptos/src/alarm_clock_plus.rs
new file mode 100644
index 0000000..bb6fc6c
--- /dev/null
+++ b/packages/leptos/src/alarm_clock_plus.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlarmClockPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="8"></circle>
+            <path d="M5 3 2 6"></path>
+            <path d="m22 6-3-3"></path>
+            <path d="M6.38 18.7 4 21"></path>
+            <path d="M17.64 18.67 20 21"></path>
+            <path d="M12 10v6"></path>
+            <path d="M9 13h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/alarm_smoke.rs b/packages/leptos/src/alarm_smoke.rs
new file mode 100644
index 0000000..682278d
--- /dev/null
+++ b/packages/leptos/src/alarm_smoke.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlarmSmoke(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 21c0-2.5 2-2.5 2-5"></path>
+            <path d="M16 21c0-2.5 2-2.5 2-5"></path>
+            <path d="m19 8-.8 3a1.25 1.25 0 0 1-1.2 1H7a1.25 1.25 0 0 1-1.2-1L5 8"></path>
+            <path d="M21 3a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V4a1 1 0 0 1 1-1z"></path>
+            <path d="M6 21c0-2.5 2-2.5 2-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/album.rs b/packages/leptos/src/album.rs
new file mode 100644
index 0000000..55df385
--- /dev/null
+++ b/packages/leptos/src/album.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Album(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <polyline points="11 3 11 11 14 8 17 11 17 3"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_center.rs b/packages/leptos/src/align_center.rs
new file mode 100644
index 0000000..9389bc0
--- /dev/null
+++ b/packages/leptos/src/align_center.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignCenter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 12H7"></path>
+            <path d="M19 18H5"></path>
+            <path d="M21 6H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_center_horizontal.rs b/packages/leptos/src/align_center_horizontal.rs
new file mode 100644
index 0000000..1ecd1b4
--- /dev/null
+++ b/packages/leptos/src/align_center_horizontal.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignCenterHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12h20"></path>
+            <path d="M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4"></path>
+            <path d="M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1"></path>
+            <path d="M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_center_vertical.rs b/packages/leptos/src/align_center_vertical.rs
new file mode 100644
index 0000000..0455bee
--- /dev/null
+++ b/packages/leptos/src/align_center_vertical.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignCenterVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v20"></path>
+            <path d="M8 10H4a2 2 0 0 1-2-2V6c0-1.1.9-2 2-2h4"></path>
+            <path d="M16 10h4a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-4"></path>
+            <path d="M8 20H7a2 2 0 0 1-2-2v-2c0-1.1.9-2 2-2h1"></path>
+            <path d="M16 14h1a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2h-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_end_horizontal.rs b/packages/leptos/src/align_end_horizontal.rs
new file mode 100644
index 0000000..4f08ea9
--- /dev/null
+++ b/packages/leptos/src/align_end_horizontal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignEndHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="16" x="4" y="2" rx="2"></rect>
+            <rect width="6" height="9" x="14" y="9" rx="2"></rect>
+            <path d="M22 22H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_end_vertical.rs b/packages/leptos/src/align_end_vertical.rs
new file mode 100644
index 0000000..b9d5c47
--- /dev/null
+++ b/packages/leptos/src/align_end_vertical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignEndVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="6" x="2" y="4" rx="2"></rect>
+            <rect width="9" height="6" x="9" y="14" rx="2"></rect>
+            <path d="M22 22V2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_horizontal_distribute_center.rs b/packages/leptos/src/align_horizontal_distribute_center.rs
new file mode 100644
index 0000000..d6c76e8
--- /dev/null
+++ b/packages/leptos/src/align_horizontal_distribute_center.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignHorizontalDistributeCenter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="4" y="5" rx="2"></rect>
+            <rect width="6" height="10" x="14" y="7" rx="2"></rect>
+            <path d="M17 22v-5"></path>
+            <path d="M17 7V2"></path>
+            <path d="M7 22v-3"></path>
+            <path d="M7 5V2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_horizontal_distribute_end.rs b/packages/leptos/src/align_horizontal_distribute_end.rs
new file mode 100644
index 0000000..3e30863
--- /dev/null
+++ b/packages/leptos/src/align_horizontal_distribute_end.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignHorizontalDistributeEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="4" y="5" rx="2"></rect>
+            <rect width="6" height="10" x="14" y="7" rx="2"></rect>
+            <path d="M10 2v20"></path>
+            <path d="M20 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_horizontal_distribute_start.rs b/packages/leptos/src/align_horizontal_distribute_start.rs
new file mode 100644
index 0000000..3219328
--- /dev/null
+++ b/packages/leptos/src/align_horizontal_distribute_start.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignHorizontalDistributeStart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="4" y="5" rx="2"></rect>
+            <rect width="6" height="10" x="14" y="7" rx="2"></rect>
+            <path d="M4 2v20"></path>
+            <path d="M14 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_horizontal_justify_center.rs b/packages/leptos/src/align_horizontal_justify_center.rs
new file mode 100644
index 0000000..186604e
--- /dev/null
+++ b/packages/leptos/src/align_horizontal_justify_center.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignHorizontalJustifyCenter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="2" y="5" rx="2"></rect>
+            <rect width="6" height="10" x="16" y="7" rx="2"></rect>
+            <path d="M12 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_horizontal_justify_end.rs b/packages/leptos/src/align_horizontal_justify_end.rs
new file mode 100644
index 0000000..f1d7ff1
--- /dev/null
+++ b/packages/leptos/src/align_horizontal_justify_end.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignHorizontalJustifyEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="2" y="5" rx="2"></rect>
+            <rect width="6" height="10" x="12" y="7" rx="2"></rect>
+            <path d="M22 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_horizontal_justify_start.rs b/packages/leptos/src/align_horizontal_justify_start.rs
new file mode 100644
index 0000000..7e91f7d
--- /dev/null
+++ b/packages/leptos/src/align_horizontal_justify_start.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignHorizontalJustifyStart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="6" y="5" rx="2"></rect>
+            <rect width="6" height="10" x="16" y="7" rx="2"></rect>
+            <path d="M2 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_horizontal_space_around.rs b/packages/leptos/src/align_horizontal_space_around.rs
new file mode 100644
index 0000000..8cbc895
--- /dev/null
+++ b/packages/leptos/src/align_horizontal_space_around.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignHorizontalSpaceAround(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="10" x="9" y="7" rx="2"></rect>
+            <path d="M4 22V2"></path>
+            <path d="M20 22V2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_horizontal_space_between.rs b/packages/leptos/src/align_horizontal_space_between.rs
new file mode 100644
index 0000000..e26f871
--- /dev/null
+++ b/packages/leptos/src/align_horizontal_space_between.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignHorizontalSpaceBetween(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="3" y="5" rx="2"></rect>
+            <rect width="6" height="10" x="15" y="7" rx="2"></rect>
+            <path d="M3 2v20"></path>
+            <path d="M21 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_justify.rs b/packages/leptos/src/align_justify.rs
new file mode 100644
index 0000000..ab1153b
--- /dev/null
+++ b/packages/leptos/src/align_justify.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignJustify(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12h18"></path>
+            <path d="M3 18h18"></path>
+            <path d="M3 6h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_left.rs b/packages/leptos/src/align_left.rs
new file mode 100644
index 0000000..4ee357e
--- /dev/null
+++ b/packages/leptos/src/align_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 12H3"></path>
+            <path d="M17 18H3"></path>
+            <path d="M21 6H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_right.rs b/packages/leptos/src/align_right.rs
new file mode 100644
index 0000000..94b3d69
--- /dev/null
+++ b/packages/leptos/src/align_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12H9"></path>
+            <path d="M21 18H7"></path>
+            <path d="M21 6H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_start_horizontal.rs b/packages/leptos/src/align_start_horizontal.rs
new file mode 100644
index 0000000..126b101
--- /dev/null
+++ b/packages/leptos/src/align_start_horizontal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignStartHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="16" x="4" y="6" rx="2"></rect>
+            <rect width="6" height="9" x="14" y="6" rx="2"></rect>
+            <path d="M22 2H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_start_vertical.rs b/packages/leptos/src/align_start_vertical.rs
new file mode 100644
index 0000000..6f6cd90
--- /dev/null
+++ b/packages/leptos/src/align_start_vertical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignStartVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="9" height="6" x="6" y="14" rx="2"></rect>
+            <rect width="16" height="6" x="6" y="4" rx="2"></rect>
+            <path d="M2 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_vertical_distribute_center.rs b/packages/leptos/src/align_vertical_distribute_center.rs
new file mode 100644
index 0000000..e711faa
--- /dev/null
+++ b/packages/leptos/src/align_vertical_distribute_center.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignVerticalDistributeCenter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 17h-3"></path>
+            <path d="M22 7h-5"></path>
+            <path d="M5 17H2"></path>
+            <path d="M7 7H2"></path>
+            <rect x="5" y="14" width="14" height="6" rx="2"></rect>
+            <rect x="7" y="4" width="10" height="6" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_vertical_distribute_end.rs b/packages/leptos/src/align_vertical_distribute_end.rs
new file mode 100644
index 0000000..13b3b69
--- /dev/null
+++ b/packages/leptos/src/align_vertical_distribute_end.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignVerticalDistributeEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="14" rx="2"></rect>
+            <rect width="10" height="6" x="7" y="4" rx="2"></rect>
+            <path d="M2 20h20"></path>
+            <path d="M2 10h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_vertical_distribute_start.rs b/packages/leptos/src/align_vertical_distribute_start.rs
new file mode 100644
index 0000000..c0eb959
--- /dev/null
+++ b/packages/leptos/src/align_vertical_distribute_start.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignVerticalDistributeStart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="14" rx="2"></rect>
+            <rect width="10" height="6" x="7" y="4" rx="2"></rect>
+            <path d="M2 14h20"></path>
+            <path d="M2 4h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_vertical_justify_center.rs b/packages/leptos/src/align_vertical_justify_center.rs
new file mode 100644
index 0000000..78e420f
--- /dev/null
+++ b/packages/leptos/src/align_vertical_justify_center.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignVerticalJustifyCenter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="16" rx="2"></rect>
+            <rect width="10" height="6" x="7" y="2" rx="2"></rect>
+            <path d="M2 12h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_vertical_justify_end.rs b/packages/leptos/src/align_vertical_justify_end.rs
new file mode 100644
index 0000000..cd3ec57
--- /dev/null
+++ b/packages/leptos/src/align_vertical_justify_end.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignVerticalJustifyEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="12" rx="2"></rect>
+            <rect width="10" height="6" x="7" y="2" rx="2"></rect>
+            <path d="M2 22h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_vertical_justify_start.rs b/packages/leptos/src/align_vertical_justify_start.rs
new file mode 100644
index 0000000..4a8b584
--- /dev/null
+++ b/packages/leptos/src/align_vertical_justify_start.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignVerticalJustifyStart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="16" rx="2"></rect>
+            <rect width="10" height="6" x="7" y="6" rx="2"></rect>
+            <path d="M2 2h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_vertical_space_around.rs b/packages/leptos/src/align_vertical_space_around.rs
new file mode 100644
index 0000000..ccb67b5
--- /dev/null
+++ b/packages/leptos/src/align_vertical_space_around.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignVerticalSpaceAround(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="10" height="6" x="7" y="9" rx="2"></rect>
+            <path d="M22 20H2"></path>
+            <path d="M22 4H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/align_vertical_space_between.rs b/packages/leptos/src/align_vertical_space_between.rs
new file mode 100644
index 0000000..5788f26
--- /dev/null
+++ b/packages/leptos/src/align_vertical_space_between.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AlignVerticalSpaceBetween(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="15" rx="2"></rect>
+            <rect width="10" height="6" x="7" y="3" rx="2"></rect>
+            <path d="M2 21h20"></path>
+            <path d="M2 3h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ambulance.rs b/packages/leptos/src/ambulance.rs
new file mode 100644
index 0000000..84e82d5
--- /dev/null
+++ b/packages/leptos/src/ambulance.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ambulance(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10H6"></path>
+            <path d="M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2"></path>
+            <path d="M19 18h2a1 1 0 0 0 1-1v-3.28a1 1 0 0 0-.684-.948l-1.923-.641a1 1 0 0 1-.578-.502l-1.539-3.076A1 1 0 0 0 16.382 8H14"></path>
+            <path d="M8 8v4"></path>
+            <path d="M9 18h6"></path>
+            <circle cx="17" cy="18" r="2"></circle>
+            <circle cx="7" cy="18" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ampersand.rs b/packages/leptos/src/ampersand.rs
new file mode 100644
index 0000000..1c41988
--- /dev/null
+++ b/packages/leptos/src/ampersand.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ampersand(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.5 12c0 4.4-3.6 8-8 8A4.5 4.5 0 0 1 5 15.5c0-6 8-4 8-8.5a3 3 0 1 0-6 0c0 3 2.5 8.5 12 13"></path>
+            <path d="M16 12h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ampersands.rs b/packages/leptos/src/ampersands.rs
new file mode 100644
index 0000000..fb6d2c6
--- /dev/null
+++ b/packages/leptos/src/ampersands.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ampersands(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5"></path>
+            <path d="M22 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/amphora.rs b/packages/leptos/src/amphora.rs
new file mode 100644
index 0000000..27c6f81
--- /dev/null
+++ b/packages/leptos/src/amphora.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Amphora(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v5.632c0 .424-.272.795-.653.982A6 6 0 0 0 6 14c.006 4 3 7 5 8"></path>
+            <path d="M10 5H8a2 2 0 0 0 0 4h.68"></path>
+            <path d="M14 2v5.632c0 .424.272.795.652.982A6 6 0 0 1 18 14c0 4-3 7-5 8"></path>
+            <path d="M14 5h2a2 2 0 0 1 0 4h-.68"></path>
+            <path d="M18 22H6"></path>
+            <path d="M9 2h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/anchor.rs b/packages/leptos/src/anchor.rs
new file mode 100644
index 0000000..93ef8aa
--- /dev/null
+++ b/packages/leptos/src/anchor.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Anchor(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22V8"></path>
+            <path d="M5 12H2a10 10 0 0 0 20 0h-3"></path>
+            <circle cx="12" cy="5" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/angry.rs b/packages/leptos/src/angry.rs
new file mode 100644
index 0000000..482e41c
--- /dev/null
+++ b/packages/leptos/src/angry.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Angry(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M16 16s-1.5-2-4-2-4 2-4 2"></path>
+            <path d="M7.5 8 10 9"></path>
+            <path d="m14 9 2.5-1"></path>
+            <path d="M9 10h.01"></path>
+            <path d="M15 10h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/annoyed.rs b/packages/leptos/src/annoyed.rs
new file mode 100644
index 0000000..a5cf5d4
--- /dev/null
+++ b/packages/leptos/src/annoyed.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Annoyed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M8 15h8"></path>
+            <path d="M8 9h2"></path>
+            <path d="M14 9h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/antenna.rs b/packages/leptos/src/antenna.rs
new file mode 100644
index 0000000..ba1f2cd
--- /dev/null
+++ b/packages/leptos/src/antenna.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Antenna(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12 7 2"></path>
+            <path d="m7 12 5-10"></path>
+            <path d="m12 12 5-10"></path>
+            <path d="m17 12 5-10"></path>
+            <path d="M4.5 7h15"></path>
+            <path d="M12 16v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/anvil.rs b/packages/leptos/src/anvil.rs
new file mode 100644
index 0000000..fb39ed9
--- /dev/null
+++ b/packages/leptos/src/anvil.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Anvil(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 10H6a4 4 0 0 1-4-4 1 1 0 0 1 1-1h4"></path>
+            <path d="M7 5a1 1 0 0 1 1-1h13a1 1 0 0 1 1 1 7 7 0 0 1-7 7H8a1 1 0 0 1-1-1z"></path>
+            <path d="M9 12v5"></path>
+            <path d="M15 12v5"></path>
+            <path d="M5 20a3 3 0 0 1 3-3h8a3 3 0 0 1 3 3 1 1 0 0 1-1 1H6a1 1 0 0 1-1-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/aperture.rs b/packages/leptos/src/aperture.rs
new file mode 100644
index 0000000..2785923
--- /dev/null
+++ b/packages/leptos/src/aperture.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Aperture(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m14.31 8 5.74 9.94"></path>
+            <path d="M9.69 8h11.48"></path>
+            <path d="m7.38 12 5.74-9.94"></path>
+            <path d="M9.69 16 3.95 6.06"></path>
+            <path d="M14.31 16H2.83"></path>
+            <path d="m16.62 12-5.74 9.94"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/app_window.rs b/packages/leptos/src/app_window.rs
new file mode 100644
index 0000000..5ab38c4
--- /dev/null
+++ b/packages/leptos/src/app_window.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AppWindow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="2" y="4" width="20" height="16" rx="2"></rect>
+            <path d="M10 4v4"></path>
+            <path d="M2 8h20"></path>
+            <path d="M6 4v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/app_window_mac.rs b/packages/leptos/src/app_window_mac.rs
new file mode 100644
index 0000000..b1d0bcd
--- /dev/null
+++ b/packages/leptos/src/app_window_mac.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AppWindowMac(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+            <path d="M6 8h.01"></path>
+            <path d="M10 8h.01"></path>
+            <path d="M14 8h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/apple.rs b/packages/leptos/src/apple.rs
new file mode 100644
index 0000000..98ec42b
--- /dev/null
+++ b/packages/leptos/src/apple.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Apple(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20.94c1.5 0 2.75 1.06 4 1.06 3 0 6-8 6-12.22A4.91 4.91 0 0 0 17 5c-2.22 0-4 1.44-5 2-1-.56-2.78-2-5-2a4.9 4.9 0 0 0-5 4.78C2 14 5 22 8 22c1.25 0 2.5-1.06 4-1.06Z"></path>
+            <path d="M10 2c1 .5 2 2 2 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/archive.rs b/packages/leptos/src/archive.rs
new file mode 100644
index 0000000..b6ffa0b
--- /dev/null
+++ b/packages/leptos/src/archive.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Archive(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="5" x="2" y="3" rx="1"></rect>
+            <path d="M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8"></path>
+            <path d="M10 12h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/archive_restore.rs b/packages/leptos/src/archive_restore.rs
new file mode 100644
index 0000000..ae6ada7
--- /dev/null
+++ b/packages/leptos/src/archive_restore.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArchiveRestore(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="5" x="2" y="3" rx="1"></rect>
+            <path d="M4 8v11a2 2 0 0 0 2 2h2"></path>
+            <path d="M20 8v11a2 2 0 0 1-2 2h-2"></path>
+            <path d="m9 15 3-3 3 3"></path>
+            <path d="M12 12v9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/archive_x.rs b/packages/leptos/src/archive_x.rs
new file mode 100644
index 0000000..272c993
--- /dev/null
+++ b/packages/leptos/src/archive_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArchiveX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="5" x="2" y="3" rx="1"></rect>
+            <path d="M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8"></path>
+            <path d="m9.5 17 5-5"></path>
+            <path d="m9.5 12 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/armchair.rs b/packages/leptos/src/armchair.rs
new file mode 100644
index 0000000..b79064f
--- /dev/null
+++ b/packages/leptos/src/armchair.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Armchair(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 9V6a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v3"></path>
+            <path d="M3 16a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-9a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z"></path>
+            <path d="M5 18v2"></path>
+            <path d="M19 18v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_big_down.rs b/packages/leptos/src/arrow_big_down.rs
new file mode 100644
index 0000000..e8c7ac8
--- /dev/null
+++ b/packages/leptos/src/arrow_big_down.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowBigDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 6v6h4l-7 7-7-7h4V6h6z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_big_down_dash.rs b/packages/leptos/src/arrow_big_down_dash.rs
new file mode 100644
index 0000000..661a02c
--- /dev/null
+++ b/packages/leptos/src/arrow_big_down_dash.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowBigDownDash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 5H9"></path>
+            <path d="M15 9v3h4l-7 7-7-7h4V9z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_big_left.rs b/packages/leptos/src/arrow_big_left.rs
new file mode 100644
index 0000000..b8ad1e6
--- /dev/null
+++ b/packages/leptos/src/arrow_big_left.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowBigLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 15h-6v4l-7-7 7-7v4h6v6z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_big_left_dash.rs b/packages/leptos/src/arrow_big_left_dash.rs
new file mode 100644
index 0000000..1d0f61a
--- /dev/null
+++ b/packages/leptos/src/arrow_big_left_dash.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowBigLeftDash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 15V9"></path>
+            <path d="M15 15h-3v4l-7-7 7-7v4h3v6z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_big_right.rs b/packages/leptos/src/arrow_big_right.rs
new file mode 100644
index 0000000..28534be
--- /dev/null
+++ b/packages/leptos/src/arrow_big_right.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowBigRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 9h6V5l7 7-7 7v-4H6V9z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_big_right_dash.rs b/packages/leptos/src/arrow_big_right_dash.rs
new file mode 100644
index 0000000..585c2fc
--- /dev/null
+++ b/packages/leptos/src/arrow_big_right_dash.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowBigRightDash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 9v6"></path>
+            <path d="M9 9h3V5l7 7-7 7v-4H9V9z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_big_up.rs b/packages/leptos/src/arrow_big_up.rs
new file mode 100644
index 0000000..d68254e
--- /dev/null
+++ b/packages/leptos/src/arrow_big_up.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowBigUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 18v-6H5l7-7 7 7h-4v6H9z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_big_up_dash.rs b/packages/leptos/src/arrow_big_up_dash.rs
new file mode 100644
index 0000000..7e92101
--- /dev/null
+++ b/packages/leptos/src/arrow_big_up_dash.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowBigUpDash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 19h6"></path>
+            <path d="M9 15v-3H5l7-7 7 7h-4v3H9z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down.rs b/packages/leptos/src/arrow_down.rs
new file mode 100644
index 0000000..dafc051
--- /dev/null
+++ b/packages/leptos/src/arrow_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5v14"></path>
+            <path d="m19 12-7 7-7-7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_0_1.rs b/packages/leptos/src/arrow_down_0_1.rs
new file mode 100644
index 0000000..1115824
--- /dev/null
+++ b/packages/leptos/src/arrow_down_0_1.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDown01(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4"></path>
+            <path d="M7 20V4"></path>
+            <rect x="15" y="4" width="4" height="6" ry="2"></rect>
+            <path d="M17 20v-6h-2"></path>
+            <path d="M15 20h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_1_0.rs b/packages/leptos/src/arrow_down_1_0.rs
new file mode 100644
index 0000000..714c420
--- /dev/null
+++ b/packages/leptos/src/arrow_down_1_0.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDown10(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4"></path>
+            <path d="M7 20V4"></path>
+            <path d="M17 10V4h-2"></path>
+            <path d="M15 10h4"></path>
+            <rect x="15" y="14" width="4" height="6" ry="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_a_z.rs b/packages/leptos/src/arrow_down_a_z.rs
new file mode 100644
index 0000000..1fc728f
--- /dev/null
+++ b/packages/leptos/src/arrow_down_a_z.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownAZ(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4"></path>
+            <path d="M7 20V4"></path>
+            <path d="M20 8h-5"></path>
+            <path d="M15 10V6.5a2.5 2.5 0 0 1 5 0V10"></path>
+            <path d="M15 14h5l-5 6h5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_from_line.rs b/packages/leptos/src/arrow_down_from_line.rs
new file mode 100644
index 0000000..0464b9a
--- /dev/null
+++ b/packages/leptos/src/arrow_down_from_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownFromLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 3H5"></path>
+            <path d="M12 21V7"></path>
+            <path d="m6 15 6 6 6-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_left.rs b/packages/leptos/src/arrow_down_left.rs
new file mode 100644
index 0000000..8648bb9
--- /dev/null
+++ b/packages/leptos/src/arrow_down_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 7 7 17"></path>
+            <path d="M17 17H7V7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_narrow_wide.rs b/packages/leptos/src/arrow_down_narrow_wide.rs
new file mode 100644
index 0000000..0632a59
--- /dev/null
+++ b/packages/leptos/src/arrow_down_narrow_wide.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownNarrowWide(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4"></path>
+            <path d="M7 20V4"></path>
+            <path d="M11 4h4"></path>
+            <path d="M11 8h7"></path>
+            <path d="M11 12h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_right.rs b/packages/leptos/src/arrow_down_right.rs
new file mode 100644
index 0000000..28f67dc
--- /dev/null
+++ b/packages/leptos/src/arrow_down_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 7 10 10"></path>
+            <path d="M17 7v10H7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_to_dot.rs b/packages/leptos/src/arrow_down_to_dot.rs
new file mode 100644
index 0000000..8837423
--- /dev/null
+++ b/packages/leptos/src/arrow_down_to_dot.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownToDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v14"></path>
+            <path d="m19 9-7 7-7-7"></path>
+            <circle cx="12" cy="21" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_to_line.rs b/packages/leptos/src/arrow_down_to_line.rs
new file mode 100644
index 0000000..493247f
--- /dev/null
+++ b/packages/leptos/src/arrow_down_to_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownToLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17V3"></path>
+            <path d="m6 11 6 6 6-6"></path>
+            <path d="M19 21H5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_up.rs b/packages/leptos/src/arrow_down_up.rs
new file mode 100644
index 0000000..de7a890
--- /dev/null
+++ b/packages/leptos/src/arrow_down_up.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4"></path>
+            <path d="M7 20V4"></path>
+            <path d="m21 8-4-4-4 4"></path>
+            <path d="M17 4v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_wide_narrow.rs b/packages/leptos/src/arrow_down_wide_narrow.rs
new file mode 100644
index 0000000..3d6ed97
--- /dev/null
+++ b/packages/leptos/src/arrow_down_wide_narrow.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownWideNarrow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4"></path>
+            <path d="M7 20V4"></path>
+            <path d="M11 4h10"></path>
+            <path d="M11 8h7"></path>
+            <path d="M11 12h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_down_z_a.rs b/packages/leptos/src/arrow_down_z_a.rs
new file mode 100644
index 0000000..0b038ad
--- /dev/null
+++ b/packages/leptos/src/arrow_down_z_a.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowDownZA(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4"></path>
+            <path d="M7 4v16"></path>
+            <path d="M15 4h5l-5 6h5"></path>
+            <path d="M15 20v-3.5a2.5 2.5 0 0 1 5 0V20"></path>
+            <path d="M20 18h-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_left.rs b/packages/leptos/src/arrow_left.rs
new file mode 100644
index 0000000..5cd9de9
--- /dev/null
+++ b/packages/leptos/src/arrow_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 19-7-7 7-7"></path>
+            <path d="M19 12H5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_left_from_line.rs b/packages/leptos/src/arrow_left_from_line.rs
new file mode 100644
index 0000000..dded6d9
--- /dev/null
+++ b/packages/leptos/src/arrow_left_from_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowLeftFromLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 6-6 6 6 6"></path>
+            <path d="M3 12h14"></path>
+            <path d="M21 19V5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_left_right.rs b/packages/leptos/src/arrow_left_right.rs
new file mode 100644
index 0000000..9ec7175
--- /dev/null
+++ b/packages/leptos/src/arrow_left_right.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowLeftRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3 4 7l4 4"></path>
+            <path d="M4 7h16"></path>
+            <path d="m16 21 4-4-4-4"></path>
+            <path d="M20 17H4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_left_to_line.rs b/packages/leptos/src/arrow_left_to_line.rs
new file mode 100644
index 0000000..1b72dd2
--- /dev/null
+++ b/packages/leptos/src/arrow_left_to_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowLeftToLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 19V5"></path>
+            <path d="m13 6-6 6 6 6"></path>
+            <path d="M7 12h14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_right.rs b/packages/leptos/src/arrow_right.rs
new file mode 100644
index 0000000..812ce00
--- /dev/null
+++ b/packages/leptos/src/arrow_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 12h14"></path>
+            <path d="m12 5 7 7-7 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_right_from_line.rs b/packages/leptos/src/arrow_right_from_line.rs
new file mode 100644
index 0000000..003468d
--- /dev/null
+++ b/packages/leptos/src/arrow_right_from_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowRightFromLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 5v14"></path>
+            <path d="M21 12H7"></path>
+            <path d="m15 18 6-6-6-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_right_left.rs b/packages/leptos/src/arrow_right_left.rs
new file mode 100644
index 0000000..6968f58
--- /dev/null
+++ b/packages/leptos/src/arrow_right_left.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowRightLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 3 4 4-4 4"></path>
+            <path d="M20 7H4"></path>
+            <path d="m8 21-4-4 4-4"></path>
+            <path d="M4 17h16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_right_to_line.rs b/packages/leptos/src/arrow_right_to_line.rs
new file mode 100644
index 0000000..3bce6e8
--- /dev/null
+++ b/packages/leptos/src/arrow_right_to_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowRightToLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 12H3"></path>
+            <path d="m11 18 6-6-6-6"></path>
+            <path d="M21 5v14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up.rs b/packages/leptos/src/arrow_up.rs
new file mode 100644
index 0000000..97ee56a
--- /dev/null
+++ b/packages/leptos/src/arrow_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5 12 7-7 7 7"></path>
+            <path d="M12 19V5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_0_1.rs b/packages/leptos/src/arrow_up_0_1.rs
new file mode 100644
index 0000000..f522037
--- /dev/null
+++ b/packages/leptos/src/arrow_up_0_1.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUp01(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4"></path>
+            <path d="M7 4v16"></path>
+            <rect x="15" y="4" width="4" height="6" ry="2"></rect>
+            <path d="M17 20v-6h-2"></path>
+            <path d="M15 20h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_1_0.rs b/packages/leptos/src/arrow_up_1_0.rs
new file mode 100644
index 0000000..0884c7a
--- /dev/null
+++ b/packages/leptos/src/arrow_up_1_0.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUp10(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4"></path>
+            <path d="M7 4v16"></path>
+            <path d="M17 10V4h-2"></path>
+            <path d="M15 10h4"></path>
+            <rect x="15" y="14" width="4" height="6" ry="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_a_z.rs b/packages/leptos/src/arrow_up_a_z.rs
new file mode 100644
index 0000000..a9dbdcf
--- /dev/null
+++ b/packages/leptos/src/arrow_up_a_z.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpAZ(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4"></path>
+            <path d="M7 4v16"></path>
+            <path d="M20 8h-5"></path>
+            <path d="M15 10V6.5a2.5 2.5 0 0 1 5 0V10"></path>
+            <path d="M15 14h5l-5 6h5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_down.rs b/packages/leptos/src/arrow_up_down.rs
new file mode 100644
index 0000000..3b83c52
--- /dev/null
+++ b/packages/leptos/src/arrow_up_down.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21 16-4 4-4-4"></path>
+            <path d="M17 20V4"></path>
+            <path d="m3 8 4-4 4 4"></path>
+            <path d="M7 4v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_from_dot.rs b/packages/leptos/src/arrow_up_from_dot.rs
new file mode 100644
index 0000000..aeaeb8e
--- /dev/null
+++ b/packages/leptos/src/arrow_up_from_dot.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpFromDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5 9 7-7 7 7"></path>
+            <path d="M12 16V2"></path>
+            <circle cx="12" cy="21" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_from_line.rs b/packages/leptos/src/arrow_up_from_line.rs
new file mode 100644
index 0000000..6ad3f87
--- /dev/null
+++ b/packages/leptos/src/arrow_up_from_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpFromLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 9-6-6-6 6"></path>
+            <path d="M12 3v14"></path>
+            <path d="M5 21h14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_left.rs b/packages/leptos/src/arrow_up_left.rs
new file mode 100644
index 0000000..8675c0f
--- /dev/null
+++ b/packages/leptos/src/arrow_up_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 17V7h10"></path>
+            <path d="M17 17 7 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_narrow_wide.rs b/packages/leptos/src/arrow_up_narrow_wide.rs
new file mode 100644
index 0000000..c3550e5
--- /dev/null
+++ b/packages/leptos/src/arrow_up_narrow_wide.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpNarrowWide(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4"></path>
+            <path d="M7 4v16"></path>
+            <path d="M11 12h4"></path>
+            <path d="M11 16h7"></path>
+            <path d="M11 20h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_right.rs b/packages/leptos/src/arrow_up_right.rs
new file mode 100644
index 0000000..312ddaf
--- /dev/null
+++ b/packages/leptos/src/arrow_up_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 7h10v10"></path>
+            <path d="M7 17 17 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_to_line.rs b/packages/leptos/src/arrow_up_to_line.rs
new file mode 100644
index 0000000..a7f660f
--- /dev/null
+++ b/packages/leptos/src/arrow_up_to_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpToLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 3h14"></path>
+            <path d="m18 13-6-6-6 6"></path>
+            <path d="M12 7v14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_wide_narrow.rs b/packages/leptos/src/arrow_up_wide_narrow.rs
new file mode 100644
index 0000000..d3bfec4
--- /dev/null
+++ b/packages/leptos/src/arrow_up_wide_narrow.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpWideNarrow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4"></path>
+            <path d="M7 4v16"></path>
+            <path d="M11 12h10"></path>
+            <path d="M11 16h7"></path>
+            <path d="M11 20h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrow_up_z_a.rs b/packages/leptos/src/arrow_up_z_a.rs
new file mode 100644
index 0000000..391f246
--- /dev/null
+++ b/packages/leptos/src/arrow_up_z_a.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowUpZA(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4"></path>
+            <path d="M7 4v16"></path>
+            <path d="M15 4h5l-5 6h5"></path>
+            <path d="M15 20v-3.5a2.5 2.5 0 0 1 5 0V20"></path>
+            <path d="M20 18h-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/arrows_up_from_line.rs b/packages/leptos/src/arrows_up_from_line.rs
new file mode 100644
index 0000000..08ed0e1
--- /dev/null
+++ b/packages/leptos/src/arrows_up_from_line.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ArrowsUpFromLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4 6 3-3 3 3"></path>
+            <path d="M7 17V3"></path>
+            <path d="m14 6 3-3 3 3"></path>
+            <path d="M17 17V3"></path>
+            <path d="M4 21h16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/asterisk.rs b/packages/leptos/src/asterisk.rs
new file mode 100644
index 0000000..d761a54
--- /dev/null
+++ b/packages/leptos/src/asterisk.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Asterisk(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v12"></path>
+            <path d="M17.196 9 6.804 15"></path>
+            <path d="m6.804 9 10.392 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/at_sign.rs b/packages/leptos/src/at_sign.rs
new file mode 100644
index 0000000..b30b4e5
--- /dev/null
+++ b/packages/leptos/src/at_sign.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AtSign(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="4"></circle>
+            <path d="M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-4 8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/atom.rs b/packages/leptos/src/atom.rs
new file mode 100644
index 0000000..ab5a545
--- /dev/null
+++ b/packages/leptos/src/atom.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Atom(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="1"></circle>
+            <path d="M20.2 20.2c2.04-2.03.02-7.36-4.5-11.9-4.54-4.52-9.87-6.54-11.9-4.5-2.04 2.03-.02 7.36 4.5 11.9 4.54 4.52 9.87 6.54 11.9 4.5Z"></path>
+            <path d="M15.7 15.7c4.52-4.54 6.54-9.87 4.5-11.9-2.03-2.04-7.36-.02-11.9 4.5-4.52 4.54-6.54 9.87-4.5 11.9 2.03 2.04 7.36.02 11.9-4.5Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/audio_lines.rs b/packages/leptos/src/audio_lines.rs
new file mode 100644
index 0000000..48b18ce
--- /dev/null
+++ b/packages/leptos/src/audio_lines.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AudioLines(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 10v3"></path>
+            <path d="M6 6v11"></path>
+            <path d="M10 3v18"></path>
+            <path d="M14 8v7"></path>
+            <path d="M18 5v13"></path>
+            <path d="M22 10v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/audio_waveform.rs b/packages/leptos/src/audio_waveform.rs
new file mode 100644
index 0000000..8db7887
--- /dev/null
+++ b/packages/leptos/src/audio_waveform.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn AudioWaveform(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 13a2 2 0 0 0 2-2V7a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0V4a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0v-4a2 2 0 0 1 2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/award.rs b/packages/leptos/src/award.rs
new file mode 100644
index 0000000..14d4489
--- /dev/null
+++ b/packages/leptos/src/award.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Award(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15.477 12.89 1.515 8.526a.5.5 0 0 1-.81.47l-3.58-2.687a1 1 0 0 0-1.197 0l-3.586 2.686a.5.5 0 0 1-.81-.469l1.514-8.526"></path>
+            <circle cx="12" cy="8" r="6"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/axe.rs b/packages/leptos/src/axe.rs
new file mode 100644
index 0000000..1958249
--- /dev/null
+++ b/packages/leptos/src/axe.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Axe(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14 12-8.5 8.5a2.12 2.12 0 1 1-3-3L11 9"></path>
+            <path d="M15 13 9 7l4-4 6 6h3a8 8 0 0 1-7 7z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/axis_3_d.rs b/packages/leptos/src/axis_3_d.rs
new file mode 100644
index 0000000..5dc166f
--- /dev/null
+++ b/packages/leptos/src/axis_3_d.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Axis3D(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16h16"></path>
+            <path d="m4 20 7-7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/baby.rs b/packages/leptos/src/baby.rs
new file mode 100644
index 0000000..6b48566
--- /dev/null
+++ b/packages/leptos/src/baby.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Baby(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 12h.01"></path>
+            <path d="M15 12h.01"></path>
+            <path d="M10 16c.5.3 1.2.5 2 .5s1.5-.2 2-.5"></path>
+            <path d="M19 6.3a9 9 0 0 1 1.8 3.9 2 2 0 0 1 0 3.6 9 9 0 0 1-17.6 0 2 2 0 0 1 0-3.6A9 9 0 0 1 12 3c2 0 3.5 1.1 3.5 2.5s-.9 2.5-2 2.5c-.8 0-1.5-.4-1.5-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/backpack.rs b/packages/leptos/src/backpack.rs
new file mode 100644
index 0000000..b0f5432
--- /dev/null
+++ b/packages/leptos/src/backpack.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Backpack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10a4 4 0 0 1 4-4h8a4 4 0 0 1 4 4v10a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2z"></path>
+            <path d="M8 10h8"></path>
+            <path d="M8 18h8"></path>
+            <path d="M8 22v-6a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v6"></path>
+            <path d="M9 6V4a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge.rs b/packages/leptos/src/badge.rs
new file mode 100644
index 0000000..9d2e999
--- /dev/null
+++ b/packages/leptos/src/badge.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Badge(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_alert.rs b/packages/leptos/src/badge_alert.rs
new file mode 100644
index 0000000..ce4239c
--- /dev/null
+++ b/packages/leptos/src/badge_alert.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeAlert(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <line x1="12" x2="12" y1="8" y2="12"></line>
+            <line x1="12" x2="12.01" y1="16" y2="16"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_cent.rs b/packages/leptos/src/badge_cent.rs
new file mode 100644
index 0000000..f3150fc
--- /dev/null
+++ b/packages/leptos/src/badge_cent.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeCent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="M12 7v10"></path>
+            <path d="M15.4 10a4 4 0 1 0 0 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_check.rs b/packages/leptos/src/badge_check.rs
new file mode 100644
index 0000000..d7a8610
--- /dev/null
+++ b/packages/leptos/src/badge_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="m9 12 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_dollar_sign.rs b/packages/leptos/src/badge_dollar_sign.rs
new file mode 100644
index 0000000..e518ab7
--- /dev/null
+++ b/packages/leptos/src/badge_dollar_sign.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeDollarSign(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8"></path>
+            <path d="M12 18V6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_euro.rs b/packages/leptos/src/badge_euro.rs
new file mode 100644
index 0000000..78f02a7
--- /dev/null
+++ b/packages/leptos/src/badge_euro.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeEuro(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="M7 12h5"></path>
+            <path d="M15 9.4a4 4 0 1 0 0 5.2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_help.rs b/packages/leptos/src/badge_help.rs
new file mode 100644
index 0000000..569f49e
--- /dev/null
+++ b/packages/leptos/src/badge_help.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeHelp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"></path>
+            <line x1="12" x2="12.01" y1="17" y2="17"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_indian_rupee.rs b/packages/leptos/src/badge_indian_rupee.rs
new file mode 100644
index 0000000..8931108
--- /dev/null
+++ b/packages/leptos/src/badge_indian_rupee.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeIndianRupee(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="M8 8h8"></path>
+            <path d="M8 12h8"></path>
+            <path d="m13 17-5-1h1a4 4 0 0 0 0-8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_info.rs b/packages/leptos/src/badge_info.rs
new file mode 100644
index 0000000..ebfcbc8
--- /dev/null
+++ b/packages/leptos/src/badge_info.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeInfo(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <line x1="12" x2="12" y1="16" y2="12"></line>
+            <line x1="12" x2="12.01" y1="8" y2="8"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_japanese_yen.rs b/packages/leptos/src/badge_japanese_yen.rs
new file mode 100644
index 0000000..c983874
--- /dev/null
+++ b/packages/leptos/src/badge_japanese_yen.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeJapaneseYen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="m9 8 3 3v7"></path>
+            <path d="m12 11 3-3"></path>
+            <path d="M9 12h6"></path>
+            <path d="M9 16h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_minus.rs b/packages/leptos/src/badge_minus.rs
new file mode 100644
index 0000000..bdba64b
--- /dev/null
+++ b/packages/leptos/src/badge_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <line x1="8" x2="16" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_percent.rs b/packages/leptos/src/badge_percent.rs
new file mode 100644
index 0000000..6d5897e
--- /dev/null
+++ b/packages/leptos/src/badge_percent.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgePercent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="m15 9-6 6"></path>
+            <path d="M9 9h.01"></path>
+            <path d="M15 15h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_plus.rs b/packages/leptos/src/badge_plus.rs
new file mode 100644
index 0000000..19ac21b
--- /dev/null
+++ b/packages/leptos/src/badge_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <line x1="12" x2="12" y1="8" y2="16"></line>
+            <line x1="8" x2="16" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_pound_sterling.rs b/packages/leptos/src/badge_pound_sterling.rs
new file mode 100644
index 0000000..d658975
--- /dev/null
+++ b/packages/leptos/src/badge_pound_sterling.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgePoundSterling(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="M8 12h4"></path>
+            <path d="M10 16V9.5a2.5 2.5 0 0 1 5 0"></path>
+            <path d="M8 16h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_russian_ruble.rs b/packages/leptos/src/badge_russian_ruble.rs
new file mode 100644
index 0000000..f3aff0e
--- /dev/null
+++ b/packages/leptos/src/badge_russian_ruble.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeRussianRuble(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="M9 16h5"></path>
+            <path d="M9 12h5a2 2 0 1 0 0-4h-3v9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_swiss_franc.rs b/packages/leptos/src/badge_swiss_franc.rs
new file mode 100644
index 0000000..5bad84e
--- /dev/null
+++ b/packages/leptos/src/badge_swiss_franc.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeSwissFranc(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <path d="M11 17V8h4"></path>
+            <path d="M11 12h3"></path>
+            <path d="M9 16h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/badge_x.rs b/packages/leptos/src/badge_x.rs
new file mode 100644
index 0000000..2c2a33e
--- /dev/null
+++ b/packages/leptos/src/badge_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BadgeX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"></path>
+            <line x1="15" x2="9" y1="9" y2="15"></line>
+            <line x1="9" x2="15" y1="9" y2="15"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/baggage_claim.rs b/packages/leptos/src/baggage_claim.rs
new file mode 100644
index 0000000..56407d0
--- /dev/null
+++ b/packages/leptos/src/baggage_claim.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BaggageClaim(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 18H6a2 2 0 0 1-2-2V7a2 2 0 0 0-2-2"></path>
+            <path d="M17 14V4a2 2 0 0 0-2-2h-1a2 2 0 0 0-2 2v10"></path>
+            <rect width="13" height="8" x="8" y="6" rx="1"></rect>
+            <circle cx="18" cy="20" r="2"></circle>
+            <circle cx="9" cy="20" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ban.rs b/packages/leptos/src/ban.rs
new file mode 100644
index 0000000..e8f99c1
--- /dev/null
+++ b/packages/leptos/src/ban.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ban(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m4.9 4.9 14.2 14.2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/banana.rs b/packages/leptos/src/banana.rs
new file mode 100644
index 0000000..8a081d1
--- /dev/null
+++ b/packages/leptos/src/banana.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Banana(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 13c3.5-2 8-2 10 2a5.5 5.5 0 0 1 8 5"></path>
+            <path d="M5.15 17.89c5.52-1.52 8.65-6.89 7-12C11.55 4 11.5 2 13 2c3.22 0 5 5.5 5 8 0 6.5-4.2 12-10.49 12C5.11 22 2 22 2 20c0-1.5 1.14-1.55 3.15-2.11Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bandage.rs b/packages/leptos/src/bandage.rs
new file mode 100644
index 0000000..199bc46
--- /dev/null
+++ b/packages/leptos/src/bandage.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bandage(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10.01h.01"></path>
+            <path d="M10 14.01h.01"></path>
+            <path d="M14 10.01h.01"></path>
+            <path d="M14 14.01h.01"></path>
+            <path d="M18 6v11.5"></path>
+            <path d="M6 6v12"></path>
+            <rect x="2" y="6" width="20" height="12" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/banknote.rs b/packages/leptos/src/banknote.rs
new file mode 100644
index 0000000..ad31b76
--- /dev/null
+++ b/packages/leptos/src/banknote.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Banknote(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="2"></rect>
+            <circle cx="12" cy="12" r="2"></circle>
+            <path d="M6 12h.01M18 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/barcode.rs b/packages/leptos/src/barcode.rs
new file mode 100644
index 0000000..b832499
--- /dev/null
+++ b/packages/leptos/src/barcode.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Barcode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 5v14"></path>
+            <path d="M8 5v14"></path>
+            <path d="M12 5v14"></path>
+            <path d="M17 5v14"></path>
+            <path d="M21 5v14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/baseline.rs b/packages/leptos/src/baseline.rs
new file mode 100644
index 0000000..a858745
--- /dev/null
+++ b/packages/leptos/src/baseline.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Baseline(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 20h16"></path>
+            <path d="m6 16 6-12 6 12"></path>
+            <path d="M8 12h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bath.rs b/packages/leptos/src/bath.rs
new file mode 100644
index 0000000..07386eb
--- /dev/null
+++ b/packages/leptos/src/bath.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bath(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 4 8 6"></path>
+            <path d="M17 19v2"></path>
+            <path d="M2 12h20"></path>
+            <path d="M7 19v2"></path>
+            <path d="M9 5 7.621 3.621A2.121 2.121 0 0 0 4 5v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/battery.rs b/packages/leptos/src/battery.rs
new file mode 100644
index 0000000..ed2dc53
--- /dev/null
+++ b/packages/leptos/src/battery.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Battery(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="10" x="2" y="7" rx="2" ry="2"></rect>
+            <line x1="22" x2="22" y1="11" y2="13"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/battery_charging.rs b/packages/leptos/src/battery_charging.rs
new file mode 100644
index 0000000..1b5093e
--- /dev/null
+++ b/packages/leptos/src/battery_charging.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BatteryCharging(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 7h1a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2h-2"></path>
+            <path d="M6 7H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h1"></path>
+            <path d="m11 7-3 5h4l-3 5"></path>
+            <line x1="22" x2="22" y1="11" y2="13"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/battery_full.rs b/packages/leptos/src/battery_full.rs
new file mode 100644
index 0000000..d827c1e
--- /dev/null
+++ b/packages/leptos/src/battery_full.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BatteryFull(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="10" x="2" y="7" rx="2" ry="2"></rect>
+            <line x1="22" x2="22" y1="11" y2="13"></line>
+            <line x1="6" x2="6" y1="11" y2="13"></line>
+            <line x1="10" x2="10" y1="11" y2="13"></line>
+            <line x1="14" x2="14" y1="11" y2="13"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/battery_low.rs b/packages/leptos/src/battery_low.rs
new file mode 100644
index 0000000..895314f
--- /dev/null
+++ b/packages/leptos/src/battery_low.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BatteryLow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="10" x="2" y="7" rx="2" ry="2"></rect>
+            <line x1="22" x2="22" y1="11" y2="13"></line>
+            <line x1="6" x2="6" y1="11" y2="13"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/battery_medium.rs b/packages/leptos/src/battery_medium.rs
new file mode 100644
index 0000000..3dd2154
--- /dev/null
+++ b/packages/leptos/src/battery_medium.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BatteryMedium(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="10" x="2" y="7" rx="2" ry="2"></rect>
+            <line x1="22" x2="22" y1="11" y2="13"></line>
+            <line x1="6" x2="6" y1="11" y2="13"></line>
+            <line x1="10" x2="10" y1="11" y2="13"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/battery_warning.rs b/packages/leptos/src/battery_warning.rs
new file mode 100644
index 0000000..608ba25
--- /dev/null
+++ b/packages/leptos/src/battery_warning.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BatteryWarning(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 17h.01"></path>
+            <path d="M10 7v6"></path>
+            <path d="M14 7h2a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2h-2"></path>
+            <path d="M22 11v2"></path>
+            <path d="M6 7H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/beaker.rs b/packages/leptos/src/beaker.rs
new file mode 100644
index 0000000..53afce8
--- /dev/null
+++ b/packages/leptos/src/beaker.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Beaker(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.5 3h15"></path>
+            <path d="M6 3v16a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V3"></path>
+            <path d="M6 14h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bean.rs b/packages/leptos/src/bean.rs
new file mode 100644
index 0000000..7975d18
--- /dev/null
+++ b/packages/leptos/src/bean.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bean(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.165 6.598C9.954 7.478 9.64 8.36 9 9c-.64.64-1.521.954-2.402 1.165A6 6 0 0 0 8 22c7.732 0 14-6.268 14-14a6 6 0 0 0-11.835-1.402Z"></path>
+            <path d="M5.341 10.62a4 4 0 1 0 5.279-5.28"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bean_off.rs b/packages/leptos/src/bean_off.rs
new file mode 100644
index 0000000..be728e7
--- /dev/null
+++ b/packages/leptos/src/bean_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BeanOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 9c-.64.64-1.521.954-2.402 1.165A6 6 0 0 0 8 22a13.96 13.96 0 0 0 9.9-4.1"></path>
+            <path d="M10.75 5.093A6 6 0 0 1 22 8c0 2.411-.61 4.68-1.683 6.66"></path>
+            <path d="M5.341 10.62a4 4 0 0 0 6.487 1.208M10.62 5.341a4.015 4.015 0 0 1 2.039 2.04"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bed.rs b/packages/leptos/src/bed.rs
new file mode 100644
index 0000000..866e78f
--- /dev/null
+++ b/packages/leptos/src/bed.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 4v16"></path>
+            <path d="M2 8h18a2 2 0 0 1 2 2v10"></path>
+            <path d="M2 17h20"></path>
+            <path d="M6 8v9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bed_double.rs b/packages/leptos/src/bed_double.rs
new file mode 100644
index 0000000..200e2db
--- /dev/null
+++ b/packages/leptos/src/bed_double.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BedDouble(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20v-8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v8"></path>
+            <path d="M4 10V6a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v4"></path>
+            <path d="M12 4v6"></path>
+            <path d="M2 18h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bed_single.rs b/packages/leptos/src/bed_single.rs
new file mode 100644
index 0000000..7274875
--- /dev/null
+++ b/packages/leptos/src/bed_single.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BedSingle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 20v-8a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v8"></path>
+            <path d="M5 10V6a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v4"></path>
+            <path d="M3 18h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/beef.rs b/packages/leptos/src/beef.rs
new file mode 100644
index 0000000..695f014
--- /dev/null
+++ b/packages/leptos/src/beef.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Beef(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12.5" cy="8.5" r="2.5"></circle>
+            <path d="M12.5 2a6.5 6.5 0 0 0-6.22 4.6c-1.1 3.13-.78 3.9-3.18 6.08A3 3 0 0 0 5 18c4 0 8.4-1.8 11.4-4.3A6.5 6.5 0 0 0 12.5 2Z"></path>
+            <path d="m18.5 6 2.19 4.5a6.48 6.48 0 0 1 .31 2 6.49 6.49 0 0 1-2.6 5.2C15.4 20.2 11 22 7 22a3 3 0 0 1-2.68-1.66L2.4 16.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/beer.rs b/packages/leptos/src/beer.rs
new file mode 100644
index 0000000..3238b35
--- /dev/null
+++ b/packages/leptos/src/beer.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Beer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 11h1a3 3 0 0 1 0 6h-1"></path>
+            <path d="M9 12v6"></path>
+            <path d="M13 12v6"></path>
+            <path d="M14 7.5c-1 0-1.44.5-3 .5s-2-.5-3-.5-1.72.5-2.5.5a2.5 2.5 0 0 1 0-5c.78 0 1.57.5 2.5.5S9.44 2 11 2s2 1.5 3 1.5 1.72-.5 2.5-.5a2.5 2.5 0 0 1 0 5c-.78 0-1.5-.5-2.5-.5Z"></path>
+            <path d="M5 8v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/beer_off.rs b/packages/leptos/src/beer_off.rs
new file mode 100644
index 0000000..4c4c44e
--- /dev/null
+++ b/packages/leptos/src/beer_off.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BeerOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 13v5"></path>
+            <path d="M17 11.47V8"></path>
+            <path d="M17 11h1a3 3 0 0 1 2.745 4.211"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M5 8v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2v-3"></path>
+            <path d="M7.536 7.535C6.766 7.649 6.154 8 5.5 8a2.5 2.5 0 0 1-1.768-4.268"></path>
+            <path d="M8.727 3.204C9.306 2.767 9.885 2 11 2c1.56 0 2 1.5 3 1.5s1.72-.5 2.5-.5a1 1 0 1 1 0 5c-.78 0-1.5-.5-2.5-.5a3.149 3.149 0 0 0-.842.12"></path>
+            <path d="M9 14.6V18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bell.rs b/packages/leptos/src/bell.rs
new file mode 100644
index 0000000..25560eb
--- /dev/null
+++ b/packages/leptos/src/bell.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bell(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8a6 6 0 0 1 12 0c0 7 3 9 3 9H3s3-2 3-9"></path>
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bell_dot.rs b/packages/leptos/src/bell_dot.rs
new file mode 100644
index 0000000..d29bbc4
--- /dev/null
+++ b/packages/leptos/src/bell_dot.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BellDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.4 14.9C20.2 16.4 21 17 21 17H3s3-2 3-9c0-3.3 2.7-6 6-6 .7 0 1.3.1 1.9.3"></path>
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0"></path>
+            <circle cx="18" cy="8" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bell_electric.rs b/packages/leptos/src/bell_electric.rs
new file mode 100644
index 0000000..72e24fa
--- /dev/null
+++ b/packages/leptos/src/bell_electric.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BellElectric(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.8 4A6.3 8.7 0 0 1 20 9"></path>
+            <path d="M9 9h.01"></path>
+            <circle cx="9" cy="9" r="7"></circle>
+            <rect width="10" height="6" x="4" y="16" rx="2"></rect>
+            <path d="M14 19c3 0 4.6-1.6 4.6-1.6"></path>
+            <circle cx="20" cy="16" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bell_minus.rs b/packages/leptos/src/bell_minus.rs
new file mode 100644
index 0000000..a4fd3af
--- /dev/null
+++ b/packages/leptos/src/bell_minus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BellMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.4 12c.8 3.8 2.6 5 2.6 5H3s3-2 3-9c0-3.3 2.7-6 6-6 1.8 0 3.4.8 4.5 2"></path>
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0"></path>
+            <path d="M15 8h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bell_off.rs b/packages/leptos/src/bell_off.rs
new file mode 100644
index 0000000..69e27be
--- /dev/null
+++ b/packages/leptos/src/bell_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BellOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.7 3A6 6 0 0 1 18 8a21.3 21.3 0 0 0 .6 5"></path>
+            <path d="M17 17H3s3-2 3-9a4.67 4.67 0 0 1 .3-1.7"></path>
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bell_plus.rs b/packages/leptos/src/bell_plus.rs
new file mode 100644
index 0000000..c4f902a
--- /dev/null
+++ b/packages/leptos/src/bell_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BellPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.3 14.8C20.1 16.4 21 17 21 17H3s3-2 3-9c0-3.3 2.7-6 6-6 1 0 1.9.2 2.8.7"></path>
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0"></path>
+            <path d="M15 8h6"></path>
+            <path d="M18 5v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bell_ring.rs b/packages/leptos/src/bell_ring.rs
new file mode 100644
index 0000000..917da0d
--- /dev/null
+++ b/packages/leptos/src/bell_ring.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BellRing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8a6 6 0 0 1 12 0c0 7 3 9 3 9H3s3-2 3-9"></path>
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0"></path>
+            <path d="M4 2C2.8 3.7 2 5.7 2 8"></path>
+            <path d="M22 8c0-2.3-.8-4.3-2-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/between_horizontal_end.rs b/packages/leptos/src/between_horizontal_end.rs
new file mode 100644
index 0000000..a5586ba
--- /dev/null
+++ b/packages/leptos/src/between_horizontal_end.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BetweenHorizontalEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="13" height="7" x="3" y="3" rx="1"></rect>
+            <path d="m22 15-3-3 3-3"></path>
+            <rect width="13" height="7" x="3" y="14" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/between_horizontal_start.rs b/packages/leptos/src/between_horizontal_start.rs
new file mode 100644
index 0000000..7e95686
--- /dev/null
+++ b/packages/leptos/src/between_horizontal_start.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BetweenHorizontalStart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="13" height="7" x="8" y="3" rx="1"></rect>
+            <path d="m2 9 3 3-3 3"></path>
+            <rect width="13" height="7" x="8" y="14" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/between_vertical_end.rs b/packages/leptos/src/between_vertical_end.rs
new file mode 100644
index 0000000..7468630
--- /dev/null
+++ b/packages/leptos/src/between_vertical_end.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BetweenVerticalEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="13" x="3" y="3" rx="1"></rect>
+            <path d="m9 22 3-3 3 3"></path>
+            <rect width="7" height="13" x="14" y="3" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/between_vertical_start.rs b/packages/leptos/src/between_vertical_start.rs
new file mode 100644
index 0000000..a786273
--- /dev/null
+++ b/packages/leptos/src/between_vertical_start.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BetweenVerticalStart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="13" x="3" y="8" rx="1"></rect>
+            <path d="m15 2-3 3-3-3"></path>
+            <rect width="7" height="13" x="14" y="8" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/biceps_flexed.rs b/packages/leptos/src/biceps_flexed.rs
new file mode 100644
index 0000000..3faee3d
--- /dev/null
+++ b/packages/leptos/src/biceps_flexed.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BicepsFlexed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.409 13.017A5 5 0 0 1 22 15c0 3.866-4 7-9 7-4.077 0-8.153-.82-10.371-2.462-.426-.316-.631-.832-.62-1.362C2.118 12.723 2.627 2 10 2a3 3 0 0 1 3 3 2 2 0 0 1-2 2c-1.105 0-1.64-.444-2-1"></path>
+            <path d="M15 14a5 5 0 0 0-7.584 2"></path>
+            <path d="M9.964 6.825C8.019 7.977 9.5 13 8 15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bike.rs b/packages/leptos/src/bike.rs
new file mode 100644
index 0000000..05647d3
--- /dev/null
+++ b/packages/leptos/src/bike.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bike(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18.5" cy="17.5" r="3.5"></circle>
+            <circle cx="5.5" cy="17.5" r="3.5"></circle>
+            <circle cx="15" cy="5" r="1"></circle>
+            <path d="M12 17.5V14l-3-3 4-3 2 3h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/binary.rs b/packages/leptos/src/binary.rs
new file mode 100644
index 0000000..2e3d588
--- /dev/null
+++ b/packages/leptos/src/binary.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Binary(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="14" y="14" width="4" height="6" rx="2"></rect>
+            <rect x="6" y="4" width="4" height="6" rx="2"></rect>
+            <path d="M6 20h4"></path>
+            <path d="M14 10h4"></path>
+            <path d="M6 14h2v6"></path>
+            <path d="M14 4h2v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/binoculars.rs b/packages/leptos/src/binoculars.rs
new file mode 100644
index 0000000..7f3c8bd
--- /dev/null
+++ b/packages/leptos/src/binoculars.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Binoculars(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10h4"></path>
+            <path d="M19 7V4a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v3"></path>
+            <path d="M20 21a2 2 0 0 0 2-2v-3.851c0-1.39-2-2.962-2-4.829V8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v11a2 2 0 0 0 2 2z"></path>
+            <path d="M 22 16 L 2 16"></path>
+            <path d="M4 21a2 2 0 0 1-2-2v-3.851c0-1.39 2-2.962 2-4.829V8a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v11a2 2 0 0 1-2 2z"></path>
+            <path d="M9 7V4a1 1 0 0 0-1-1H6a1 1 0 0 0-1 1v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/biohazard.rs b/packages/leptos/src/biohazard.rs
new file mode 100644
index 0000000..969703d
--- /dev/null
+++ b/packages/leptos/src/biohazard.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Biohazard(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="11.9" r="2"></circle>
+            <path d="M6.7 3.4c-.9 2.5 0 5.2 2.2 6.7C6.5 9 3.7 9.6 2 11.6"></path>
+            <path d="m8.9 10.1 1.4.8"></path>
+            <path d="M17.3 3.4c.9 2.5 0 5.2-2.2 6.7 2.4-1.2 5.2-.6 6.9 1.5"></path>
+            <path d="m15.1 10.1-1.4.8"></path>
+            <path d="M16.7 20.8c-2.6-.4-4.6-2.6-4.7-5.3-.2 2.6-2.1 4.8-4.7 5.2"></path>
+            <path d="M12 13.9v1.6"></path>
+            <path d="M13.5 5.4c-1-.2-2-.2-3 0"></path>
+            <path d="M17 16.4c.7-.7 1.2-1.6 1.5-2.5"></path>
+            <path d="M5.5 13.9c.3.9.8 1.8 1.5 2.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bird.rs b/packages/leptos/src/bird.rs
new file mode 100644
index 0000000..197cf10
--- /dev/null
+++ b/packages/leptos/src/bird.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bird(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 7h.01"></path>
+            <path d="M3.4 18H12a8 8 0 0 0 8-8V7a4 4 0 0 0-7.28-2.3L2 20"></path>
+            <path d="m20 7 2 .5-2 .5"></path>
+            <path d="M10 18v3"></path>
+            <path d="M14 17.75V21"></path>
+            <path d="M7 18a6 6 0 0 0 3.84-10.61"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bitcoin.rs b/packages/leptos/src/bitcoin.rs
new file mode 100644
index 0000000..658cba6
--- /dev/null
+++ b/packages/leptos/src/bitcoin.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bitcoin(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.767 19.089c4.924.868 6.14-6.025 1.216-6.894m-1.216 6.894L5.86 18.047m5.908 1.042-.347 1.97m1.563-8.864c4.924.869 6.14-6.025 1.215-6.893m-1.215 6.893-3.94-.694m5.155-6.2L8.29 4.26m5.908 1.042.348-1.97M7.48 20.364l3.126-17.727"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/blend.rs b/packages/leptos/src/blend.rs
new file mode 100644
index 0000000..7cf6f6a
--- /dev/null
+++ b/packages/leptos/src/blend.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Blend(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="9" cy="9" r="7"></circle>
+            <circle cx="15" cy="15" r="7"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/blinds.rs b/packages/leptos/src/blinds.rs
new file mode 100644
index 0000000..8474558
--- /dev/null
+++ b/packages/leptos/src/blinds.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Blinds(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3h18"></path>
+            <path d="M20 7H8"></path>
+            <path d="M20 11H8"></path>
+            <path d="M10 19h10"></path>
+            <path d="M8 15h12"></path>
+            <path d="M4 3v14"></path>
+            <circle cx="4" cy="19" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/blocks.rs b/packages/leptos/src/blocks.rs
new file mode 100644
index 0000000..3e082ff
--- /dev/null
+++ b/packages/leptos/src/blocks.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Blocks(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="7" x="14" y="3" rx="1"></rect>
+            <path d="M10 21V8a1 1 0 0 0-1-1H4a1 1 0 0 0-1 1v12a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-5a1 1 0 0 0-1-1H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bluetooth.rs b/packages/leptos/src/bluetooth.rs
new file mode 100644
index 0000000..b28196f
--- /dev/null
+++ b/packages/leptos/src/bluetooth.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bluetooth(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 7 10 10-5 5V2l5 5L7 17"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bluetooth_connected.rs b/packages/leptos/src/bluetooth_connected.rs
new file mode 100644
index 0000000..aa70d1d
--- /dev/null
+++ b/packages/leptos/src/bluetooth_connected.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BluetoothConnected(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 7 10 10-5 5V2l5 5L7 17"></path>
+            <line x1="18" x2="21" y1="12" y2="12"></line>
+            <line x1="3" x2="6" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bluetooth_off.rs b/packages/leptos/src/bluetooth_off.rs
new file mode 100644
index 0000000..c15cb78
--- /dev/null
+++ b/packages/leptos/src/bluetooth_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BluetoothOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 17-5 5V12l-5 5"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M14.5 9.5 17 7l-5-5v4.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bluetooth_searching.rs b/packages/leptos/src/bluetooth_searching.rs
new file mode 100644
index 0000000..0995a6f
--- /dev/null
+++ b/packages/leptos/src/bluetooth_searching.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BluetoothSearching(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 7 10 10-5 5V2l5 5L7 17"></path>
+            <path d="M20.83 14.83a4 4 0 0 0 0-5.66"></path>
+            <path d="M18 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bold.rs b/packages/leptos/src/bold.rs
new file mode 100644
index 0000000..8640f6e
--- /dev/null
+++ b/packages/leptos/src/bold.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bold(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bolt.rs b/packages/leptos/src/bolt.rs
new file mode 100644
index 0000000..b599fad
--- /dev/null
+++ b/packages/leptos/src/bolt.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bolt(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"></path>
+            <circle cx="12" cy="12" r="4"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bomb.rs b/packages/leptos/src/bomb.rs
new file mode 100644
index 0000000..89827f8
--- /dev/null
+++ b/packages/leptos/src/bomb.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bomb(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="13" r="9"></circle>
+            <path d="M14.35 4.65 16.3 2.7a2.41 2.41 0 0 1 3.4 0l1.6 1.6a2.4 2.4 0 0 1 0 3.4l-1.95 1.95"></path>
+            <path d="m22 2-1.5 1.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bone.rs b/packages/leptos/src/bone.rs
new file mode 100644
index 0000000..f36a03f
--- /dev/null
+++ b/packages/leptos/src/bone.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 10c.7-.7 1.69 0 2.5 0a2.5 2.5 0 1 0 0-5 .5.5 0 0 1-.5-.5 2.5 2.5 0 1 0-5 0c0 .81.7 1.8 0 2.5l-7 7c-.7.7-1.69 0-2.5 0a2.5 2.5 0 0 0 0 5c.28 0 .5.22.5.5a2.5 2.5 0 1 0 5 0c0-.81-.7-1.8 0-2.5Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book.rs b/packages/leptos/src/book.rs
new file mode 100644
index 0000000..7a34011
--- /dev/null
+++ b/packages/leptos/src/book.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Book(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_a.rs b/packages/leptos/src/book_a.rs
new file mode 100644
index 0000000..6ddaaab
--- /dev/null
+++ b/packages/leptos/src/book_a.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookA(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="m8 13 4-7 4 7"></path>
+            <path d="M9.1 11h5.7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_audio.rs b/packages/leptos/src/book_audio.rs
new file mode 100644
index 0000000..fcf7272
--- /dev/null
+++ b/packages/leptos/src/book_audio.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookAudio(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v7"></path>
+            <path d="M16 8v3"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="M8 8v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_check.rs b/packages/leptos/src/book_check.rs
new file mode 100644
index 0000000..b553da8
--- /dev/null
+++ b/packages/leptos/src/book_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="m9 9.5 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_copy.rs b/packages/leptos/src/book_copy.rs
new file mode 100644
index 0000000..15d82a7
--- /dev/null
+++ b/packages/leptos/src/book_copy.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookCopy(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 16V4a2 2 0 0 1 2-2h11"></path>
+            <path d="M22 18H11a2 2 0 1 0 0 4h10.5a.5.5 0 0 0 .5-.5v-15a.5.5 0 0 0-.5-.5H11a2 2 0 0 0-2 2v12"></path>
+            <path d="M5 14H4a2 2 0 1 0 0 4h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_dashed.rs b/packages/leptos/src/book_dashed.rs
new file mode 100644
index 0000000..5142687
--- /dev/null
+++ b/packages/leptos/src/book_dashed.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17h2"></path>
+            <path d="M12 22h2"></path>
+            <path d="M12 2h2"></path>
+            <path d="M18 22h1a1 1 0 0 0 1-1"></path>
+            <path d="M18 2h1a1 1 0 0 1 1 1v1"></path>
+            <path d="M20 15v2h-2"></path>
+            <path d="M20 8v3"></path>
+            <path d="M4 11V9"></path>
+            <path d="M4 19.5V15"></path>
+            <path d="M4 5v-.5A2.5 2.5 0 0 1 6.5 2H8"></path>
+            <path d="M8 22H6.5a1 1 0 0 1 0-5H8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_down.rs b/packages/leptos/src/book_down.rs
new file mode 100644
index 0000000..86d4a33
--- /dev/null
+++ b/packages/leptos/src/book_down.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V7"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="m9 10 3 3 3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_headphones.rs b/packages/leptos/src/book_headphones.rs
new file mode 100644
index 0000000..add92d4
--- /dev/null
+++ b/packages/leptos/src/book_headphones.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookHeadphones(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="M8 12v-2a4 4 0 0 1 8 0v2"></path>
+            <circle cx="15" cy="12" r="1"></circle>
+            <circle cx="9" cy="12" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_heart.rs b/packages/leptos/src/book_heart.rs
new file mode 100644
index 0000000..89ebcc9
--- /dev/null
+++ b/packages/leptos/src/book_heart.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookHeart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 8.2A2.22 2.22 0 0 0 13.8 6c-.8 0-1.4.3-1.8.9-.4-.6-1-.9-1.8-.9A2.22 2.22 0 0 0 8 8.2c0 .6.3 1.2.7 1.6A226.652 226.652 0 0 0 12 13a404 404 0 0 0 3.3-3.1 2.413 2.413 0 0 0 .7-1.7"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_image.rs b/packages/leptos/src/book_image.rs
new file mode 100644
index 0000000..67fef5c
--- /dev/null
+++ b/packages/leptos/src/book_image.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookImage(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m20 13.7-2.1-2.1a2 2 0 0 0-2.8 0L9.7 17"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <circle cx="10" cy="8" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_key.rs b/packages/leptos/src/book_key.rs
new file mode 100644
index 0000000..e12d28b
--- /dev/null
+++ b/packages/leptos/src/book_key.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookKey(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 3 1 1"></path>
+            <path d="m20 2-4.5 4.5"></path>
+            <path d="M20 8v13a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H14"></path>
+            <circle cx="14" cy="8" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_lock.rs b/packages/leptos/src/book_lock.rs
new file mode 100644
index 0000000..9924c53
--- /dev/null
+++ b/packages/leptos/src/book_lock.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookLock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 6V4a2 2 0 1 0-4 0v2"></path>
+            <path d="M20 15v6a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H10"></path>
+            <rect x="12" y="6" width="8" height="5" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_marked.rs b/packages/leptos/src/book_marked.rs
new file mode 100644
index 0000000..4ddf7cc
--- /dev/null
+++ b/packages/leptos/src/book_marked.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookMarked(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v8l3-3 3 3V2"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_minus.rs b/packages/leptos/src/book_minus.rs
new file mode 100644
index 0000000..75fa28d
--- /dev/null
+++ b/packages/leptos/src/book_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="M9 10h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_open.rs b/packages/leptos/src/book_open.rs
new file mode 100644
index 0000000..b112935
--- /dev/null
+++ b/packages/leptos/src/book_open.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v14"></path>
+            <path d="M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_open_check.rs b/packages/leptos/src/book_open_check.rs
new file mode 100644
index 0000000..e9e3903
--- /dev/null
+++ b/packages/leptos/src/book_open_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookOpenCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 21V7"></path>
+            <path d="m16 12 2 2 4-4"></path>
+            <path d="M22 6V4a1 1 0 0 0-1-1h-5a4 4 0 0 0-4 4 4 4 0 0 0-4-4H3a1 1 0 0 0-1 1v13a1 1 0 0 0 1 1h6a3 3 0 0 1 3 3 3 3 0 0 1 3-3h6a1 1 0 0 0 1-1v-1.3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_open_text.rs b/packages/leptos/src/book_open_text.rs
new file mode 100644
index 0000000..4bfc77b
--- /dev/null
+++ b/packages/leptos/src/book_open_text.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookOpenText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v14"></path>
+            <path d="M16 12h2"></path>
+            <path d="M16 8h2"></path>
+            <path d="M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z"></path>
+            <path d="M6 12h2"></path>
+            <path d="M6 8h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_plus.rs b/packages/leptos/src/book_plus.rs
new file mode 100644
index 0000000..16e8ac8
--- /dev/null
+++ b/packages/leptos/src/book_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v6"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="M9 10h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_text.rs b/packages/leptos/src/book_text.rs
new file mode 100644
index 0000000..0bceddf
--- /dev/null
+++ b/packages/leptos/src/book_text.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="M8 11h8"></path>
+            <path d="M8 7h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_type.rs b/packages/leptos/src/book_type.rs
new file mode 100644
index 0000000..d7e9f2f
--- /dev/null
+++ b/packages/leptos/src/book_type.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookType(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 13h4"></path>
+            <path d="M12 6v7"></path>
+            <path d="M16 8V6H8v2"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_up.rs b/packages/leptos/src/book_up.rs
new file mode 100644
index 0000000..1772659
--- /dev/null
+++ b/packages/leptos/src/book_up.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V7"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="m9 10 3-3 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_up_2.rs b/packages/leptos/src/book_up_2.rs
new file mode 100644
index 0000000..197cf47
--- /dev/null
+++ b/packages/leptos/src/book_up_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookUp2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V7"></path>
+            <path d="M18 2h1a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2"></path>
+            <path d="m9 10 3-3 3 3"></path>
+            <path d="m9 5 3-3 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_user.rs b/packages/leptos/src/book_user.rs
new file mode 100644
index 0000000..9239a26
--- /dev/null
+++ b/packages/leptos/src/book_user.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookUser(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 13a3 3 0 1 0-6 0"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <circle cx="12" cy="8" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/book_x.rs b/packages/leptos/src/book_x.rs
new file mode 100644
index 0000000..8c13ceb
--- /dev/null
+++ b/packages/leptos/src/book_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14.5 7-5 5"></path>
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"></path>
+            <path d="m9.5 7 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bookmark.rs b/packages/leptos/src/bookmark.rs
new file mode 100644
index 0000000..1916146
--- /dev/null
+++ b/packages/leptos/src/bookmark.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bookmark(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bookmark_check.rs b/packages/leptos/src/bookmark_check.rs
new file mode 100644
index 0000000..53f6c49
--- /dev/null
+++ b/packages/leptos/src/bookmark_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookmarkCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2Z"></path>
+            <path d="m9 10 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bookmark_minus.rs b/packages/leptos/src/bookmark_minus.rs
new file mode 100644
index 0000000..36bc0ac
--- /dev/null
+++ b/packages/leptos/src/bookmark_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookmarkMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z"></path>
+            <line x1="15" x2="9" y1="10" y2="10"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bookmark_plus.rs b/packages/leptos/src/bookmark_plus.rs
new file mode 100644
index 0000000..d0e7a50
--- /dev/null
+++ b/packages/leptos/src/bookmark_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookmarkPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z"></path>
+            <line x1="12" x2="12" y1="7" y2="13"></line>
+            <line x1="15" x2="9" y1="10" y2="10"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bookmark_x.rs b/packages/leptos/src/bookmark_x.rs
new file mode 100644
index 0000000..fbe9e5a
--- /dev/null
+++ b/packages/leptos/src/bookmark_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BookmarkX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2Z"></path>
+            <path d="m14.5 7.5-5 5"></path>
+            <path d="m9.5 7.5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/boom_box.rs b/packages/leptos/src/boom_box.rs
new file mode 100644
index 0000000..808f495
--- /dev/null
+++ b/packages/leptos/src/boom_box.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BoomBox(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 9V5a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v4"></path>
+            <path d="M8 8v1"></path>
+            <path d="M12 8v1"></path>
+            <path d="M16 8v1"></path>
+            <rect width="20" height="12" x="2" y="9" rx="2"></rect>
+            <circle cx="8" cy="15" r="2"></circle>
+            <circle cx="16" cy="15" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bot.rs b/packages/leptos/src/bot.rs
new file mode 100644
index 0000000..3164b44
--- /dev/null
+++ b/packages/leptos/src/bot.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 8V4H8"></path>
+            <rect width="16" height="12" x="4" y="8" rx="2"></rect>
+            <path d="M2 14h2"></path>
+            <path d="M20 14h2"></path>
+            <path d="M15 13v2"></path>
+            <path d="M9 13v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bot_message_square.rs b/packages/leptos/src/bot_message_square.rs
new file mode 100644
index 0000000..6fc5768
--- /dev/null
+++ b/packages/leptos/src/bot_message_square.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BotMessageSquare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6V2H8"></path>
+            <path d="m8 18-4 4V8a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2Z"></path>
+            <path d="M2 12h2"></path>
+            <path d="M9 11v2"></path>
+            <path d="M15 11v2"></path>
+            <path d="M20 12h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bot_off.rs b/packages/leptos/src/bot_off.rs
new file mode 100644
index 0000000..310bc8f
--- /dev/null
+++ b/packages/leptos/src/bot_off.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BotOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.67 8H18a2 2 0 0 1 2 2v4.33"></path>
+            <path d="M2 14h2"></path>
+            <path d="M20 14h2"></path>
+            <path d="M22 22 2 2"></path>
+            <path d="M8 8H6a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h12a2 2 0 0 0 1.414-.586"></path>
+            <path d="M9 13v2"></path>
+            <path d="M9.67 4H12v2.33"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/box.rs b/packages/leptos/src/box.rs
new file mode 100644
index 0000000..243227d
--- /dev/null
+++ b/packages/leptos/src/box.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Box(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"></path>
+            <path d="m3.3 7 8.7 5 8.7-5"></path>
+            <path d="M12 22V12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/boxes.rs b/packages/leptos/src/boxes.rs
new file mode 100644
index 0000000..c3c1b5f
--- /dev/null
+++ b/packages/leptos/src/boxes.rs
@@ -0,0 +1,46 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Boxes(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z"></path>
+            <path d="m7 16.5-4.74-2.85"></path>
+            <path d="m7 16.5 5-3"></path>
+            <path d="M7 16.5v5.17"></path>
+            <path d="M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z"></path>
+            <path d="m17 16.5-5-3"></path>
+            <path d="m17 16.5 4.74-2.85"></path>
+            <path d="M17 16.5v5.17"></path>
+            <path d="M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0l-3 1.8Z"></path>
+            <path d="M12 8 7.26 5.15"></path>
+            <path d="m12 8 4.74-2.85"></path>
+            <path d="M12 13.5V8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/braces.rs b/packages/leptos/src/braces.rs
new file mode 100644
index 0000000..9b18cfa
--- /dev/null
+++ b/packages/leptos/src/braces.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Braces(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3H7a2 2 0 0 0-2 2v5a2 2 0 0 1-2 2 2 2 0 0 1 2 2v5c0 1.1.9 2 2 2h1"></path>
+            <path d="M16 21h1a2 2 0 0 0 2-2v-5c0-1.1.9-2 2-2a2 2 0 0 1-2-2V5a2 2 0 0 0-2-2h-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/brackets.rs b/packages/leptos/src/brackets.rs
new file mode 100644
index 0000000..1c045c7
--- /dev/null
+++ b/packages/leptos/src/brackets.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Brackets(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 3h3v18h-3"></path>
+            <path d="M8 21H5V3h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/brain.rs b/packages/leptos/src/brain.rs
new file mode 100644
index 0000000..979ae0a
--- /dev/null
+++ b/packages/leptos/src/brain.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Brain(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z"></path>
+            <path d="M12 5a3 3 0 1 1 5.997.125 4 4 0 0 1 2.526 5.77 4 4 0 0 1-.556 6.588A4 4 0 1 1 12 18Z"></path>
+            <path d="M15 13a4.5 4.5 0 0 1-3-4 4.5 4.5 0 0 1-3 4"></path>
+            <path d="M17.599 6.5a3 3 0 0 0 .399-1.375"></path>
+            <path d="M6.003 5.125A3 3 0 0 0 6.401 6.5"></path>
+            <path d="M3.477 10.896a4 4 0 0 1 .585-.396"></path>
+            <path d="M19.938 10.5a4 4 0 0 1 .585.396"></path>
+            <path d="M6 18a4 4 0 0 1-1.967-.516"></path>
+            <path d="M19.967 17.484A4 4 0 0 1 18 18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/brain_circuit.rs b/packages/leptos/src/brain_circuit.rs
new file mode 100644
index 0000000..8b074aa
--- /dev/null
+++ b/packages/leptos/src/brain_circuit.rs
@@ -0,0 +1,47 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BrainCircuit(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z"></path>
+            <path d="M9 13a4.5 4.5 0 0 0 3-4"></path>
+            <path d="M6.003 5.125A3 3 0 0 0 6.401 6.5"></path>
+            <path d="M3.477 10.896a4 4 0 0 1 .585-.396"></path>
+            <path d="M6 18a4 4 0 0 1-1.967-.516"></path>
+            <path d="M12 13h4"></path>
+            <path d="M12 18h6a2 2 0 0 1 2 2v1"></path>
+            <path d="M12 8h8"></path>
+            <path d="M16 8V5a2 2 0 0 1 2-2"></path>
+            <circle cx="16" cy="13" r=".5"></circle>
+            <circle cx="18" cy="3" r=".5"></circle>
+            <circle cx="20" cy="21" r=".5"></circle>
+            <circle cx="20" cy="8" r=".5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/brain_cog.rs b/packages/leptos/src/brain_cog.rs
new file mode 100644
index 0000000..647a2f1
--- /dev/null
+++ b/packages/leptos/src/brain_cog.rs
@@ -0,0 +1,50 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BrainCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5a3 3 0 1 0-5.997.142 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588 4 4 0 0 0 7.636 2.106 3.2 3.2 0 0 0 .164-.546c.028-.13.306-.13.335 0a3.2 3.2 0 0 0 .163.546 4 4 0 0 0 7.636-2.106 4 4 0 0 0 .556-6.588 4 4 0 0 0-2.526-5.77A3 3 0 1 0 12 5"></path>
+            <path d="M17.599 6.5a3 3 0 0 0 .399-1.375"></path>
+            <path d="M6.003 5.125A3 3 0 0 0 6.401 6.5"></path>
+            <path d="M3.477 10.896a4 4 0 0 1 .585-.396"></path>
+            <path d="M19.938 10.5a4 4 0 0 1 .585.396"></path>
+            <path d="M6 18a4 4 0 0 1-1.967-.516"></path>
+            <path d="M19.967 17.484A4 4 0 0 1 18 18"></path>
+            <circle cx="12" cy="12" r="3"></circle>
+            <path d="m15.7 10.4-.9.4"></path>
+            <path d="m9.2 13.2-.9.4"></path>
+            <path d="m13.6 15.7-.4-.9"></path>
+            <path d="m10.8 9.2-.4-.9"></path>
+            <path d="m15.7 13.5-.9-.4"></path>
+            <path d="m9.2 10.9-.9-.4"></path>
+            <path d="m10.5 15.7.4-.9"></path>
+            <path d="m13.1 9.2.4-.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/brick_wall.rs b/packages/leptos/src/brick_wall.rs
new file mode 100644
index 0000000..730232a
--- /dev/null
+++ b/packages/leptos/src/brick_wall.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BrickWall(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M12 9v6"></path>
+            <path d="M16 15v6"></path>
+            <path d="M16 3v6"></path>
+            <path d="M3 15h18"></path>
+            <path d="M3 9h18"></path>
+            <path d="M8 15v6"></path>
+            <path d="M8 3v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/briefcase.rs b/packages/leptos/src/briefcase.rs
new file mode 100644
index 0000000..9bffb97
--- /dev/null
+++ b/packages/leptos/src/briefcase.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Briefcase(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 20V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16"></path>
+            <rect width="20" height="14" x="2" y="6" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/briefcase_business.rs b/packages/leptos/src/briefcase_business.rs
new file mode 100644
index 0000000..abb1bf9
--- /dev/null
+++ b/packages/leptos/src/briefcase_business.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BriefcaseBusiness(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12h.01"></path>
+            <path d="M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2"></path>
+            <path d="M22 13a18.15 18.15 0 0 1-20 0"></path>
+            <rect width="20" height="14" x="2" y="6" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/briefcase_conveyor_belt.rs b/packages/leptos/src/briefcase_conveyor_belt.rs
new file mode 100644
index 0000000..9e84a5b
--- /dev/null
+++ b/packages/leptos/src/briefcase_conveyor_belt.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BriefcaseConveyorBelt(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 20v2"></path>
+            <path d="M14 20v2"></path>
+            <path d="M18 20v2"></path>
+            <path d="M21 20H3"></path>
+            <path d="M6 20v2"></path>
+            <path d="M8 16V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v12"></path>
+            <rect x="4" y="6" width="16" height="10" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/briefcase_medical.rs b/packages/leptos/src/briefcase_medical.rs
new file mode 100644
index 0000000..ec9f785
--- /dev/null
+++ b/packages/leptos/src/briefcase_medical.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BriefcaseMedical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 11v4"></path>
+            <path d="M14 13h-4"></path>
+            <path d="M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2"></path>
+            <path d="M18 6v14"></path>
+            <path d="M6 6v14"></path>
+            <rect width="20" height="14" x="2" y="6" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bring_to_front.rs b/packages/leptos/src/bring_to_front.rs
new file mode 100644
index 0000000..a14dd35
--- /dev/null
+++ b/packages/leptos/src/bring_to_front.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BringToFront(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="8" y="8" width="8" height="8" rx="2"></rect>
+            <path d="M4 10a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2"></path>
+            <path d="M14 20a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/brush.rs b/packages/leptos/src/brush.rs
new file mode 100644
index 0000000..a3a2983
--- /dev/null
+++ b/packages/leptos/src/brush.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Brush(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9.06 11.9 8.07-8.06a2.85 2.85 0 1 1 4.03 4.03l-8.06 8.08"></path>
+            <path d="M7.07 14.94c-1.66 0-3 1.35-3 3.02 0 1.33-2.5 1.52-2 2.02 1.08 1.1 2.49 2.02 4 2.02 2.2 0 4-1.8 4-4.04a3.01 3.01 0 0 0-3-3.02z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bug.rs b/packages/leptos/src/bug.rs
new file mode 100644
index 0000000..7ccf47b
--- /dev/null
+++ b/packages/leptos/src/bug.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bug(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 2 1.88 1.88"></path>
+            <path d="M14.12 3.88 16 2"></path>
+            <path d="M9 7.13v-1a3.003 3.003 0 1 1 6 0v1"></path>
+            <path d="M12 20c-3.3 0-6-2.7-6-6v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 4v3c0 3.3-2.7 6-6 6"></path>
+            <path d="M12 20v-9"></path>
+            <path d="M6.53 9C4.6 8.8 3 7.1 3 5"></path>
+            <path d="M6 13H2"></path>
+            <path d="M3 21c0-2.1 1.7-3.9 3.8-4"></path>
+            <path d="M20.97 5c0 2.1-1.6 3.8-3.5 4"></path>
+            <path d="M22 13h-4"></path>
+            <path d="M17.2 17c2.1.1 3.8 1.9 3.8 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bug_off.rs b/packages/leptos/src/bug_off.rs
new file mode 100644
index 0000000..af5684d
--- /dev/null
+++ b/packages/leptos/src/bug_off.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BugOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 7.13V6a3 3 0 0 0-5.14-2.1L8 2"></path>
+            <path d="M14.12 3.88 16 2"></path>
+            <path d="M22 13h-4v-2a4 4 0 0 0-4-4h-1.3"></path>
+            <path d="M20.97 5c0 2.1-1.6 3.8-3.5 4"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M7.7 7.7A4 4 0 0 0 6 11v3a6 6 0 0 0 11.13 3.13"></path>
+            <path d="M12 20v-8"></path>
+            <path d="M6 13H2"></path>
+            <path d="M3 21c0-2.1 1.7-3.9 3.8-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bug_play.rs b/packages/leptos/src/bug_play.rs
new file mode 100644
index 0000000..c094f9b
--- /dev/null
+++ b/packages/leptos/src/bug_play.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BugPlay(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.765 21.522a.5.5 0 0 1-.765-.424v-8.196a.5.5 0 0 1 .765-.424l5.878 3.674a1 1 0 0 1 0 1.696z"></path>
+            <path d="M14.12 3.88 16 2"></path>
+            <path d="M18 11a4 4 0 0 0-4-4h-4a4 4 0 0 0-4 4v3a6.1 6.1 0 0 0 2 4.5"></path>
+            <path d="M20.97 5c0 2.1-1.6 3.8-3.5 4"></path>
+            <path d="M3 21c0-2.1 1.7-3.9 3.8-4"></path>
+            <path d="M6 13H2"></path>
+            <path d="M6.53 9C4.6 8.8 3 7.1 3 5"></path>
+            <path d="m8 2 1.88 1.88"></path>
+            <path d="M9 7.13v-1a3.003 3.003 0 1 1 6 0v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/building.rs b/packages/leptos/src/building.rs
new file mode 100644
index 0000000..7c0e3c0
--- /dev/null
+++ b/packages/leptos/src/building.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Building(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="20" x="4" y="2" rx="2" ry="2"></rect>
+            <path d="M9 22v-4h6v4"></path>
+            <path d="M8 6h.01"></path>
+            <path d="M16 6h.01"></path>
+            <path d="M12 6h.01"></path>
+            <path d="M12 10h.01"></path>
+            <path d="M12 14h.01"></path>
+            <path d="M16 10h.01"></path>
+            <path d="M16 14h.01"></path>
+            <path d="M8 10h.01"></path>
+            <path d="M8 14h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/building_2.rs b/packages/leptos/src/building_2.rs
new file mode 100644
index 0000000..690dc9b
--- /dev/null
+++ b/packages/leptos/src/building_2.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Building2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 22V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v18Z"></path>
+            <path d="M6 12H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h2"></path>
+            <path d="M18 9h2a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2h-2"></path>
+            <path d="M10 6h4"></path>
+            <path d="M10 10h4"></path>
+            <path d="M10 14h4"></path>
+            <path d="M10 18h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bus.rs b/packages/leptos/src/bus.rs
new file mode 100644
index 0000000..b41d4de
--- /dev/null
+++ b/packages/leptos/src/bus.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Bus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 6v6"></path>
+            <path d="M15 6v6"></path>
+            <path d="M2 12h19.6"></path>
+            <path d="M18 18h3s.5-1.7.8-2.8c.1-.4.2-.8.2-1.2 0-.4-.1-.8-.2-1.2l-1.4-5C20.1 6.8 19.1 6 18 6H4a2 2 0 0 0-2 2v10h3"></path>
+            <circle cx="7" cy="18" r="2"></circle>
+            <path d="M9 18h5"></path>
+            <circle cx="16" cy="18" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/bus_front.rs b/packages/leptos/src/bus_front.rs
new file mode 100644
index 0000000..a571824
--- /dev/null
+++ b/packages/leptos/src/bus_front.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn BusFront(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 6 2 7"></path>
+            <path d="M10 6h4"></path>
+            <path d="m22 7-2-1"></path>
+            <rect width="16" height="16" x="4" y="3" rx="2"></rect>
+            <path d="M4 11h16"></path>
+            <path d="M8 15h.01"></path>
+            <path d="M16 15h.01"></path>
+            <path d="M6 19v2"></path>
+            <path d="M18 21v-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cable.rs b/packages/leptos/src/cable.rs
new file mode 100644
index 0000000..017acad
--- /dev/null
+++ b/packages/leptos/src/cable.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cable(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 21v-2a1 1 0 0 1-1-1v-1a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1"></path>
+            <path d="M19 15V6.5a1 1 0 0 0-7 0v11a1 1 0 0 1-7 0V9"></path>
+            <path d="M21 21v-2h-4"></path>
+            <path d="M3 5h4V3"></path>
+            <path d="M7 5a1 1 0 0 1 1 1v1a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V6a1 1 0 0 1 1-1V3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cable_car.rs b/packages/leptos/src/cable_car.rs
new file mode 100644
index 0000000..6d4248e
--- /dev/null
+++ b/packages/leptos/src/cable_car.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CableCar(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 3h.01"></path>
+            <path d="M14 2h.01"></path>
+            <path d="m2 9 20-5"></path>
+            <path d="M12 12V6.5"></path>
+            <rect width="16" height="10" x="4" y="12" rx="3"></rect>
+            <path d="M9 12v5"></path>
+            <path d="M15 12v5"></path>
+            <path d="M4 17h16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cake.rs b/packages/leptos/src/cake.rs
new file mode 100644
index 0000000..738ed3f
--- /dev/null
+++ b/packages/leptos/src/cake.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cake(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 21v-8a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v8"></path>
+            <path d="M4 16s.5-1 2-1 2.5 2 4 2 2.5-2 4-2 2.5 2 4 2 2-1 2-1"></path>
+            <path d="M2 21h20"></path>
+            <path d="M7 8v3"></path>
+            <path d="M12 8v3"></path>
+            <path d="M17 8v3"></path>
+            <path d="M7 4h.01"></path>
+            <path d="M12 4h.01"></path>
+            <path d="M17 4h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cake_slice.rs b/packages/leptos/src/cake_slice.rs
new file mode 100644
index 0000000..883bcf2
--- /dev/null
+++ b/packages/leptos/src/cake_slice.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CakeSlice(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="9" cy="7" r="2"></circle>
+            <path d="M7.2 7.9 3 11v9c0 .6.4 1 1 1h16c.6 0 1-.4 1-1v-9c0-2-3-6-7-8l-3.6 2.6"></path>
+            <path d="M16 13H3"></path>
+            <path d="M16 17H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calculator.rs b/packages/leptos/src/calculator.rs
new file mode 100644
index 0000000..6cfa65a
--- /dev/null
+++ b/packages/leptos/src/calculator.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Calculator(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="20" x="4" y="2" rx="2"></rect>
+            <line x1="8" x2="16" y1="6" y2="6"></line>
+            <line x1="16" x2="16" y1="14" y2="18"></line>
+            <path d="M16 10h.01"></path>
+            <path d="M12 10h.01"></path>
+            <path d="M8 10h.01"></path>
+            <path d="M12 14h.01"></path>
+            <path d="M8 14h.01"></path>
+            <path d="M12 18h.01"></path>
+            <path d="M8 18h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar.rs b/packages/leptos/src/calendar.rs
new file mode 100644
index 0000000..f3a64fb
--- /dev/null
+++ b/packages/leptos/src/calendar.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Calendar(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <rect width="18" height="18" x="3" y="4" rx="2"></rect>
+            <path d="M3 10h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_1.rs b/packages/leptos/src/calendar_1.rs
new file mode 100644
index 0000000..f3e9164
--- /dev/null
+++ b/packages/leptos/src/calendar_1.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Calendar1(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 14h1v4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M3 10h18"></path>
+            <path d="M8 2v4"></path>
+            <rect x="3" y="4" width="18" height="18" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_arrow_down.rs b/packages/leptos/src/calendar_arrow_down.rs
new file mode 100644
index 0000000..f528ec7
--- /dev/null
+++ b/packages/leptos/src/calendar_arrow_down.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarArrowDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14 18 4 4 4-4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M18 14v8"></path>
+            <path d="M21 11.354V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7.343"></path>
+            <path d="M3 10h18"></path>
+            <path d="M8 2v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_arrow_up.rs b/packages/leptos/src/calendar_arrow_up.rs
new file mode 100644
index 0000000..e3e7288
--- /dev/null
+++ b/packages/leptos/src/calendar_arrow_up.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarArrowUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14 18 4-4 4 4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M18 22v-8"></path>
+            <path d="M21 11.343V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h9"></path>
+            <path d="M3 10h18"></path>
+            <path d="M8 2v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_check.rs b/packages/leptos/src/calendar_check.rs
new file mode 100644
index 0000000..4b470c9
--- /dev/null
+++ b/packages/leptos/src/calendar_check.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <rect width="18" height="18" x="3" y="4" rx="2"></rect>
+            <path d="M3 10h18"></path>
+            <path d="m9 16 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_check_2.rs b/packages/leptos/src/calendar_check_2.rs
new file mode 100644
index 0000000..e489df8
--- /dev/null
+++ b/packages/leptos/src/calendar_check_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarCheck2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M21 14V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8"></path>
+            <path d="M3 10h18"></path>
+            <path d="m16 20 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_clock.rs b/packages/leptos/src/calendar_clock.rs
new file mode 100644
index 0000000..0eef935
--- /dev/null
+++ b/packages/leptos/src/calendar_clock.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarClock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 7.5V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h3.5"></path>
+            <path d="M16 2v4"></path>
+            <path d="M8 2v4"></path>
+            <path d="M3 10h5"></path>
+            <path d="M17.5 17.5 16 16.3V14"></path>
+            <circle cx="16" cy="16" r="6"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_cog.rs b/packages/leptos/src/calendar_cog.rs
new file mode 100644
index 0000000..534e74a
--- /dev/null
+++ b/packages/leptos/src/calendar_cog.rs
@@ -0,0 +1,47 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15.2 16.9-.9-.4"></path>
+            <path d="m15.2 19.1-.9.4"></path>
+            <path d="M16 2v4"></path>
+            <path d="m16.9 15.2-.4-.9"></path>
+            <path d="m16.9 20.8-.4.9"></path>
+            <path d="m19.5 14.3-.4.9"></path>
+            <path d="m19.5 21.7-.4-.9"></path>
+            <path d="M21 10.5V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6"></path>
+            <path d="m21.7 16.5-.9.4"></path>
+            <path d="m21.7 19.5-.9-.4"></path>
+            <path d="M3 10h18"></path>
+            <path d="M8 2v4"></path>
+            <circle cx="18" cy="18" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_days.rs b/packages/leptos/src/calendar_days.rs
new file mode 100644
index 0000000..ab8e8d6
--- /dev/null
+++ b/packages/leptos/src/calendar_days.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarDays(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <rect width="18" height="18" x="3" y="4" rx="2"></rect>
+            <path d="M3 10h18"></path>
+            <path d="M8 14h.01"></path>
+            <path d="M12 14h.01"></path>
+            <path d="M16 14h.01"></path>
+            <path d="M8 18h.01"></path>
+            <path d="M12 18h.01"></path>
+            <path d="M16 18h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_fold.rs b/packages/leptos/src/calendar_fold.rs
new file mode 100644
index 0000000..922a256
--- /dev/null
+++ b/packages/leptos/src/calendar_fold.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarFold(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M21 17V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h11Z"></path>
+            <path d="M3 10h18"></path>
+            <path d="M15 22v-4a2 2 0 0 1 2-2h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_heart.rs b/packages/leptos/src/calendar_heart.rs
new file mode 100644
index 0000000..d82c69b
--- /dev/null
+++ b/packages/leptos/src/calendar_heart.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarHeart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 10h18V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7"></path>
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M21.29 14.7a2.43 2.43 0 0 0-2.65-.52c-.3.12-.57.3-.8.53l-.34.34-.35-.34a2.43 2.43 0 0 0-2.65-.53c-.3.12-.56.3-.79.53-.95.94-1 2.53.2 3.74L17.5 22l3.6-3.55c1.2-1.21 1.14-2.8.19-3.74Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_minus.rs b/packages/leptos/src/calendar_minus.rs
new file mode 100644
index 0000000..048dc20
--- /dev/null
+++ b/packages/leptos/src/calendar_minus.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 19h6"></path>
+            <path d="M16 2v4"></path>
+            <path d="M21 15V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8.5"></path>
+            <path d="M3 10h18"></path>
+            <path d="M8 2v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_minus_2.rs b/packages/leptos/src/calendar_minus_2.rs
new file mode 100644
index 0000000..6241447
--- /dev/null
+++ b/packages/leptos/src/calendar_minus_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarMinus2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <rect width="18" height="18" x="3" y="4" rx="2"></rect>
+            <path d="M3 10h18"></path>
+            <path d="M10 16h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_off.rs b/packages/leptos/src/calendar_off.rs
new file mode 100644
index 0000000..31250be
--- /dev/null
+++ b/packages/leptos/src/calendar_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.2 4.2A2 2 0 0 0 3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 1.82-1.18"></path>
+            <path d="M21 15.5V6a2 2 0 0 0-2-2H9.5"></path>
+            <path d="M16 2v4"></path>
+            <path d="M3 10h7"></path>
+            <path d="M21 10h-5.5"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_plus.rs b/packages/leptos/src/calendar_plus.rs
new file mode 100644
index 0000000..40cfbf1
--- /dev/null
+++ b/packages/leptos/src/calendar_plus.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M21 13V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8"></path>
+            <path d="M3 10h18"></path>
+            <path d="M16 19h6"></path>
+            <path d="M19 16v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_plus_2.rs b/packages/leptos/src/calendar_plus_2.rs
new file mode 100644
index 0000000..f885a48
--- /dev/null
+++ b/packages/leptos/src/calendar_plus_2.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarPlus2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <rect width="18" height="18" x="3" y="4" rx="2"></rect>
+            <path d="M3 10h18"></path>
+            <path d="M10 16h4"></path>
+            <path d="M12 14v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_range.rs b/packages/leptos/src/calendar_range.rs
new file mode 100644
index 0000000..5bafb0c
--- /dev/null
+++ b/packages/leptos/src/calendar_range.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarRange(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="4" rx="2"></rect>
+            <path d="M16 2v4"></path>
+            <path d="M3 10h18"></path>
+            <path d="M8 2v4"></path>
+            <path d="M17 14h-6"></path>
+            <path d="M13 18H7"></path>
+            <path d="M7 14h.01"></path>
+            <path d="M17 18h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_search.rs b/packages/leptos/src/calendar_search.rs
new file mode 100644
index 0000000..b0c4d65
--- /dev/null
+++ b/packages/leptos/src/calendar_search.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 2v4"></path>
+            <path d="M21 11.75V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7.25"></path>
+            <path d="m22 22-1.875-1.875"></path>
+            <path d="M3 10h18"></path>
+            <path d="M8 2v4"></path>
+            <circle cx="18" cy="18" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_x.rs b/packages/leptos/src/calendar_x.rs
new file mode 100644
index 0000000..0e9de93
--- /dev/null
+++ b/packages/leptos/src/calendar_x.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <rect width="18" height="18" x="3" y="4" rx="2"></rect>
+            <path d="M3 10h18"></path>
+            <path d="m14 14-4 4"></path>
+            <path d="m10 14 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/calendar_x_2.rs b/packages/leptos/src/calendar_x_2.rs
new file mode 100644
index 0000000..e893046
--- /dev/null
+++ b/packages/leptos/src/calendar_x_2.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CalendarX2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M21 13V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8"></path>
+            <path d="M3 10h18"></path>
+            <path d="m17 22 5-5"></path>
+            <path d="m17 17 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/camera.rs b/packages/leptos/src/camera.rs
new file mode 100644
index 0000000..68ac6df
--- /dev/null
+++ b/packages/leptos/src/camera.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Camera(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.5 4h-5L7 7H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-3l-2.5-3z"></path>
+            <circle cx="12" cy="13" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/camera_off.rs b/packages/leptos/src/camera_off.rs
new file mode 100644
index 0000000..d88895e
--- /dev/null
+++ b/packages/leptos/src/camera_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CameraOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+            <path d="M7 7H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h16"></path>
+            <path d="M9.5 4h5L17 7h3a2 2 0 0 1 2 2v7.5"></path>
+            <path d="M14.121 15.121A3 3 0 1 1 9.88 10.88"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/candy.rs b/packages/leptos/src/candy.rs
new file mode 100644
index 0000000..16a14f4
--- /dev/null
+++ b/packages/leptos/src/candy.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Candy(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9.5 7.5-2 2a4.95 4.95 0 1 0 7 7l2-2a4.95 4.95 0 1 0-7-7Z"></path>
+            <path d="M14 6.5v10"></path>
+            <path d="M10 7.5v10"></path>
+            <path d="m16 7 1-5 1.37.68A3 3 0 0 0 19.7 3H21v1.3c0 .46.1.92.32 1.33L22 7l-5 1"></path>
+            <path d="m8 17-1 5-1.37-.68A3 3 0 0 0 4.3 21H3v-1.3a3 3 0 0 0-.32-1.33L2 17l5-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/candy_cane.rs b/packages/leptos/src/candy_cane.rs
new file mode 100644
index 0000000..20a9245
--- /dev/null
+++ b/packages/leptos/src/candy_cane.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CandyCane(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5.7 21a2 2 0 0 1-3.5-2l8.6-14a6 6 0 0 1 10.4 6 2 2 0 1 1-3.464-2 2 2 0 1 0-3.464-2Z"></path>
+            <path d="M17.75 7 15 2.1"></path>
+            <path d="M10.9 4.8 13 9"></path>
+            <path d="m7.9 9.7 2 4.4"></path>
+            <path d="M4.9 14.7 7 18.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/candy_off.rs b/packages/leptos/src/candy_off.rs
new file mode 100644
index 0000000..9e2dab3
--- /dev/null
+++ b/packages/leptos/src/candy_off.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CandyOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8.5 8.5-1 1a4.95 4.95 0 0 0 7 7l1-1"></path>
+            <path d="M11.843 6.187A4.947 4.947 0 0 1 16.5 7.5a4.947 4.947 0 0 1 1.313 4.657"></path>
+            <path d="M14 16.5V14"></path>
+            <path d="M14 6.5v1.843"></path>
+            <path d="M10 10v7.5"></path>
+            <path d="m16 7 1-5 1.367.683A3 3 0 0 0 19.708 3H21v1.292a3 3 0 0 0 .317 1.341L22 7l-5 1"></path>
+            <path d="m8 17-1 5-1.367-.683A3 3 0 0 0 4.292 21H3v-1.292a3 3 0 0 0-.317-1.341L2 17l5-1"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cannabis.rs b/packages/leptos/src/cannabis.rs
new file mode 100644
index 0000000..ab5a96b
--- /dev/null
+++ b/packages/leptos/src/cannabis.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cannabis(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-4"></path>
+            <path d="M7 12c-1.5 0-4.5 1.5-5 3 3.5 1.5 6 1 6 1-1.5 1.5-2 3.5-2 5 2.5 0 4.5-1.5 6-3 1.5 1.5 3.5 3 6 3 0-1.5-.5-3.5-2-5 0 0 2.5.5 6-1-.5-1.5-3.5-3-5-3 1.5-1 4-4 4-6-2.5 0-5.5 1.5-7 3 0-2.5-.5-5-2-7-1.5 2-2 4.5-2 7-1.5-1.5-4.5-3-7-3 0 2 2.5 5 4 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/captions.rs b/packages/leptos/src/captions.rs
new file mode 100644
index 0000000..7a1a58b
--- /dev/null
+++ b/packages/leptos/src/captions.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Captions(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="14" x="3" y="5" rx="2" ry="2"></rect>
+            <path d="M7 15h4M15 15h2M7 11h2M13 11h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/captions_off.rs b/packages/leptos/src/captions_off.rs
new file mode 100644
index 0000000..ceb2a91
--- /dev/null
+++ b/packages/leptos/src/captions_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CaptionsOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.5 5H19a2 2 0 0 1 2 2v8.5"></path>
+            <path d="M17 11h-.5"></path>
+            <path d="M19 19H5a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M7 11h4"></path>
+            <path d="M7 15h2.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/car.rs b/packages/leptos/src/car.rs
new file mode 100644
index 0000000..78f5387
--- /dev/null
+++ b/packages/leptos/src/car.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Car(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 17h2c.6 0 1-.4 1-1v-3c0-.9-.7-1.7-1.5-1.9C18.7 10.6 16 10 16 10s-1.3-1.4-2.2-2.3c-.5-.4-1.1-.7-1.8-.7H5c-.6 0-1.1.4-1.4.9l-1.4 2.9A3.7 3.7 0 0 0 2 12v4c0 .6.4 1 1 1h2"></path>
+            <circle cx="7" cy="17" r="2"></circle>
+            <path d="M9 17h6"></path>
+            <circle cx="17" cy="17" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/car_front.rs b/packages/leptos/src/car_front.rs
new file mode 100644
index 0000000..e042b68
--- /dev/null
+++ b/packages/leptos/src/car_front.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CarFront(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8"></path>
+            <path d="M7 14h.01"></path>
+            <path d="M17 14h.01"></path>
+            <rect width="18" height="8" x="3" y="10" rx="2"></rect>
+            <path d="M5 18v2"></path>
+            <path d="M19 18v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/car_taxi_front.rs b/packages/leptos/src/car_taxi_front.rs
new file mode 100644
index 0000000..0a3c406
--- /dev/null
+++ b/packages/leptos/src/car_taxi_front.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CarTaxiFront(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2h4"></path>
+            <path d="m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8"></path>
+            <path d="M7 14h.01"></path>
+            <path d="M17 14h.01"></path>
+            <rect width="18" height="8" x="3" y="10" rx="2"></rect>
+            <path d="M5 18v2"></path>
+            <path d="M19 18v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/caravan.rs b/packages/leptos/src/caravan.rs
new file mode 100644
index 0000000..bfba14d
--- /dev/null
+++ b/packages/leptos/src/caravan.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Caravan(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 19V9a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v8a2 2 0 0 0 2 2h2"></path>
+            <path d="M2 9h3a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1H2"></path>
+            <path d="M22 17v1a1 1 0 0 1-1 1H10v-9a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v9"></path>
+            <circle cx="8" cy="19" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/carrot.rs b/packages/leptos/src/carrot.rs
new file mode 100644
index 0000000..d7d085e
--- /dev/null
+++ b/packages/leptos/src/carrot.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Carrot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.27 21.7s9.87-3.5 12.73-6.36a4.5 4.5 0 0 0-6.36-6.37C5.77 11.84 2.27 21.7 2.27 21.7zM8.64 14l-2.05-2.04M15.34 15l-2.46-2.46"></path>
+            <path d="M22 9s-1.33-2-3.5-2C16.86 7 15 9 15 9s1.33 2 3.5 2S22 9 22 9z"></path>
+            <path d="M15 2s-2 1.33-2 3.5S15 9 15 9s2-1.84 2-3.5C17 3.33 15 2 15 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/case_lower.rs b/packages/leptos/src/case_lower.rs
new file mode 100644
index 0000000..c8b5994
--- /dev/null
+++ b/packages/leptos/src/case_lower.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CaseLower(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="7" cy="12" r="3"></circle>
+            <path d="M10 9v6"></path>
+            <circle cx="17" cy="12" r="3"></circle>
+            <path d="M14 7v8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/case_sensitive.rs b/packages/leptos/src/case_sensitive.rs
new file mode 100644
index 0000000..c04da14
--- /dev/null
+++ b/packages/leptos/src/case_sensitive.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CaseSensitive(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 15 4-8 4 8"></path>
+            <path d="M4 13h6"></path>
+            <circle cx="18" cy="12" r="3"></circle>
+            <path d="M21 9v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/case_upper.rs b/packages/leptos/src/case_upper.rs
new file mode 100644
index 0000000..a48bcd0
--- /dev/null
+++ b/packages/leptos/src/case_upper.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CaseUpper(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 15 4-8 4 8"></path>
+            <path d="M4 13h6"></path>
+            <path d="M15 11h4.5a2 2 0 0 1 0 4H15V7h4a2 2 0 0 1 0 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cassette_tape.rs b/packages/leptos/src/cassette_tape.rs
new file mode 100644
index 0000000..64b0857
--- /dev/null
+++ b/packages/leptos/src/cassette_tape.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CassetteTape(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+            <circle cx="8" cy="10" r="2"></circle>
+            <path d="M8 12h8"></path>
+            <circle cx="16" cy="10" r="2"></circle>
+            <path d="m6 20 .7-2.9A1.4 1.4 0 0 1 8.1 16h7.8a1.4 1.4 0 0 1 1.4 1l.7 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cast.rs b/packages/leptos/src/cast.rs
new file mode 100644
index 0000000..5510f9d
--- /dev/null
+++ b/packages/leptos/src/cast.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cast(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6"></path>
+            <path d="M2 12a9 9 0 0 1 8 8"></path>
+            <path d="M2 16a5 5 0 0 1 4 4"></path>
+            <line x1="2" x2="2.01" y1="20" y2="20"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/castle.rs b/packages/leptos/src/castle.rs
new file mode 100644
index 0000000..b098dfe
--- /dev/null
+++ b/packages/leptos/src/castle.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Castle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 20v-9H2v9a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2Z"></path>
+            <path d="M18 11V4H6v7"></path>
+            <path d="M15 22v-4a3 3 0 0 0-3-3a3 3 0 0 0-3 3v4"></path>
+            <path d="M22 11V9"></path>
+            <path d="M2 11V9"></path>
+            <path d="M6 4V2"></path>
+            <path d="M18 4V2"></path>
+            <path d="M10 4V2"></path>
+            <path d="M14 4V2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cat.rs b/packages/leptos/src/cat.rs
new file mode 100644
index 0000000..b8fbd4f
--- /dev/null
+++ b/packages/leptos/src/cat.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cat(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5c.67 0 1.35.09 2 .26 1.78-2 5.03-2.84 6.42-2.26 1.4.58-.42 7-.42 7 .57 1.07 1 2.24 1 3.44C21 17.9 16.97 21 12 21s-9-3-9-7.56c0-1.25.5-2.4 1-3.44 0 0-1.89-6.42-.5-7 1.39-.58 4.72.23 6.5 2.23A9.04 9.04 0 0 1 12 5Z"></path>
+            <path d="M8 14v.5"></path>
+            <path d="M16 14v.5"></path>
+            <path d="M11.25 16.25h1.5L12 17l-.75-.75Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cctv.rs b/packages/leptos/src/cctv.rs
new file mode 100644
index 0000000..9a1ea95
--- /dev/null
+++ b/packages/leptos/src/cctv.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cctv(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16.75 12h3.632a1 1 0 0 1 .894 1.447l-2.034 4.069a1 1 0 0 1-1.708.134l-2.124-2.97"></path>
+            <path d="M17.106 9.053a1 1 0 0 1 .447 1.341l-3.106 6.211a1 1 0 0 1-1.342.447L3.61 12.3a2.92 2.92 0 0 1-1.3-3.91L3.69 5.6a2.92 2.92 0 0 1 3.92-1.3z"></path>
+            <path d="M2 19h3.76a2 2 0 0 0 1.8-1.1L9 15"></path>
+            <path d="M2 21v-4"></path>
+            <path d="M7 9h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_area.rs b/packages/leptos/src/chart_area.rs
new file mode 100644
index 0000000..2e109a4
--- /dev/null
+++ b/packages/leptos/src/chart_area.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartArea(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M7 11.207a.5.5 0 0 1 .146-.353l2-2a.5.5 0 0 1 .708 0l3.292 3.292a.5.5 0 0 0 .708 0l4.292-4.292a.5.5 0 0 1 .854.353V16a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_bar.rs b/packages/leptos/src/chart_bar.rs
new file mode 100644
index 0000000..9d1d826
--- /dev/null
+++ b/packages/leptos/src/chart_bar.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartBar(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M7 16h8"></path>
+            <path d="M7 11h12"></path>
+            <path d="M7 6h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_bar_big.rs b/packages/leptos/src/chart_bar_big.rs
new file mode 100644
index 0000000..a387db2
--- /dev/null
+++ b/packages/leptos/src/chart_bar_big.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartBarBig(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <rect x="7" y="13" width="9" height="4" rx="1"></rect>
+            <rect x="7" y="5" width="12" height="4" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_bar_decreasing.rs b/packages/leptos/src/chart_bar_decreasing.rs
new file mode 100644
index 0000000..2cf05a3
--- /dev/null
+++ b/packages/leptos/src/chart_bar_decreasing.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartBarDecreasing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M7 11h8"></path>
+            <path d="M7 16h3"></path>
+            <path d="M7 6h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_bar_increasing.rs b/packages/leptos/src/chart_bar_increasing.rs
new file mode 100644
index 0000000..ba5a518
--- /dev/null
+++ b/packages/leptos/src/chart_bar_increasing.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartBarIncreasing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M7 11h8"></path>
+            <path d="M7 16h12"></path>
+            <path d="M7 6h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_bar_stacked.rs b/packages/leptos/src/chart_bar_stacked.rs
new file mode 100644
index 0000000..2d5f74d
--- /dev/null
+++ b/packages/leptos/src/chart_bar_stacked.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartBarStacked(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 13v4"></path>
+            <path d="M15 5v4"></path>
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <rect x="7" y="13" width="9" height="4" rx="1"></rect>
+            <rect x="7" y="5" width="12" height="4" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_candlestick.rs b/packages/leptos/src/chart_candlestick.rs
new file mode 100644
index 0000000..d766d79
--- /dev/null
+++ b/packages/leptos/src/chart_candlestick.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartCandlestick(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 5v4"></path>
+            <rect width="4" height="6" x="7" y="9" rx="1"></rect>
+            <path d="M9 15v2"></path>
+            <path d="M17 3v2"></path>
+            <rect width="4" height="8" x="15" y="5" rx="1"></rect>
+            <path d="M17 13v3"></path>
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_column.rs b/packages/leptos/src/chart_column.rs
new file mode 100644
index 0000000..43948bd
--- /dev/null
+++ b/packages/leptos/src/chart_column.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartColumn(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M18 17V9"></path>
+            <path d="M13 17V5"></path>
+            <path d="M8 17v-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_column_big.rs b/packages/leptos/src/chart_column_big.rs
new file mode 100644
index 0000000..9fa73e0
--- /dev/null
+++ b/packages/leptos/src/chart_column_big.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartColumnBig(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <rect x="15" y="5" width="4" height="12" rx="1"></rect>
+            <rect x="7" y="8" width="4" height="9" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_column_decreasing.rs b/packages/leptos/src/chart_column_decreasing.rs
new file mode 100644
index 0000000..a1bd26c
--- /dev/null
+++ b/packages/leptos/src/chart_column_decreasing.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartColumnDecreasing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 17V9"></path>
+            <path d="M18 17v-3"></path>
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M8 17V5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_column_increasing.rs b/packages/leptos/src/chart_column_increasing.rs
new file mode 100644
index 0000000..2807ad0
--- /dev/null
+++ b/packages/leptos/src/chart_column_increasing.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartColumnIncreasing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 17V9"></path>
+            <path d="M18 17V5"></path>
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M8 17v-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_column_stacked.rs b/packages/leptos/src/chart_column_stacked.rs
new file mode 100644
index 0000000..6b8e5d5
--- /dev/null
+++ b/packages/leptos/src/chart_column_stacked.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartColumnStacked(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 13H7"></path>
+            <path d="M19 9h-4"></path>
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <rect x="15" y="5" width="4" height="12" rx="1"></rect>
+            <rect x="7" y="8" width="4" height="9" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_gantt.rs b/packages/leptos/src/chart_gantt.rs
new file mode 100644
index 0000000..7382dcc
--- /dev/null
+++ b/packages/leptos/src/chart_gantt.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartGantt(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 6h8"></path>
+            <path d="M12 16h6"></path>
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M8 11h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_line.rs b/packages/leptos/src/chart_line.rs
new file mode 100644
index 0000000..5abc275
--- /dev/null
+++ b/packages/leptos/src/chart_line.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="m19 9-5 5-4-4-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_network.rs b/packages/leptos/src/chart_network.rs
new file mode 100644
index 0000000..a414543
--- /dev/null
+++ b/packages/leptos/src/chart_network.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartNetwork(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m13.11 7.664 1.78 2.672"></path>
+            <path d="m14.162 12.788-3.324 1.424"></path>
+            <path d="m20 4-6.06 1.515"></path>
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <circle cx="12" cy="6" r="2"></circle>
+            <circle cx="16" cy="12" r="2"></circle>
+            <circle cx="9" cy="15" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_no_axes_column.rs b/packages/leptos/src/chart_no_axes_column.rs
new file mode 100644
index 0000000..0311e38
--- /dev/null
+++ b/packages/leptos/src/chart_no_axes_column.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartNoAxesColumn(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="18" x2="18" y1="20" y2="10"></line>
+            <line x1="12" x2="12" y1="20" y2="4"></line>
+            <line x1="6" x2="6" y1="20" y2="14"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_no_axes_column_decreasing.rs b/packages/leptos/src/chart_no_axes_column_decreasing.rs
new file mode 100644
index 0000000..1f4e76b
--- /dev/null
+++ b/packages/leptos/src/chart_no_axes_column_decreasing.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartNoAxesColumnDecreasing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20V10"></path>
+            <path d="M18 20v-4"></path>
+            <path d="M6 20V4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_no_axes_column_increasing.rs b/packages/leptos/src/chart_no_axes_column_increasing.rs
new file mode 100644
index 0000000..1861460
--- /dev/null
+++ b/packages/leptos/src/chart_no_axes_column_increasing.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartNoAxesColumnIncreasing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="12" y1="20" y2="10"></line>
+            <line x1="18" x2="18" y1="20" y2="4"></line>
+            <line x1="6" x2="6" y1="20" y2="16"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_no_axes_combined.rs b/packages/leptos/src/chart_no_axes_combined.rs
new file mode 100644
index 0000000..0b292eb
--- /dev/null
+++ b/packages/leptos/src/chart_no_axes_combined.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartNoAxesCombined(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 16v5"></path>
+            <path d="M16 14v7"></path>
+            <path d="M20 10v11"></path>
+            <path d="m22 3-8.646 8.646a.5.5 0 0 1-.708 0L9.354 8.354a.5.5 0 0 0-.707 0L2 15"></path>
+            <path d="M4 18v3"></path>
+            <path d="M8 14v7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_no_axes_gantt.rs b/packages/leptos/src/chart_no_axes_gantt.rs
new file mode 100644
index 0000000..532b2d4
--- /dev/null
+++ b/packages/leptos/src/chart_no_axes_gantt.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartNoAxesGantt(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 6h10"></path>
+            <path d="M6 12h9"></path>
+            <path d="M11 18h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_pie.rs b/packages/leptos/src/chart_pie.rs
new file mode 100644
index 0000000..dd0b20d
--- /dev/null
+++ b/packages/leptos/src/chart_pie.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartPie(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12c.552 0 1.005-.449.95-.998a10 10 0 0 0-8.953-8.951c-.55-.055-.998.398-.998.95v8a1 1 0 0 0 1 1z"></path>
+            <path d="M21.21 15.89A10 10 0 1 1 8 2.83"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_scatter.rs b/packages/leptos/src/chart_scatter.rs
new file mode 100644
index 0000000..2a01ff9
--- /dev/null
+++ b/packages/leptos/src/chart_scatter.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartScatter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="7.5" cy="7.5" r=".5" fill="currentColor"></circle>
+            <circle cx="18.5" cy="5.5" r=".5" fill="currentColor"></circle>
+            <circle cx="11.5" cy="11.5" r=".5" fill="currentColor"></circle>
+            <circle cx="7.5" cy="16.5" r=".5" fill="currentColor"></circle>
+            <circle cx="17.5" cy="14.5" r=".5" fill="currentColor"></circle>
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chart_spline.rs b/packages/leptos/src/chart_spline.rs
new file mode 100644
index 0000000..e81e756
--- /dev/null
+++ b/packages/leptos/src/chart_spline.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChartSpline(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16"></path>
+            <path d="M7 16c.5-2 1.5-7 4-7 2 0 2 3 4 3 2.5 0 4.5-5 5-7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/check.rs b/packages/leptos/src/check.rs
new file mode 100644
index 0000000..5f670df
--- /dev/null
+++ b/packages/leptos/src/check.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Check(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 6 9 17l-5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/check_check.rs b/packages/leptos/src/check_check.rs
new file mode 100644
index 0000000..0c6043f
--- /dev/null
+++ b/packages/leptos/src/check_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CheckCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 6 7 17l-5-5"></path>
+            <path d="m22 10-7.5 7.5L13 16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chef_hat.rs b/packages/leptos/src/chef_hat.rs
new file mode 100644
index 0000000..1c0d773
--- /dev/null
+++ b/packages/leptos/src/chef_hat.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChefHat(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 21a1 1 0 0 0 1-1v-5.35c0-.457.316-.844.727-1.041a4 4 0 0 0-2.134-7.589 5 5 0 0 0-9.186 0 4 4 0 0 0-2.134 7.588c.411.198.727.585.727 1.041V20a1 1 0 0 0 1 1Z"></path>
+            <path d="M6 17h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cherry.rs b/packages/leptos/src/cherry.rs
new file mode 100644
index 0000000..1c33179
--- /dev/null
+++ b/packages/leptos/src/cherry.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cherry(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 17a5 5 0 0 0 10 0c0-2.76-2.5-5-5-3-2.5-2-5 .24-5 3Z"></path>
+            <path d="M12 17a5 5 0 0 0 10 0c0-2.76-2.5-5-5-3-2.5-2-5 .24-5 3Z"></path>
+            <path d="M7 14c3.22-2.91 4.29-8.75 5-12 1.66 2.38 4.94 9 5 12"></path>
+            <path d="M22 9c-4.29 0-7.14-2.33-10-7 5.71 0 10 4.67 10 7Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevron_down.rs b/packages/leptos/src/chevron_down.rs
new file mode 100644
index 0000000..80a654e
--- /dev/null
+++ b/packages/leptos/src/chevron_down.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 9 6 6 6-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevron_first.rs b/packages/leptos/src/chevron_first.rs
new file mode 100644
index 0000000..dd180e8
--- /dev/null
+++ b/packages/leptos/src/chevron_first.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronFirst(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 18-6-6 6-6"></path>
+            <path d="M7 6v12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevron_last.rs b/packages/leptos/src/chevron_last.rs
new file mode 100644
index 0000000..cc65098
--- /dev/null
+++ b/packages/leptos/src/chevron_last.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronLast(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 18 6-6-6-6"></path>
+            <path d="M17 6v12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevron_left.rs b/packages/leptos/src/chevron_left.rs
new file mode 100644
index 0000000..0443f6e
--- /dev/null
+++ b/packages/leptos/src/chevron_left.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 18-6-6 6-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevron_right.rs b/packages/leptos/src/chevron_right.rs
new file mode 100644
index 0000000..2535368
--- /dev/null
+++ b/packages/leptos/src/chevron_right.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 18 6-6-6-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevron_up.rs b/packages/leptos/src/chevron_up.rs
new file mode 100644
index 0000000..5c86663
--- /dev/null
+++ b/packages/leptos/src/chevron_up.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 15-6-6-6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_down.rs b/packages/leptos/src/chevrons_down.rs
new file mode 100644
index 0000000..83364b9
--- /dev/null
+++ b/packages/leptos/src/chevrons_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 6 5 5 5-5"></path>
+            <path d="m7 13 5 5 5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_down_up.rs b/packages/leptos/src/chevrons_down_up.rs
new file mode 100644
index 0000000..dd7c45c
--- /dev/null
+++ b/packages/leptos/src/chevrons_down_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsDownUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 20 5-5 5 5"></path>
+            <path d="m7 4 5 5 5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_left.rs b/packages/leptos/src/chevrons_left.rs
new file mode 100644
index 0000000..bc3527b
--- /dev/null
+++ b/packages/leptos/src/chevrons_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11 17-5-5 5-5"></path>
+            <path d="m18 17-5-5 5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_left_right.rs b/packages/leptos/src/chevrons_left_right.rs
new file mode 100644
index 0000000..bec608e
--- /dev/null
+++ b/packages/leptos/src/chevrons_left_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsLeftRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 7-5 5 5 5"></path>
+            <path d="m15 7 5 5-5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_left_right_ellipsis.rs b/packages/leptos/src/chevrons_left_right_ellipsis.rs
new file mode 100644
index 0000000..a90fc9d
--- /dev/null
+++ b/packages/leptos/src/chevrons_left_right_ellipsis.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsLeftRightEllipsis(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 8 4 4-4 4"></path>
+            <path d="m6 8-4 4 4 4"></path>
+            <path d="M8 12h.01"></path>
+            <path d="M12 12h.01"></path>
+            <path d="M16 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_right.rs b/packages/leptos/src/chevrons_right.rs
new file mode 100644
index 0000000..2c2348c
--- /dev/null
+++ b/packages/leptos/src/chevrons_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 17 5-5-5-5"></path>
+            <path d="m13 17 5-5-5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_right_left.rs b/packages/leptos/src/chevrons_right_left.rs
new file mode 100644
index 0000000..2d8503b
--- /dev/null
+++ b/packages/leptos/src/chevrons_right_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsRightLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m20 17-5-5 5-5"></path>
+            <path d="m4 17 5-5-5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_up.rs b/packages/leptos/src/chevrons_up.rs
new file mode 100644
index 0000000..cc71261
--- /dev/null
+++ b/packages/leptos/src/chevrons_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 11-5-5-5 5"></path>
+            <path d="m17 18-5-5-5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chevrons_up_down.rs b/packages/leptos/src/chevrons_up_down.rs
new file mode 100644
index 0000000..d01c6e0
--- /dev/null
+++ b/packages/leptos/src/chevrons_up_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ChevronsUpDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 15 5 5 5-5"></path>
+            <path d="m7 9 5-5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/chrome.rs b/packages/leptos/src/chrome.rs
new file mode 100644
index 0000000..0a30f58
--- /dev/null
+++ b/packages/leptos/src/chrome.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Chrome(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <circle cx="12" cy="12" r="4"></circle>
+            <line x1="21.17" x2="12" y1="8" y2="8"></line>
+            <line x1="3.95" x2="8.54" y1="6.06" y2="14"></line>
+            <line x1="10.88" x2="15.46" y1="21.94" y2="14"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/church.rs b/packages/leptos/src/church.rs
new file mode 100644
index 0000000..b5e7dd8
--- /dev/null
+++ b/packages/leptos/src/church.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Church(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9h4"></path>
+            <path d="M12 7v5"></path>
+            <path d="M14 22v-4a2 2 0 0 0-4 0v4"></path>
+            <path d="M18 22V5.618a1 1 0 0 0-.553-.894l-4.553-2.277a2 2 0 0 0-1.788 0L6.553 4.724A1 1 0 0 0 6 5.618V22"></path>
+            <path d="m18 7 3.447 1.724a1 1 0 0 1 .553.894V20a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9.618a1 1 0 0 1 .553-.894L6 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cigarette.rs b/packages/leptos/src/cigarette.rs
new file mode 100644
index 0000000..a4d6fd4
--- /dev/null
+++ b/packages/leptos/src/cigarette.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cigarette(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 12H3a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h14"></path>
+            <path d="M18 8c0-2.5-2-2.5-2-5"></path>
+            <path d="M21 16a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1"></path>
+            <path d="M22 8c0-2.5-2-2.5-2-5"></path>
+            <path d="M7 12v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cigarette_off.rs b/packages/leptos/src/cigarette_off.rs
new file mode 100644
index 0000000..8c4e9c4
--- /dev/null
+++ b/packages/leptos/src/cigarette_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CigaretteOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12H3a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h13"></path>
+            <path d="M18 8c0-2.5-2-2.5-2-5"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M21 12a1 1 0 0 1 1 1v2a1 1 0 0 1-.5.866"></path>
+            <path d="M22 8c0-2.5-2-2.5-2-5"></path>
+            <path d="M7 12v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle.rs b/packages/leptos/src/circle.rs
new file mode 100644
index 0000000..ae8905c
--- /dev/null
+++ b/packages/leptos/src/circle.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Circle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_alert.rs b/packages/leptos/src/circle_alert.rs
new file mode 100644
index 0000000..8b75c75
--- /dev/null
+++ b/packages/leptos/src/circle_alert.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleAlert(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <line x1="12" x2="12" y1="8" y2="12"></line>
+            <line x1="12" x2="12.01" y1="16" y2="16"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_arrow_down.rs b/packages/leptos/src/circle_arrow_down.rs
new file mode 100644
index 0000000..16e7d4a
--- /dev/null
+++ b/packages/leptos/src/circle_arrow_down.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleArrowDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M12 8v8"></path>
+            <path d="m8 12 4 4 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_arrow_left.rs b/packages/leptos/src/circle_arrow_left.rs
new file mode 100644
index 0000000..d7685b2
--- /dev/null
+++ b/packages/leptos/src/circle_arrow_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleArrowLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M16 12H8"></path>
+            <path d="m12 8-4 4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_arrow_out_down_left.rs b/packages/leptos/src/circle_arrow_out_down_left.rs
new file mode 100644
index 0000000..e100468
--- /dev/null
+++ b/packages/leptos/src/circle_arrow_out_down_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleArrowOutDownLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12a10 10 0 1 1 10 10"></path>
+            <path d="m2 22 10-10"></path>
+            <path d="M8 22H2v-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_arrow_out_down_right.rs b/packages/leptos/src/circle_arrow_out_down_right.rs
new file mode 100644
index 0000000..8117f02
--- /dev/null
+++ b/packages/leptos/src/circle_arrow_out_down_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleArrowOutDownRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22a10 10 0 1 1 10-10"></path>
+            <path d="M22 22 12 12"></path>
+            <path d="M22 16v6h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_arrow_out_up_left.rs b/packages/leptos/src/circle_arrow_out_up_left.rs
new file mode 100644
index 0000000..d99866d
--- /dev/null
+++ b/packages/leptos/src/circle_arrow_out_up_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleArrowOutUpLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 8V2h6"></path>
+            <path d="m2 2 10 10"></path>
+            <path d="M12 2A10 10 0 1 1 2 12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_arrow_out_up_right.rs b/packages/leptos/src/circle_arrow_out_up_right.rs
new file mode 100644
index 0000000..f4a2e10
--- /dev/null
+++ b/packages/leptos/src/circle_arrow_out_up_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleArrowOutUpRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12A10 10 0 1 1 12 2"></path>
+            <path d="M22 2 12 12"></path>
+            <path d="M16 2h6v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_arrow_right.rs b/packages/leptos/src/circle_arrow_right.rs
new file mode 100644
index 0000000..3ace9a2
--- /dev/null
+++ b/packages/leptos/src/circle_arrow_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleArrowRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M8 12h8"></path>
+            <path d="m12 16 4-4-4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_arrow_up.rs b/packages/leptos/src/circle_arrow_up.rs
new file mode 100644
index 0000000..bd4da2b
--- /dev/null
+++ b/packages/leptos/src/circle_arrow_up.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleArrowUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m16 12-4-4-4 4"></path>
+            <path d="M12 16V8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_check.rs b/packages/leptos/src/circle_check.rs
new file mode 100644
index 0000000..cf42bb0
--- /dev/null
+++ b/packages/leptos/src/circle_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m9 12 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_check_big.rs b/packages/leptos/src/circle_check_big.rs
new file mode 100644
index 0000000..e50cf67
--- /dev/null
+++ b/packages/leptos/src/circle_check_big.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleCheckBig(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.801 10A10 10 0 1 1 17 3.335"></path>
+            <path d="m9 11 3 3L22 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_chevron_down.rs b/packages/leptos/src/circle_chevron_down.rs
new file mode 100644
index 0000000..f5512da
--- /dev/null
+++ b/packages/leptos/src/circle_chevron_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleChevronDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m16 10-4 4-4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_chevron_left.rs b/packages/leptos/src/circle_chevron_left.rs
new file mode 100644
index 0000000..759db30
--- /dev/null
+++ b/packages/leptos/src/circle_chevron_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleChevronLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m14 16-4-4 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_chevron_right.rs b/packages/leptos/src/circle_chevron_right.rs
new file mode 100644
index 0000000..32b7d83
--- /dev/null
+++ b/packages/leptos/src/circle_chevron_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleChevronRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m10 8 4 4-4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_chevron_up.rs b/packages/leptos/src/circle_chevron_up.rs
new file mode 100644
index 0000000..5f3a3cc
--- /dev/null
+++ b/packages/leptos/src/circle_chevron_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleChevronUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m8 14 4-4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_dashed.rs b/packages/leptos/src/circle_dashed.rs
new file mode 100644
index 0000000..ca17ad5
--- /dev/null
+++ b/packages/leptos/src/circle_dashed.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.1 2.182a10 10 0 0 1 3.8 0"></path>
+            <path d="M13.9 21.818a10 10 0 0 1-3.8 0"></path>
+            <path d="M17.609 3.721a10 10 0 0 1 2.69 2.7"></path>
+            <path d="M2.182 13.9a10 10 0 0 1 0-3.8"></path>
+            <path d="M20.279 17.609a10 10 0 0 1-2.7 2.69"></path>
+            <path d="M21.818 10.1a10 10 0 0 1 0 3.8"></path>
+            <path d="M3.721 6.391a10 10 0 0 1 2.7-2.69"></path>
+            <path d="M6.391 20.279a10 10 0 0 1-2.69-2.7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_divide.rs b/packages/leptos/src/circle_divide.rs
new file mode 100644
index 0000000..c06252d
--- /dev/null
+++ b/packages/leptos/src/circle_divide.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleDivide(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="8" x2="16" y1="12" y2="12"></line>
+            <line x1="12" x2="12" y1="16" y2="16"></line>
+            <line x1="12" x2="12" y1="8" y2="8"></line>
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_dollar_sign.rs b/packages/leptos/src/circle_dollar_sign.rs
new file mode 100644
index 0000000..2f76fff
--- /dev/null
+++ b/packages/leptos/src/circle_dollar_sign.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleDollarSign(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8"></path>
+            <path d="M12 18V6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_dot.rs b/packages/leptos/src/circle_dot.rs
new file mode 100644
index 0000000..54ab2b8
--- /dev/null
+++ b/packages/leptos/src/circle_dot.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <circle cx="12" cy="12" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_dot_dashed.rs b/packages/leptos/src/circle_dot_dashed.rs
new file mode 100644
index 0000000..de0abb5
--- /dev/null
+++ b/packages/leptos/src/circle_dot_dashed.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleDotDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.1 2.18a9.93 9.93 0 0 1 3.8 0"></path>
+            <path d="M17.6 3.71a9.95 9.95 0 0 1 2.69 2.7"></path>
+            <path d="M21.82 10.1a9.93 9.93 0 0 1 0 3.8"></path>
+            <path d="M20.29 17.6a9.95 9.95 0 0 1-2.7 2.69"></path>
+            <path d="M13.9 21.82a9.94 9.94 0 0 1-3.8 0"></path>
+            <path d="M6.4 20.29a9.95 9.95 0 0 1-2.69-2.7"></path>
+            <path d="M2.18 13.9a9.93 9.93 0 0 1 0-3.8"></path>
+            <path d="M3.71 6.4a9.95 9.95 0 0 1 2.7-2.69"></path>
+            <circle cx="12" cy="12" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_ellipsis.rs b/packages/leptos/src/circle_ellipsis.rs
new file mode 100644
index 0000000..277fa40
--- /dev/null
+++ b/packages/leptos/src/circle_ellipsis.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleEllipsis(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M17 12h.01"></path>
+            <path d="M12 12h.01"></path>
+            <path d="M7 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_equal.rs b/packages/leptos/src/circle_equal.rs
new file mode 100644
index 0000000..1674198
--- /dev/null
+++ b/packages/leptos/src/circle_equal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleEqual(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 10h10"></path>
+            <path d="M7 14h10"></path>
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_fading_arrow_up.rs b/packages/leptos/src/circle_fading_arrow_up.rs
new file mode 100644
index 0000000..d589f1f
--- /dev/null
+++ b/packages/leptos/src/circle_fading_arrow_up.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleFadingArrowUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2a10 10 0 0 1 7.38 16.75"></path>
+            <path d="m16 12-4-4-4 4"></path>
+            <path d="M12 16V8"></path>
+            <path d="M2.5 8.875a10 10 0 0 0-.5 3"></path>
+            <path d="M2.83 16a10 10 0 0 0 2.43 3.4"></path>
+            <path d="M4.636 5.235a10 10 0 0 1 .891-.857"></path>
+            <path d="M8.644 21.42a10 10 0 0 0 7.631-.38"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_fading_plus.rs b/packages/leptos/src/circle_fading_plus.rs
new file mode 100644
index 0000000..6615b9b
--- /dev/null
+++ b/packages/leptos/src/circle_fading_plus.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleFadingPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2a10 10 0 0 1 7.38 16.75"></path>
+            <path d="M12 8v8"></path>
+            <path d="M16 12H8"></path>
+            <path d="M2.5 8.875a10 10 0 0 0-.5 3"></path>
+            <path d="M2.83 16a10 10 0 0 0 2.43 3.4"></path>
+            <path d="M4.636 5.235a10 10 0 0 1 .891-.857"></path>
+            <path d="M8.644 21.42a10 10 0 0 0 7.631-.38"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_gauge.rs b/packages/leptos/src/circle_gauge.rs
new file mode 100644
index 0000000..730d991
--- /dev/null
+++ b/packages/leptos/src/circle_gauge.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleGauge(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.6 2.7a10 10 0 1 0 5.7 5.7"></path>
+            <circle cx="12" cy="12" r="2"></circle>
+            <path d="M13.4 10.6 19 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_help.rs b/packages/leptos/src/circle_help.rs
new file mode 100644
index 0000000..fb91f0c
--- /dev/null
+++ b/packages/leptos/src/circle_help.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleHelp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"></path>
+            <path d="M12 17h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_minus.rs b/packages/leptos/src/circle_minus.rs
new file mode 100644
index 0000000..4bdacbe
--- /dev/null
+++ b/packages/leptos/src/circle_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M8 12h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_off.rs b/packages/leptos/src/circle_off.rs
new file mode 100644
index 0000000..dd7ad3e
--- /dev/null
+++ b/packages/leptos/src/circle_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 2 20 20"></path>
+            <path d="M8.35 2.69A10 10 0 0 1 21.3 15.65"></path>
+            <path d="M19.08 19.08A10 10 0 1 1 4.92 4.92"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_parking.rs b/packages/leptos/src/circle_parking.rs
new file mode 100644
index 0000000..9e43bd6
--- /dev/null
+++ b/packages/leptos/src/circle_parking.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleParking(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M9 17V7h4a3 3 0 0 1 0 6H9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_parking_off.rs b/packages/leptos/src/circle_parking_off.rs
new file mode 100644
index 0000000..49b3ada
--- /dev/null
+++ b/packages/leptos/src/circle_parking_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleParkingOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m5 5 14 14"></path>
+            <path d="M13 13a3 3 0 1 0 0-6H9v2"></path>
+            <path d="M9 17v-2.34"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_pause.rs b/packages/leptos/src/circle_pause.rs
new file mode 100644
index 0000000..e25e247
--- /dev/null
+++ b/packages/leptos/src/circle_pause.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CirclePause(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <line x1="10" x2="10" y1="15" y2="9"></line>
+            <line x1="14" x2="14" y1="15" y2="9"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_percent.rs b/packages/leptos/src/circle_percent.rs
new file mode 100644
index 0000000..c596dd8
--- /dev/null
+++ b/packages/leptos/src/circle_percent.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CirclePercent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m15 9-6 6"></path>
+            <path d="M9 9h.01"></path>
+            <path d="M15 15h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_play.rs b/packages/leptos/src/circle_play.rs
new file mode 100644
index 0000000..f3bf35e
--- /dev/null
+++ b/packages/leptos/src/circle_play.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CirclePlay(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polygon points="10 8 16 12 10 16 10 8"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_plus.rs b/packages/leptos/src/circle_plus.rs
new file mode 100644
index 0000000..5525f02
--- /dev/null
+++ b/packages/leptos/src/circle_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CirclePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M8 12h8"></path>
+            <path d="M12 8v8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_power.rs b/packages/leptos/src/circle_power.rs
new file mode 100644
index 0000000..5ad666f
--- /dev/null
+++ b/packages/leptos/src/circle_power.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CirclePower(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v4"></path>
+            <path d="M7.998 9.003a5 5 0 1 0 8-.005"></path>
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_slash.rs b/packages/leptos/src/circle_slash.rs
new file mode 100644
index 0000000..dc9ce7a
--- /dev/null
+++ b/packages/leptos/src/circle_slash.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleSlash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <line x1="9" x2="15" y1="15" y2="9"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_slash_2.rs b/packages/leptos/src/circle_slash_2.rs
new file mode 100644
index 0000000..5578402
--- /dev/null
+++ b/packages/leptos/src/circle_slash_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleSlash2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M22 2 2 22"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_stop.rs b/packages/leptos/src/circle_stop.rs
new file mode 100644
index 0000000..a326537
--- /dev/null
+++ b/packages/leptos/src/circle_stop.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleStop(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <rect x="9" y="9" width="6" height="6" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_user.rs b/packages/leptos/src/circle_user.rs
new file mode 100644
index 0000000..5bc4c7a
--- /dev/null
+++ b/packages/leptos/src/circle_user.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleUser(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <circle cx="12" cy="10" r="3"></circle>
+            <path d="M7 20.662V19a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v1.662"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_user_round.rs b/packages/leptos/src/circle_user_round.rs
new file mode 100644
index 0000000..e18da3e
--- /dev/null
+++ b/packages/leptos/src/circle_user_round.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleUserRound(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 20a6 6 0 0 0-12 0"></path>
+            <circle cx="12" cy="10" r="4"></circle>
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circle_x.rs b/packages/leptos/src/circle_x.rs
new file mode 100644
index 0000000..5013952
--- /dev/null
+++ b/packages/leptos/src/circle_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircleX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m15 9-6 6"></path>
+            <path d="m9 9 6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/circuit_board.rs b/packages/leptos/src/circuit_board.rs
new file mode 100644
index 0000000..2b73a28
--- /dev/null
+++ b/packages/leptos/src/circuit_board.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CircuitBoard(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M11 9h4a2 2 0 0 0 2-2V3"></path>
+            <circle cx="9" cy="9" r="2"></circle>
+            <path d="M7 21v-4a2 2 0 0 1 2-2h4"></path>
+            <circle cx="15" cy="15" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/citrus.rs b/packages/leptos/src/citrus.rs
new file mode 100644
index 0000000..0b0a54b
--- /dev/null
+++ b/packages/leptos/src/citrus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Citrus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.66 17.67a1.08 1.08 0 0 1-.04 1.6A12 12 0 0 1 4.73 2.38a1.1 1.1 0 0 1 1.61-.04z"></path>
+            <path d="M19.65 15.66A8 8 0 0 1 8.35 4.34"></path>
+            <path d="m14 10-5.5 5.5"></path>
+            <path d="M14 17.85V10H6.15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clapperboard.rs b/packages/leptos/src/clapperboard.rs
new file mode 100644
index 0000000..3a2e57c
--- /dev/null
+++ b/packages/leptos/src/clapperboard.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clapperboard(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20.2 6 3 11l-.9-2.4c-.3-1.1.3-2.2 1.3-2.5l13.5-4c1.1-.3 2.2.3 2.5 1.3Z"></path>
+            <path d="m6.2 5.3 3.1 3.9"></path>
+            <path d="m12.4 3.4 3.1 4"></path>
+            <path d="M3 11h18v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard.rs b/packages/leptos/src/clipboard.rs
new file mode 100644
index 0000000..d2da082
--- /dev/null
+++ b/packages/leptos/src/clipboard.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clipboard(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1"></rect>
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_check.rs b/packages/leptos/src/clipboard_check.rs
new file mode 100644
index 0000000..0952155
--- /dev/null
+++ b/packages/leptos/src/clipboard_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1"></rect>
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path>
+            <path d="m9 14 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_copy.rs b/packages/leptos/src/clipboard_copy.rs
new file mode 100644
index 0000000..aff306b
--- /dev/null
+++ b/packages/leptos/src/clipboard_copy.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardCopy(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1"></rect>
+            <path d="M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-2"></path>
+            <path d="M16 4h2a2 2 0 0 1 2 2v4"></path>
+            <path d="M21 14H11"></path>
+            <path d="m15 10-4 4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_list.rs b/packages/leptos/src/clipboard_list.rs
new file mode 100644
index 0000000..906964b
--- /dev/null
+++ b/packages/leptos/src/clipboard_list.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardList(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1"></rect>
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path>
+            <path d="M12 11h4"></path>
+            <path d="M12 16h4"></path>
+            <path d="M8 11h.01"></path>
+            <path d="M8 16h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_minus.rs b/packages/leptos/src/clipboard_minus.rs
new file mode 100644
index 0000000..6766c4b
--- /dev/null
+++ b/packages/leptos/src/clipboard_minus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1"></rect>
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path>
+            <path d="M9 14h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_paste.rs b/packages/leptos/src/clipboard_paste.rs
new file mode 100644
index 0000000..b274fc6
--- /dev/null
+++ b/packages/leptos/src/clipboard_paste.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardPaste(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H9a1 1 0 0 0-1 1v2c0 .6.4 1 1 1h6c.6 0 1-.4 1-1V3c0-.6-.4-1-1-1Z"></path>
+            <path d="M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2M16 4h2a2 2 0 0 1 2 2v2M11 14h10"></path>
+            <path d="m17 10 4 4-4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_pen.rs b/packages/leptos/src/clipboard_pen.rs
new file mode 100644
index 0000000..046bb94
--- /dev/null
+++ b/packages/leptos/src/clipboard_pen.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardPen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1"></rect>
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-5.5"></path>
+            <path d="M4 13.5V6a2 2 0 0 1 2-2h2"></path>
+            <path d="M13.378 15.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_pen_line.rs b/packages/leptos/src/clipboard_pen_line.rs
new file mode 100644
index 0000000..4efd01e
--- /dev/null
+++ b/packages/leptos/src/clipboard_pen_line.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardPenLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1"></rect>
+            <path d="M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-.5"></path>
+            <path d="M16 4h2a2 2 0 0 1 1.73 1"></path>
+            <path d="M8 18h1"></path>
+            <path d="M21.378 12.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_plus.rs b/packages/leptos/src/clipboard_plus.rs
new file mode 100644
index 0000000..7ef18a6
--- /dev/null
+++ b/packages/leptos/src/clipboard_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1"></rect>
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path>
+            <path d="M9 14h6"></path>
+            <path d="M12 17v-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_type.rs b/packages/leptos/src/clipboard_type.rs
new file mode 100644
index 0000000..23546a2
--- /dev/null
+++ b/packages/leptos/src/clipboard_type.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardType(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1"></rect>
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path>
+            <path d="M9 12v-1h6v1"></path>
+            <path d="M11 17h2"></path>
+            <path d="M12 11v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clipboard_x.rs b/packages/leptos/src/clipboard_x.rs
new file mode 100644
index 0000000..30c55e4
--- /dev/null
+++ b/packages/leptos/src/clipboard_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClipboardX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1"></rect>
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path>
+            <path d="m15 11-6 6"></path>
+            <path d="m9 11 6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock.rs b/packages/leptos/src/clock.rs
new file mode 100644
index 0000000..da66b30
--- /dev/null
+++ b/packages/leptos/src/clock.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 16 14"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_1.rs b/packages/leptos/src/clock_1.rs
new file mode 100644
index 0000000..45fcc31
--- /dev/null
+++ b/packages/leptos/src/clock_1.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock1(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 14.5 8"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_10.rs b/packages/leptos/src/clock_10.rs
new file mode 100644
index 0000000..5f5615b
--- /dev/null
+++ b/packages/leptos/src/clock_10.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock10(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 8 10"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_11.rs b/packages/leptos/src/clock_11.rs
new file mode 100644
index 0000000..7e2380e
--- /dev/null
+++ b/packages/leptos/src/clock_11.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock11(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 9.5 8"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_12.rs b/packages/leptos/src/clock_12.rs
new file mode 100644
index 0000000..e6058e6
--- /dev/null
+++ b/packages/leptos/src/clock_12.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock12(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_2.rs b/packages/leptos/src/clock_2.rs
new file mode 100644
index 0000000..a2d9353
--- /dev/null
+++ b/packages/leptos/src/clock_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 16 10"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_3.rs b/packages/leptos/src/clock_3.rs
new file mode 100644
index 0000000..9cc39a0
--- /dev/null
+++ b/packages/leptos/src/clock_3.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 16.5 12"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_4.rs b/packages/leptos/src/clock_4.rs
new file mode 100644
index 0000000..da377f1
--- /dev/null
+++ b/packages/leptos/src/clock_4.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock4(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 16 14"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_5.rs b/packages/leptos/src/clock_5.rs
new file mode 100644
index 0000000..ed2c655
--- /dev/null
+++ b/packages/leptos/src/clock_5.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock5(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 14.5 16"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_6.rs b/packages/leptos/src/clock_6.rs
new file mode 100644
index 0000000..16ad0f4
--- /dev/null
+++ b/packages/leptos/src/clock_6.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock6(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 12 16.5"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_7.rs b/packages/leptos/src/clock_7.rs
new file mode 100644
index 0000000..e72f5e8
--- /dev/null
+++ b/packages/leptos/src/clock_7.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock7(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 9.5 16"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_8.rs b/packages/leptos/src/clock_8.rs
new file mode 100644
index 0000000..dac57da
--- /dev/null
+++ b/packages/leptos/src/clock_8.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock8(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 8 14"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_9.rs b/packages/leptos/src/clock_9.rs
new file mode 100644
index 0000000..4342fb4
--- /dev/null
+++ b/packages/leptos/src/clock_9.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clock9(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <polyline points="12 6 12 12 7.5 12"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_alert.rs b/packages/leptos/src/clock_alert.rs
new file mode 100644
index 0000000..f249366
--- /dev/null
+++ b/packages/leptos/src/clock_alert.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClockAlert(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v6l4 2"></path>
+            <path d="M16 21.16a10 10 0 1 1 5-13.516"></path>
+            <path d="M20 11.5v6"></path>
+            <path d="M20 21.5h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_arrow_down.rs b/packages/leptos/src/clock_arrow_down.rs
new file mode 100644
index 0000000..706989d
--- /dev/null
+++ b/packages/leptos/src/clock_arrow_down.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClockArrowDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.338 21.994A10 10 0 1 1 21.925 13.227"></path>
+            <path d="M12 6v6l2 1"></path>
+            <path d="m14 18 4 4 4-4"></path>
+            <path d="M18 14v8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clock_arrow_up.rs b/packages/leptos/src/clock_arrow_up.rs
new file mode 100644
index 0000000..483fbac
--- /dev/null
+++ b/packages/leptos/src/clock_arrow_up.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ClockArrowUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.228 21.925A10 10 0 1 1 21.994 12.338"></path>
+            <path d="M12 6v6l1.562.781"></path>
+            <path d="m14 18 4-4 4 4"></path>
+            <path d="M18 22v-8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud.rs b/packages/leptos/src/cloud.rs
new file mode 100644
index 0000000..38a83ce
--- /dev/null
+++ b/packages/leptos/src/cloud.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cloud(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_alert.rs b/packages/leptos/src/cloud_alert.rs
new file mode 100644
index 0000000..59df3c5
--- /dev/null
+++ b/packages/leptos/src/cloud_alert.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudAlert(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12v4"></path>
+            <path d="M12 20h.01"></path>
+            <path d="M17 18h.5a1 1 0 0 0 0-9h-1.79A7 7 0 1 0 7 17.708"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_cog.rs b/packages/leptos/src/cloud_cog.rs
new file mode 100644
index 0000000..c9865c4
--- /dev/null
+++ b/packages/leptos/src/cloud_cog.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="17" r="3"></circle>
+            <path d="M4.2 15.1A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.2"></path>
+            <path d="m15.7 18.4-.9-.3"></path>
+            <path d="m9.2 15.9-.9-.3"></path>
+            <path d="m10.6 20.7.3-.9"></path>
+            <path d="m13.1 14.2.3-.9"></path>
+            <path d="m13.6 20.7-.4-1"></path>
+            <path d="m10.8 14.3-.4-1"></path>
+            <path d="m8.3 18.6 1-.4"></path>
+            <path d="m14.7 15.8 1-.4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_download.rs b/packages/leptos/src/cloud_download.rs
new file mode 100644
index 0000000..0c2473d
--- /dev/null
+++ b/packages/leptos/src/cloud_download.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudDownload(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13v8l-4-4"></path>
+            <path d="m12 21 4-4"></path>
+            <path d="M4.393 15.269A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.436 8.284"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_drizzle.rs b/packages/leptos/src/cloud_drizzle.rs
new file mode 100644
index 0000000..6438df7
--- /dev/null
+++ b/packages/leptos/src/cloud_drizzle.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudDrizzle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"></path>
+            <path d="M8 19v1"></path>
+            <path d="M8 14v1"></path>
+            <path d="M16 19v1"></path>
+            <path d="M16 14v1"></path>
+            <path d="M12 21v1"></path>
+            <path d="M12 16v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_fog.rs b/packages/leptos/src/cloud_fog.rs
new file mode 100644
index 0000000..4a46544
--- /dev/null
+++ b/packages/leptos/src/cloud_fog.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudFog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"></path>
+            <path d="M16 17H7"></path>
+            <path d="M17 21H9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_hail.rs b/packages/leptos/src/cloud_hail.rs
new file mode 100644
index 0000000..72520a1
--- /dev/null
+++ b/packages/leptos/src/cloud_hail.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudHail(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"></path>
+            <path d="M16 14v2"></path>
+            <path d="M8 14v2"></path>
+            <path d="M16 20h.01"></path>
+            <path d="M8 20h.01"></path>
+            <path d="M12 16v2"></path>
+            <path d="M12 22h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_lightning.rs b/packages/leptos/src/cloud_lightning.rs
new file mode 100644
index 0000000..b0ae4b6
--- /dev/null
+++ b/packages/leptos/src/cloud_lightning.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudLightning(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 16.326A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 .5 8.973"></path>
+            <path d="m13 12-3 5h4l-3 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_moon.rs b/packages/leptos/src/cloud_moon.rs
new file mode 100644
index 0000000..b549c7b
--- /dev/null
+++ b/packages/leptos/src/cloud_moon.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudMoon(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.188 8.5A6 6 0 0 1 16 4a1 1 0 0 0 6 6 6 6 0 0 1-3 5.197"></path>
+            <path d="M13 16a3 3 0 1 1 0 6H7a5 5 0 1 1 4.9-6Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_moon_rain.rs b/packages/leptos/src/cloud_moon_rain.rs
new file mode 100644
index 0000000..8b23ae9
--- /dev/null
+++ b/packages/leptos/src/cloud_moon_rain.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudMoonRain(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.188 8.5A6 6 0 0 1 16 4a1 1 0 0 0 6 6 6 6 0 0 1-3 5.197"></path>
+            <path d="M11 20v2"></path>
+            <path d="M3 20a5 5 0 1 1 8.9-4H13a3 3 0 0 1 2 5.24"></path>
+            <path d="M7 19v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_off.rs b/packages/leptos/src/cloud_off.rs
new file mode 100644
index 0000000..e25d5c8
--- /dev/null
+++ b/packages/leptos/src/cloud_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 2 20 20"></path>
+            <path d="M5.782 5.782A7 7 0 0 0 9 19h8.5a4.5 4.5 0 0 0 1.307-.193"></path>
+            <path d="M21.532 16.5A4.5 4.5 0 0 0 17.5 10h-1.79A7.008 7.008 0 0 0 10 5.07"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_rain.rs b/packages/leptos/src/cloud_rain.rs
new file mode 100644
index 0000000..8341d24
--- /dev/null
+++ b/packages/leptos/src/cloud_rain.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudRain(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"></path>
+            <path d="M16 14v6"></path>
+            <path d="M8 14v6"></path>
+            <path d="M12 16v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_rain_wind.rs b/packages/leptos/src/cloud_rain_wind.rs
new file mode 100644
index 0000000..2d2ab74
--- /dev/null
+++ b/packages/leptos/src/cloud_rain_wind.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudRainWind(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"></path>
+            <path d="m9.2 22 3-7"></path>
+            <path d="m9 13-3 7"></path>
+            <path d="m17 13-3 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_snow.rs b/packages/leptos/src/cloud_snow.rs
new file mode 100644
index 0000000..f3a1f53
--- /dev/null
+++ b/packages/leptos/src/cloud_snow.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudSnow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"></path>
+            <path d="M8 15h.01"></path>
+            <path d="M8 19h.01"></path>
+            <path d="M12 17h.01"></path>
+            <path d="M12 21h.01"></path>
+            <path d="M16 15h.01"></path>
+            <path d="M16 19h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_sun.rs b/packages/leptos/src/cloud_sun.rs
new file mode 100644
index 0000000..b061379
--- /dev/null
+++ b/packages/leptos/src/cloud_sun.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudSun(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v2"></path>
+            <path d="m4.93 4.93 1.41 1.41"></path>
+            <path d="M20 12h2"></path>
+            <path d="m19.07 4.93-1.41 1.41"></path>
+            <path d="M15.947 12.65a4 4 0 0 0-5.925-4.128"></path>
+            <path d="M13 22H7a5 5 0 1 1 4.9-6H13a3 3 0 0 1 0 6Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_sun_rain.rs b/packages/leptos/src/cloud_sun_rain.rs
new file mode 100644
index 0000000..978e2fe
--- /dev/null
+++ b/packages/leptos/src/cloud_sun_rain.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudSunRain(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v2"></path>
+            <path d="m4.93 4.93 1.41 1.41"></path>
+            <path d="M20 12h2"></path>
+            <path d="m19.07 4.93-1.41 1.41"></path>
+            <path d="M15.947 12.65a4 4 0 0 0-5.925-4.128"></path>
+            <path d="M3 20a5 5 0 1 1 8.9-4H13a3 3 0 0 1 2 5.24"></path>
+            <path d="M11 20v2"></path>
+            <path d="M7 19v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloud_upload.rs b/packages/leptos/src/cloud_upload.rs
new file mode 100644
index 0000000..5a497b0
--- /dev/null
+++ b/packages/leptos/src/cloud_upload.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CloudUpload(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13v8"></path>
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"></path>
+            <path d="m8 17 4-4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cloudy.rs b/packages/leptos/src/cloudy.rs
new file mode 100644
index 0000000..e4433dd
--- /dev/null
+++ b/packages/leptos/src/cloudy.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cloudy(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.5 21H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"></path>
+            <path d="M22 10a3 3 0 0 0-3-3h-2.207a5.502 5.502 0 0 0-10.702.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/clover.rs b/packages/leptos/src/clover.rs
new file mode 100644
index 0000000..169da4e
--- /dev/null
+++ b/packages/leptos/src/clover.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Clover(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16.17 7.83 2 22"></path>
+            <path d="M4.02 12a2.827 2.827 0 1 1 3.81-4.17A2.827 2.827 0 1 1 12 4.02a2.827 2.827 0 1 1 4.17 3.81A2.827 2.827 0 1 1 19.98 12a2.827 2.827 0 1 1-3.81 4.17A2.827 2.827 0 1 1 12 19.98a2.827 2.827 0 1 1-4.17-3.81A1 1 0 1 1 4 12"></path>
+            <path d="m7.83 7.83 8.34 8.34"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/club.rs b/packages/leptos/src/club.rs
new file mode 100644
index 0000000..01e77f8
--- /dev/null
+++ b/packages/leptos/src/club.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Club(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.28 9.05a5.5 5.5 0 1 0-10.56 0A5.5 5.5 0 1 0 12 17.66a5.5 5.5 0 1 0 5.28-8.6Z"></path>
+            <path d="M12 17.66L12 22"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/code.rs b/packages/leptos/src/code.rs
new file mode 100644
index 0000000..a8ee2c3
--- /dev/null
+++ b/packages/leptos/src/code.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Code(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="16 18 22 12 16 6"></polyline>
+            <polyline points="8 6 2 12 8 18"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/code_xml.rs b/packages/leptos/src/code_xml.rs
new file mode 100644
index 0000000..6853c1f
--- /dev/null
+++ b/packages/leptos/src/code_xml.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CodeXml(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 16 4-4-4-4"></path>
+            <path d="m6 8-4 4 4 4"></path>
+            <path d="m14.5 4-5 16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/codepen.rs b/packages/leptos/src/codepen.rs
new file mode 100644
index 0000000..e5a368f
--- /dev/null
+++ b/packages/leptos/src/codepen.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Codepen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2"></polygon>
+            <line x1="12" x2="12" y1="22" y2="15.5"></line>
+            <polyline points="22 8.5 12 15.5 2 8.5"></polyline>
+            <polyline points="2 15.5 12 8.5 22 15.5"></polyline>
+            <line x1="12" x2="12" y1="2" y2="8.5"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/codesandbox.rs b/packages/leptos/src/codesandbox.rs
new file mode 100644
index 0000000..d9e76ca
--- /dev/null
+++ b/packages/leptos/src/codesandbox.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Codesandbox(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"></path>
+            <polyline points="7.5 4.21 12 6.81 16.5 4.21"></polyline>
+            <polyline points="7.5 19.79 7.5 14.6 3 12"></polyline>
+            <polyline points="21 12 16.5 14.6 16.5 19.79"></polyline>
+            <polyline points="3.27 6.96 12 12.01 20.73 6.96"></polyline>
+            <line x1="12" x2="12" y1="22.08" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/coffee.rs b/packages/leptos/src/coffee.rs
new file mode 100644
index 0000000..bc73ad5
--- /dev/null
+++ b/packages/leptos/src/coffee.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Coffee(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v2"></path>
+            <path d="M14 2v2"></path>
+            <path d="M16 8a1 1 0 0 1 1 1v8a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1h14a4 4 0 1 1 0 8h-1"></path>
+            <path d="M6 2v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cog.rs b/packages/leptos/src/cog.rs
new file mode 100644
index 0000000..d864632
--- /dev/null
+++ b/packages/leptos/src/cog.rs
@@ -0,0 +1,48 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20a8 8 0 1 0 0-16 8 8 0 0 0 0 16Z"></path>
+            <path d="M12 14a2 2 0 1 0 0-4 2 2 0 0 0 0 4Z"></path>
+            <path d="M12 2v2"></path>
+            <path d="M12 22v-2"></path>
+            <path d="m17 20.66-1-1.73"></path>
+            <path d="M11 10.27 7 3.34"></path>
+            <path d="m20.66 17-1.73-1"></path>
+            <path d="m3.34 7 1.73 1"></path>
+            <path d="M14 12h8"></path>
+            <path d="M2 12h2"></path>
+            <path d="m20.66 7-1.73 1"></path>
+            <path d="m3.34 17 1.73-1"></path>
+            <path d="m17 3.34-1 1.73"></path>
+            <path d="m11 13.73-4 6.93"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/coins.rs b/packages/leptos/src/coins.rs
new file mode 100644
index 0000000..a5318ad
--- /dev/null
+++ b/packages/leptos/src/coins.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Coins(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="8" cy="8" r="6"></circle>
+            <path d="M18.09 10.37A6 6 0 1 1 10.34 18"></path>
+            <path d="M7 6h1v4"></path>
+            <path d="m16.71 13.88.7.71-2.82 2.82"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/columns_2.rs b/packages/leptos/src/columns_2.rs
new file mode 100644
index 0000000..64b381b
--- /dev/null
+++ b/packages/leptos/src/columns_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Columns2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M12 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/columns_3.rs b/packages/leptos/src/columns_3.rs
new file mode 100644
index 0000000..68c6bab
--- /dev/null
+++ b/packages/leptos/src/columns_3.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Columns3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M9 3v18"></path>
+            <path d="M15 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/columns_4.rs b/packages/leptos/src/columns_4.rs
new file mode 100644
index 0000000..86120c7
--- /dev/null
+++ b/packages/leptos/src/columns_4.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Columns4(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M7.5 3v18"></path>
+            <path d="M12 3v18"></path>
+            <path d="M16.5 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/combine.rs b/packages/leptos/src/combine.rs
new file mode 100644
index 0000000..63c0f33
--- /dev/null
+++ b/packages/leptos/src/combine.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Combine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 18H5a3 3 0 0 1-3-3v-1"></path>
+            <path d="M14 2a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2"></path>
+            <path d="M20 2a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2"></path>
+            <path d="m7 21 3-3-3-3"></path>
+            <rect x="14" y="14" width="8" height="8" rx="2"></rect>
+            <rect x="2" y="2" width="8" height="8" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/command.rs b/packages/leptos/src/command.rs
new file mode 100644
index 0000000..c7ca640
--- /dev/null
+++ b/packages/leptos/src/command.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Command(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 6v12a3 3 0 1 0 3-3H6a3 3 0 1 0 3 3V6a3 3 0 1 0-3 3h12a3 3 0 1 0-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/compass.rs b/packages/leptos/src/compass.rs
new file mode 100644
index 0000000..c5baeeb
--- /dev/null
+++ b/packages/leptos/src/compass.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Compass(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16.24 7.76-1.804 5.411a2 2 0 0 1-1.265 1.265L7.76 16.24l1.804-5.411a2 2 0 0 1 1.265-1.265z"></path>
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/component.rs b/packages/leptos/src/component.rs
new file mode 100644
index 0000000..73ee071
--- /dev/null
+++ b/packages/leptos/src/component.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Component(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.536 11.293a1 1 0 0 0 0 1.414l2.376 2.377a1 1 0 0 0 1.414 0l2.377-2.377a1 1 0 0 0 0-1.414l-2.377-2.377a1 1 0 0 0-1.414 0z"></path>
+            <path d="M2.297 11.293a1 1 0 0 0 0 1.414l2.377 2.377a1 1 0 0 0 1.414 0l2.377-2.377a1 1 0 0 0 0-1.414L6.088 8.916a1 1 0 0 0-1.414 0z"></path>
+            <path d="M8.916 17.912a1 1 0 0 0 0 1.415l2.377 2.376a1 1 0 0 0 1.414 0l2.377-2.376a1 1 0 0 0 0-1.415l-2.377-2.376a1 1 0 0 0-1.414 0z"></path>
+            <path d="M8.916 4.674a1 1 0 0 0 0 1.414l2.377 2.376a1 1 0 0 0 1.414 0l2.377-2.376a1 1 0 0 0 0-1.414l-2.377-2.377a1 1 0 0 0-1.414 0z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/computer.rs b/packages/leptos/src/computer.rs
new file mode 100644
index 0000000..8f0e3af
--- /dev/null
+++ b/packages/leptos/src/computer.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Computer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="8" x="5" y="2" rx="2"></rect>
+            <rect width="20" height="8" x="2" y="14" rx="2"></rect>
+            <path d="M6 18h2"></path>
+            <path d="M12 18h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/concierge_bell.rs b/packages/leptos/src/concierge_bell.rs
new file mode 100644
index 0000000..2fbe34a
--- /dev/null
+++ b/packages/leptos/src/concierge_bell.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ConciergeBell(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 20a1 1 0 0 1-1-1v-1a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1Z"></path>
+            <path d="M20 16a8 8 0 1 0-16 0"></path>
+            <path d="M12 4v4"></path>
+            <path d="M10 4h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cone.rs b/packages/leptos/src/cone.rs
new file mode 100644
index 0000000..aa0eb65
--- /dev/null
+++ b/packages/leptos/src/cone.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m20.9 18.55-8-15.98a1 1 0 0 0-1.8 0l-8 15.98"></path>
+            <ellipse cx="12" cy="19" rx="9" ry="3"></ellipse>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/construction.rs b/packages/leptos/src/construction.rs
new file mode 100644
index 0000000..8c74d25
--- /dev/null
+++ b/packages/leptos/src/construction.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Construction(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="2" y="6" width="20" height="8" rx="1"></rect>
+            <path d="M17 14v7"></path>
+            <path d="M7 14v7"></path>
+            <path d="M17 3v3"></path>
+            <path d="M7 3v3"></path>
+            <path d="M10 14 2.3 6.3"></path>
+            <path d="m14 6 7.7 7.7"></path>
+            <path d="m8 6 8 8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/contact.rs b/packages/leptos/src/contact.rs
new file mode 100644
index 0000000..90b53a1
--- /dev/null
+++ b/packages/leptos/src/contact.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Contact(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 2v2"></path>
+            <path d="M7 22v-2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v2"></path>
+            <path d="M8 2v2"></path>
+            <circle cx="12" cy="11" r="3"></circle>
+            <rect x="3" y="4" width="18" height="18" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/contact_round.rs b/packages/leptos/src/contact_round.rs
new file mode 100644
index 0000000..25aee14
--- /dev/null
+++ b/packages/leptos/src/contact_round.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ContactRound(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 2v2"></path>
+            <path d="M17.915 22a6 6 0 0 0-12 0"></path>
+            <path d="M8 2v2"></path>
+            <circle cx="12" cy="12" r="4"></circle>
+            <rect x="3" y="4" width="18" height="18" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/container.rs b/packages/leptos/src/container.rs
new file mode 100644
index 0000000..f15458f
--- /dev/null
+++ b/packages/leptos/src/container.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Container(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 7.7c0-.6-.4-1.2-.8-1.5l-6.3-3.9a1.72 1.72 0 0 0-1.7 0l-10.3 6c-.5.2-.9.8-.9 1.4v6.6c0 .5.4 1.2.8 1.5l6.3 3.9a1.72 1.72 0 0 0 1.7 0l10.3-6c.5-.3.9-1 .9-1.5Z"></path>
+            <path d="M10 21.9V14L2.1 9.1"></path>
+            <path d="m10 14 11.9-6.9"></path>
+            <path d="M14 19.8v-8.1"></path>
+            <path d="M18 17.5V9.4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/contrast.rs b/packages/leptos/src/contrast.rs
new file mode 100644
index 0000000..792f8fa
--- /dev/null
+++ b/packages/leptos/src/contrast.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Contrast(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M12 18a6 6 0 0 0 0-12v12z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cookie.rs b/packages/leptos/src/cookie.rs
new file mode 100644
index 0000000..b8a3888
--- /dev/null
+++ b/packages/leptos/src/cookie.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cookie(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2a10 10 0 1 0 10 10 4 4 0 0 1-5-5 4 4 0 0 1-5-5"></path>
+            <path d="M8.5 8.5v.01"></path>
+            <path d="M16 15.5v.01"></path>
+            <path d="M12 12v.01"></path>
+            <path d="M11 17v.01"></path>
+            <path d="M7 14v.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cooking_pot.rs b/packages/leptos/src/cooking_pot.rs
new file mode 100644
index 0000000..f5db30a
--- /dev/null
+++ b/packages/leptos/src/cooking_pot.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CookingPot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12h20"></path>
+            <path d="M20 12v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-8"></path>
+            <path d="m4 8 16-4"></path>
+            <path d="m8.86 6.78-.45-1.81a2 2 0 0 1 1.45-2.43l1.94-.48a2 2 0 0 1 2.43 1.46l.45 1.8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/copy.rs b/packages/leptos/src/copy.rs
new file mode 100644
index 0000000..c46bfd6
--- /dev/null
+++ b/packages/leptos/src/copy.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Copy(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2"></rect>
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/copy_check.rs b/packages/leptos/src/copy_check.rs
new file mode 100644
index 0000000..abe368b
--- /dev/null
+++ b/packages/leptos/src/copy_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CopyCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 15 2 2 4-4"></path>
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2"></rect>
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/copy_minus.rs b/packages/leptos/src/copy_minus.rs
new file mode 100644
index 0000000..fee2e5b
--- /dev/null
+++ b/packages/leptos/src/copy_minus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CopyMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="18" y1="15" y2="15"></line>
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2"></rect>
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/copy_plus.rs b/packages/leptos/src/copy_plus.rs
new file mode 100644
index 0000000..0522a3e
--- /dev/null
+++ b/packages/leptos/src/copy_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CopyPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="15" x2="15" y1="12" y2="18"></line>
+            <line x1="12" x2="18" y1="15" y2="15"></line>
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2"></rect>
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/copy_slash.rs b/packages/leptos/src/copy_slash.rs
new file mode 100644
index 0000000..5377fe1
--- /dev/null
+++ b/packages/leptos/src/copy_slash.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CopySlash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="18" y1="18" y2="12"></line>
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2"></rect>
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/copy_x.rs b/packages/leptos/src/copy_x.rs
new file mode 100644
index 0000000..900d79e
--- /dev/null
+++ b/packages/leptos/src/copy_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CopyX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="18" y1="12" y2="18"></line>
+            <line x1="12" x2="18" y1="18" y2="12"></line>
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2"></rect>
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/copyleft.rs b/packages/leptos/src/copyleft.rs
new file mode 100644
index 0000000..cd60f0b
--- /dev/null
+++ b/packages/leptos/src/copyleft.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Copyleft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M9.17 14.83a4 4 0 1 0 0-5.66"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/copyright.rs b/packages/leptos/src/copyright.rs
new file mode 100644
index 0000000..96d740d
--- /dev/null
+++ b/packages/leptos/src/copyright.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Copyright(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M14.83 14.83a4 4 0 1 1 0-5.66"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/corner_down_left.rs b/packages/leptos/src/corner_down_left.rs
new file mode 100644
index 0000000..937ffd9
--- /dev/null
+++ b/packages/leptos/src/corner_down_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CornerDownLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="9 10 4 15 9 20"></polyline>
+            <path d="M20 4v7a4 4 0 0 1-4 4H4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/corner_down_right.rs b/packages/leptos/src/corner_down_right.rs
new file mode 100644
index 0000000..24b7a43
--- /dev/null
+++ b/packages/leptos/src/corner_down_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CornerDownRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="15 10 20 15 15 20"></polyline>
+            <path d="M4 4v7a4 4 0 0 0 4 4h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/corner_left_down.rs b/packages/leptos/src/corner_left_down.rs
new file mode 100644
index 0000000..3abe2db
--- /dev/null
+++ b/packages/leptos/src/corner_left_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CornerLeftDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="14 15 9 20 4 15"></polyline>
+            <path d="M20 4h-7a4 4 0 0 0-4 4v12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/corner_left_up.rs b/packages/leptos/src/corner_left_up.rs
new file mode 100644
index 0000000..cff12ed
--- /dev/null
+++ b/packages/leptos/src/corner_left_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CornerLeftUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="14 9 9 4 4 9"></polyline>
+            <path d="M20 20h-7a4 4 0 0 1-4-4V4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/corner_right_down.rs b/packages/leptos/src/corner_right_down.rs
new file mode 100644
index 0000000..054d4df
--- /dev/null
+++ b/packages/leptos/src/corner_right_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CornerRightDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="10 15 15 20 20 15"></polyline>
+            <path d="M4 4h7a4 4 0 0 1 4 4v12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/corner_right_up.rs b/packages/leptos/src/corner_right_up.rs
new file mode 100644
index 0000000..454c013
--- /dev/null
+++ b/packages/leptos/src/corner_right_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CornerRightUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="10 9 15 4 20 9"></polyline>
+            <path d="M4 20h7a4 4 0 0 0 4-4V4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/corner_up_left.rs b/packages/leptos/src/corner_up_left.rs
new file mode 100644
index 0000000..1eeb948
--- /dev/null
+++ b/packages/leptos/src/corner_up_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CornerUpLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="9 14 4 9 9 4"></polyline>
+            <path d="M20 20v-7a4 4 0 0 0-4-4H4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/corner_up_right.rs b/packages/leptos/src/corner_up_right.rs
new file mode 100644
index 0000000..1969f77
--- /dev/null
+++ b/packages/leptos/src/corner_up_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CornerUpRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="15 14 20 9 15 4"></polyline>
+            <path d="M4 20v-7a4 4 0 0 1 4-4h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cpu.rs b/packages/leptos/src/cpu.rs
new file mode 100644
index 0000000..3521ae1
--- /dev/null
+++ b/packages/leptos/src/cpu.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cpu(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="16" x="4" y="4" rx="2"></rect>
+            <rect width="6" height="6" x="9" y="9" rx="1"></rect>
+            <path d="M15 2v2"></path>
+            <path d="M15 20v2"></path>
+            <path d="M2 15h2"></path>
+            <path d="M2 9h2"></path>
+            <path d="M20 15h2"></path>
+            <path d="M20 9h2"></path>
+            <path d="M9 2v2"></path>
+            <path d="M9 20v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/creative_commons.rs b/packages/leptos/src/creative_commons.rs
new file mode 100644
index 0000000..f2b7a94
--- /dev/null
+++ b/packages/leptos/src/creative_commons.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CreativeCommons(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M10 9.3a2.8 2.8 0 0 0-3.5 1 3.1 3.1 0 0 0 0 3.4 2.7 2.7 0 0 0 3.5 1"></path>
+            <path d="M17 9.3a2.8 2.8 0 0 0-3.5 1 3.1 3.1 0 0 0 0 3.4 2.7 2.7 0 0 0 3.5 1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/credit_card.rs b/packages/leptos/src/credit_card.rs
new file mode 100644
index 0000000..080001e
--- /dev/null
+++ b/packages/leptos/src/credit_card.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CreditCard(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="14" x="2" y="5" rx="2"></rect>
+            <line x1="2" x2="22" y1="10" y2="10"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/croissant.rs b/packages/leptos/src/croissant.rs
new file mode 100644
index 0000000..b465322
--- /dev/null
+++ b/packages/leptos/src/croissant.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Croissant(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4.6 13.11 5.79-3.21c1.89-1.05 4.79 1.78 3.71 3.71l-3.22 5.81C8.8 23.16.79 15.23 4.6 13.11Z"></path>
+            <path d="m10.5 9.5-1-2.29C9.2 6.48 8.8 6 8 6H4.5C2.79 6 2 6.5 2 8.5a7.71 7.71 0 0 0 2 4.83"></path>
+            <path d="M8 6c0-1.55.24-4-2-4-2 0-2.5 2.17-2.5 4"></path>
+            <path d="m14.5 13.5 2.29 1c.73.3 1.21.7 1.21 1.5v3.5c0 1.71-.5 2.5-2.5 2.5a7.71 7.71 0 0 1-4.83-2"></path>
+            <path d="M18 16c1.55 0 4-.24 4 2 0 2-2.17 2.5-4 2.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/crop.rs b/packages/leptos/src/crop.rs
new file mode 100644
index 0000000..80cb563
--- /dev/null
+++ b/packages/leptos/src/crop.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Crop(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 2v14a2 2 0 0 0 2 2h14"></path>
+            <path d="M18 22V8a2 2 0 0 0-2-2H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cross.rs b/packages/leptos/src/cross.rs
new file mode 100644
index 0000000..8d5df70
--- /dev/null
+++ b/packages/leptos/src/cross.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cross(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 9a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h4a1 1 0 0 1 1 1v4a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-4a1 1 0 0 1 1-1h4a2 2 0 0 0 2-2v-2a2 2 0 0 0-2-2h-4a1 1 0 0 1-1-1V4a2 2 0 0 0-2-2h-2a2 2 0 0 0-2 2v4a1 1 0 0 1-1 1z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/crosshair.rs b/packages/leptos/src/crosshair.rs
new file mode 100644
index 0000000..f78a970
--- /dev/null
+++ b/packages/leptos/src/crosshair.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Crosshair(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <line x1="22" x2="18" y1="12" y2="12"></line>
+            <line x1="6" x2="2" y1="12" y2="12"></line>
+            <line x1="12" x2="12" y1="6" y2="2"></line>
+            <line x1="12" x2="12" y1="22" y2="18"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/crown.rs b/packages/leptos/src/crown.rs
new file mode 100644
index 0000000..dc7218e
--- /dev/null
+++ b/packages/leptos/src/crown.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Crown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.562 3.266a.5.5 0 0 1 .876 0L15.39 8.87a1 1 0 0 0 1.516.294L21.183 5.5a.5.5 0 0 1 .798.519l-2.834 10.246a1 1 0 0 1-.956.734H5.81a1 1 0 0 1-.957-.734L2.02 6.02a.5.5 0 0 1 .798-.519l4.276 3.664a1 1 0 0 0 1.516-.294z"></path>
+            <path d="M5 21h14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cuboid.rs b/packages/leptos/src/cuboid.rs
new file mode 100644
index 0000000..c65be0c
--- /dev/null
+++ b/packages/leptos/src/cuboid.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cuboid(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21.12 6.4-6.05-4.06a2 2 0 0 0-2.17-.05L2.95 8.41a2 2 0 0 0-.95 1.7v5.82a2 2 0 0 0 .88 1.66l6.05 4.07a2 2 0 0 0 2.17.05l9.95-6.12a2 2 0 0 0 .95-1.7V8.06a2 2 0 0 0-.88-1.66Z"></path>
+            <path d="M10 22v-8L2.25 9.15"></path>
+            <path d="m10 14 11.77-6.87"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cup_soda.rs b/packages/leptos/src/cup_soda.rs
new file mode 100644
index 0000000..4731858
--- /dev/null
+++ b/packages/leptos/src/cup_soda.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn CupSoda(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 8 1.75 12.28a2 2 0 0 0 2 1.72h4.54a2 2 0 0 0 2-1.72L18 8"></path>
+            <path d="M5 8h14"></path>
+            <path d="M7 15a6.47 6.47 0 0 1 5 0 6.47 6.47 0 0 0 5 0"></path>
+            <path d="m12 8 1-6h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/currency.rs b/packages/leptos/src/currency.rs
new file mode 100644
index 0000000..2641e24
--- /dev/null
+++ b/packages/leptos/src/currency.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Currency(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="8"></circle>
+            <line x1="3" x2="6" y1="3" y2="6"></line>
+            <line x1="21" x2="18" y1="3" y2="6"></line>
+            <line x1="3" x2="6" y1="21" y2="18"></line>
+            <line x1="21" x2="18" y1="21" y2="18"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/cylinder.rs b/packages/leptos/src/cylinder.rs
new file mode 100644
index 0000000..a4ad40b
--- /dev/null
+++ b/packages/leptos/src/cylinder.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Cylinder(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
+            <path d="M3 5v14a9 3 0 0 0 18 0V5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dam.rs b/packages/leptos/src/dam.rs
new file mode 100644
index 0000000..71df641
--- /dev/null
+++ b/packages/leptos/src/dam.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dam(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 11.31c1.17.56 1.54 1.69 3.5 1.69 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"></path>
+            <path d="M11.75 18c.35.5 1.45 1 2.75 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"></path>
+            <path d="M2 10h4"></path>
+            <path d="M2 14h4"></path>
+            <path d="M2 18h4"></path>
+            <path d="M2 6h4"></path>
+            <path d="M7 3a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h4a1 1 0 0 0 1-1L10 4a1 1 0 0 0-1-1z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/database.rs b/packages/leptos/src/database.rs
new file mode 100644
index 0000000..39ec453
--- /dev/null
+++ b/packages/leptos/src/database.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Database(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
+            <path d="M3 5V19A9 3 0 0 0 21 19V5"></path>
+            <path d="M3 12A9 3 0 0 0 21 12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/database_backup.rs b/packages/leptos/src/database_backup.rs
new file mode 100644
index 0000000..a624ee4
--- /dev/null
+++ b/packages/leptos/src/database_backup.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DatabaseBackup(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
+            <path d="M3 12a9 3 0 0 0 5 2.69"></path>
+            <path d="M21 9.3V5"></path>
+            <path d="M3 5v14a9 3 0 0 0 6.47 2.88"></path>
+            <path d="M12 12v4h4"></path>
+            <path d="M13 20a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L12 16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/database_zap.rs b/packages/leptos/src/database_zap.rs
new file mode 100644
index 0000000..26768bd
--- /dev/null
+++ b/packages/leptos/src/database_zap.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DatabaseZap(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
+            <path d="M3 5V19A9 3 0 0 0 15 21.84"></path>
+            <path d="M21 5V8"></path>
+            <path d="M21 12L18 17H22L19 22"></path>
+            <path d="M3 12A9 3 0 0 0 14.59 14.87"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/delete.rs b/packages/leptos/src/delete.rs
new file mode 100644
index 0000000..d90b92f
--- /dev/null
+++ b/packages/leptos/src/delete.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Delete(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 5a2 2 0 0 0-1.344.519l-6.328 5.74a1 1 0 0 0 0 1.481l6.328 5.741A2 2 0 0 0 10 19h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2z"></path>
+            <path d="m12 9 6 6"></path>
+            <path d="m18 9-6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dessert.rs b/packages/leptos/src/dessert.rs
new file mode 100644
index 0000000..6e8d8b2
--- /dev/null
+++ b/packages/leptos/src/dessert.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dessert(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="4" r="2"></circle>
+            <path d="M10.2 3.2C5.5 4 2 8.1 2 13a2 2 0 0 0 4 0v-1a2 2 0 0 1 4 0v4a2 2 0 0 0 4 0v-4a2 2 0 0 1 4 0v1a2 2 0 0 0 4 0c0-4.9-3.5-9-8.2-9.8"></path>
+            <path d="M3.2 14.8a9 9 0 0 0 17.6 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/diameter.rs b/packages/leptos/src/diameter.rs
new file mode 100644
index 0000000..ae2eb8c
--- /dev/null
+++ b/packages/leptos/src/diameter.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Diameter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="19" cy="19" r="2"></circle>
+            <circle cx="5" cy="5" r="2"></circle>
+            <path d="M6.48 3.66a10 10 0 0 1 13.86 13.86"></path>
+            <path d="m6.41 6.41 11.18 11.18"></path>
+            <path d="M3.66 6.48a10 10 0 0 0 13.86 13.86"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/diamond.rs b/packages/leptos/src/diamond.rs
new file mode 100644
index 0000000..238fd4e
--- /dev/null
+++ b/packages/leptos/src/diamond.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Diamond(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41l-7.59-7.59a2.41 2.41 0 0 0-3.41 0Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/diamond_minus.rs b/packages/leptos/src/diamond_minus.rs
new file mode 100644
index 0000000..59d5b22
--- /dev/null
+++ b/packages/leptos/src/diamond_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DiamondMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0z"></path>
+            <path d="M8 12h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/diamond_percent.rs b/packages/leptos/src/diamond_percent.rs
new file mode 100644
index 0000000..bbf1974
--- /dev/null
+++ b/packages/leptos/src/diamond_percent.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DiamondPercent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0Z"></path>
+            <path d="M9.2 9.2h.01"></path>
+            <path d="m14.5 9.5-5 5"></path>
+            <path d="M14.7 14.8h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/diamond_plus.rs b/packages/leptos/src/diamond_plus.rs
new file mode 100644
index 0000000..1c19103
--- /dev/null
+++ b/packages/leptos/src/diamond_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DiamondPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 8v8"></path>
+            <path d="M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0z"></path>
+            <path d="M8 12h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dice_1.rs b/packages/leptos/src/dice_1.rs
new file mode 100644
index 0000000..a1c83fa
--- /dev/null
+++ b/packages/leptos/src/dice_1.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dice1(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <path d="M12 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dice_2.rs b/packages/leptos/src/dice_2.rs
new file mode 100644
index 0000000..c694e81
--- /dev/null
+++ b/packages/leptos/src/dice_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dice2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <path d="M15 9h.01"></path>
+            <path d="M9 15h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dice_3.rs b/packages/leptos/src/dice_3.rs
new file mode 100644
index 0000000..b2c49a3
--- /dev/null
+++ b/packages/leptos/src/dice_3.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dice3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <path d="M16 8h.01"></path>
+            <path d="M12 12h.01"></path>
+            <path d="M8 16h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dice_4.rs b/packages/leptos/src/dice_4.rs
new file mode 100644
index 0000000..2246e6d
--- /dev/null
+++ b/packages/leptos/src/dice_4.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dice4(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <path d="M16 8h.01"></path>
+            <path d="M8 8h.01"></path>
+            <path d="M8 16h.01"></path>
+            <path d="M16 16h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dice_5.rs b/packages/leptos/src/dice_5.rs
new file mode 100644
index 0000000..9220b1a
--- /dev/null
+++ b/packages/leptos/src/dice_5.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dice5(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <path d="M16 8h.01"></path>
+            <path d="M8 8h.01"></path>
+            <path d="M8 16h.01"></path>
+            <path d="M16 16h.01"></path>
+            <path d="M12 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dice_6.rs b/packages/leptos/src/dice_6.rs
new file mode 100644
index 0000000..320c285
--- /dev/null
+++ b/packages/leptos/src/dice_6.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dice6(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <path d="M16 8h.01"></path>
+            <path d="M16 12h.01"></path>
+            <path d="M16 16h.01"></path>
+            <path d="M8 8h.01"></path>
+            <path d="M8 12h.01"></path>
+            <path d="M8 16h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dices.rs b/packages/leptos/src/dices.rs
new file mode 100644
index 0000000..a9cd8c3
--- /dev/null
+++ b/packages/leptos/src/dices.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dices(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="12" height="12" x="2" y="10" rx="2" ry="2"></rect>
+            <path d="m17.92 14 3.5-3.5a2.24 2.24 0 0 0 0-3l-5-4.92a2.24 2.24 0 0 0-3 0L10 6"></path>
+            <path d="M6 18h.01"></path>
+            <path d="M10 14h.01"></path>
+            <path d="M15 6h.01"></path>
+            <path d="M18 9h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/diff.rs b/packages/leptos/src/diff.rs
new file mode 100644
index 0000000..f0648a2
--- /dev/null
+++ b/packages/leptos/src/diff.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Diff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v14"></path>
+            <path d="M5 10h14"></path>
+            <path d="M5 21h14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/disc.rs b/packages/leptos/src/disc.rs
new file mode 100644
index 0000000..af1f5f5
--- /dev/null
+++ b/packages/leptos/src/disc.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Disc(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <circle cx="12" cy="12" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/disc_2.rs b/packages/leptos/src/disc_2.rs
new file mode 100644
index 0000000..f17aa2c
--- /dev/null
+++ b/packages/leptos/src/disc_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Disc2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <circle cx="12" cy="12" r="4"></circle>
+            <path d="M12 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/disc_3.rs b/packages/leptos/src/disc_3.rs
new file mode 100644
index 0000000..16d055d
--- /dev/null
+++ b/packages/leptos/src/disc_3.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Disc3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M6 12c0-1.7.7-3.2 1.8-4.2"></path>
+            <circle cx="12" cy="12" r="2"></circle>
+            <path d="M18 12c0 1.7-.7 3.2-1.8 4.2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/disc_album.rs b/packages/leptos/src/disc_album.rs
new file mode 100644
index 0000000..a06db89
--- /dev/null
+++ b/packages/leptos/src/disc_album.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DiscAlbum(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <circle cx="12" cy="12" r="5"></circle>
+            <path d="M12 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/divide.rs b/packages/leptos/src/divide.rs
new file mode 100644
index 0000000..b549856
--- /dev/null
+++ b/packages/leptos/src/divide.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Divide(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="6" r="1"></circle>
+            <line x1="5" x2="19" y1="12" y2="12"></line>
+            <circle cx="12" cy="18" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dna.rs b/packages/leptos/src/dna.rs
new file mode 100644
index 0000000..fe8f494
--- /dev/null
+++ b/packages/leptos/src/dna.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dna(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10 16 1.5 1.5"></path>
+            <path d="m14 8-1.5-1.5"></path>
+            <path d="M15 2c-1.798 1.998-2.518 3.995-2.807 5.993"></path>
+            <path d="m16.5 10.5 1 1"></path>
+            <path d="m17 6-2.891-2.891"></path>
+            <path d="M2 15c6.667-6 13.333 0 20-6"></path>
+            <path d="m20 9 .891.891"></path>
+            <path d="M3.109 14.109 4 15"></path>
+            <path d="m6.5 12.5 1 1"></path>
+            <path d="m7 18 2.891 2.891"></path>
+            <path d="M9 22c1.798-1.998 2.518-3.995 2.807-5.993"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dna_off.rs b/packages/leptos/src/dna_off.rs
new file mode 100644
index 0000000..c74fe86
--- /dev/null
+++ b/packages/leptos/src/dna_off.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DnaOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2c-1.35 1.5-2.092 3-2.5 4.5L14 8"></path>
+            <path d="m17 6-2.891-2.891"></path>
+            <path d="M2 15c3.333-3 6.667-3 10-3"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="m20 9 .891.891"></path>
+            <path d="M22 9c-1.5 1.35-3 2.092-4.5 2.5l-1-1"></path>
+            <path d="M3.109 14.109 4 15"></path>
+            <path d="m6.5 12.5 1 1"></path>
+            <path d="m7 18 2.891 2.891"></path>
+            <path d="M9 22c1.35-1.5 2.092-3 2.5-4.5L10 16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dock.rs b/packages/leptos/src/dock.rs
new file mode 100644
index 0000000..aa639be
--- /dev/null
+++ b/packages/leptos/src/dock.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 8h20"></path>
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+            <path d="M6 16h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dog.rs b/packages/leptos/src/dog.rs
new file mode 100644
index 0000000..2dc742f
--- /dev/null
+++ b/packages/leptos/src/dog.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.25 16.25h1.5L12 17z"></path>
+            <path d="M16 14v.5"></path>
+            <path d="M4.42 11.247A13.152 13.152 0 0 0 4 14.556C4 18.728 7.582 21 12 21s8-2.272 8-6.444a11.702 11.702 0 0 0-.493-3.309"></path>
+            <path d="M8 14v.5"></path>
+            <path d="M8.5 8.5c-.384 1.05-1.083 2.028-2.344 2.5-1.931.722-3.576-.297-3.656-1-.113-.994 1.177-6.53 4-7 1.923-.321 3.651.845 3.651 2.235A7.497 7.497 0 0 1 14 5.277c0-1.39 1.844-2.598 3.767-2.277 2.823.47 4.113 6.006 4 7-.08.703-1.725 1.722-3.656 1-1.261-.472-1.855-1.45-2.239-2.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dollar_sign.rs b/packages/leptos/src/dollar_sign.rs
new file mode 100644
index 0000000..a321726
--- /dev/null
+++ b/packages/leptos/src/dollar_sign.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DollarSign(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="12" y1="2" y2="22"></line>
+            <path d="M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/donut.rs b/packages/leptos/src/donut.rs
new file mode 100644
index 0000000..70617cf
--- /dev/null
+++ b/packages/leptos/src/donut.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Donut(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20.5 10a2.5 2.5 0 0 1-2.4-3H18a2.95 2.95 0 0 1-2.6-4.4 10 10 0 1 0 6.3 7.1c-.3.2-.8.3-1.2.3"></path>
+            <circle cx="12" cy="12" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/door_closed.rs b/packages/leptos/src/door_closed.rs
new file mode 100644
index 0000000..797c639
--- /dev/null
+++ b/packages/leptos/src/door_closed.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DoorClosed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 20V6a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v14"></path>
+            <path d="M2 20h20"></path>
+            <path d="M14 12v.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/door_open.rs b/packages/leptos/src/door_open.rs
new file mode 100644
index 0000000..028bbd3
--- /dev/null
+++ b/packages/leptos/src/door_open.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DoorOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 4h3a2 2 0 0 1 2 2v14"></path>
+            <path d="M2 20h3"></path>
+            <path d="M13 20h9"></path>
+            <path d="M10 12v.01"></path>
+            <path d="M13 4.562v16.157a1 1 0 0 1-1.242.97L5 20V5.562a2 2 0 0 1 1.515-1.94l4-1A2 2 0 0 1 13 4.561Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dot.rs b/packages/leptos/src/dot.rs
new file mode 100644
index 0000000..c3080c3
--- /dev/null
+++ b/packages/leptos/src/dot.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12.1" cy="12.1" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/download.rs b/packages/leptos/src/download.rs
new file mode 100644
index 0000000..9450f0c
--- /dev/null
+++ b/packages/leptos/src/download.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Download(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path>
+            <polyline points="7 10 12 15 17 10"></polyline>
+            <line x1="12" x2="12" y1="15" y2="3"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/drafting_compass.rs b/packages/leptos/src/drafting_compass.rs
new file mode 100644
index 0000000..29e7aae
--- /dev/null
+++ b/packages/leptos/src/drafting_compass.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn DraftingCompass(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12.99 6.74 1.93 3.44"></path>
+            <path d="M19.136 12a10 10 0 0 1-14.271 0"></path>
+            <path d="m21 21-2.16-3.84"></path>
+            <path d="m3 21 8.02-14.26"></path>
+            <circle cx="12" cy="5" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/drama.rs b/packages/leptos/src/drama.rs
new file mode 100644
index 0000000..f2daf80
--- /dev/null
+++ b/packages/leptos/src/drama.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Drama(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 11h.01"></path>
+            <path d="M14 6h.01"></path>
+            <path d="M18 6h.01"></path>
+            <path d="M6.5 13.1h.01"></path>
+            <path d="M22 5c0 9-4 12-6 12s-6-3-6-12c0-2 2-3 6-3s6 1 6 3"></path>
+            <path d="M17.4 9.9c-.8.8-2 .8-2.8 0"></path>
+            <path d="M10.1 7.1C9 7.2 7.7 7.7 6 8.6c-3.5 2-4.7 3.9-3.7 5.6 4.5 7.8 9.5 8.4 11.2 7.4.9-.5 1.9-2.1 1.9-4.7"></path>
+            <path d="M9.1 16.5c.3-1.1 1.4-1.7 2.4-1.4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dribbble.rs b/packages/leptos/src/dribbble.rs
new file mode 100644
index 0000000..2361dab
--- /dev/null
+++ b/packages/leptos/src/dribbble.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dribbble(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M19.13 5.09C15.22 9.14 10 10.44 2.25 10.94"></path>
+            <path d="M21.75 12.84c-6.62-1.41-12.14 1-16.38 6.32"></path>
+            <path d="M8.56 2.75c4.37 6 6 9.42 8 17.72"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/drill.rs b/packages/leptos/src/drill.rs
new file mode 100644
index 0000000..18b377b
--- /dev/null
+++ b/packages/leptos/src/drill.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Drill(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 18a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1H5a3 3 0 0 1-3-3 1 1 0 0 1 1-1z"></path>
+            <path d="M13 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a1 1 0 0 1 1 1v6a1 1 0 0 1-1 1l-.81 3.242a1 1 0 0 1-.97.758H8"></path>
+            <path d="M14 4h3a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1h-3"></path>
+            <path d="M18 6h4"></path>
+            <path d="m5 10-2 8"></path>
+            <path d="m7 18 2-8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/droplet.rs b/packages/leptos/src/droplet.rs
new file mode 100644
index 0000000..8c22592
--- /dev/null
+++ b/packages/leptos/src/droplet.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Droplet(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22a7 7 0 0 0 7-7c0-2-1-3.9-3-5.5s-3.5-4-4-6.5c-.5 2.5-2 4.9-4 6.5C6 11.1 5 13 5 15a7 7 0 0 0 7 7z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/droplets.rs b/packages/leptos/src/droplets.rs
new file mode 100644
index 0000000..3cd67b3
--- /dev/null
+++ b/packages/leptos/src/droplets.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Droplets(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 16.3c2.2 0 4-1.83 4-4.05 0-1.16-.57-2.26-1.71-3.19S7.29 6.75 7 5.3c-.29 1.45-1.14 2.84-2.29 3.76S3 11.1 3 12.25c0 2.22 1.8 4.05 4 4.05z"></path>
+            <path d="M12.56 6.6A10.97 10.97 0 0 0 14 3.02c.5 2.5 2 4.9 4 6.5s3 3.5 3 5.5a6.98 6.98 0 0 1-11.91 4.97"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/drum.rs b/packages/leptos/src/drum.rs
new file mode 100644
index 0000000..1aa8ef2
--- /dev/null
+++ b/packages/leptos/src/drum.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Drum(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 2 8 8"></path>
+            <path d="m22 2-8 8"></path>
+            <ellipse cx="12" cy="9" rx="10" ry="5"></ellipse>
+            <path d="M7 13.4v7.9"></path>
+            <path d="M12 14v8"></path>
+            <path d="M17 13.4v7.9"></path>
+            <path d="M2 9v8a10 5 0 0 0 20 0V9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/drumstick.rs b/packages/leptos/src/drumstick.rs
new file mode 100644
index 0000000..4fdb71e
--- /dev/null
+++ b/packages/leptos/src/drumstick.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Drumstick(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.4 15.63a7.875 6 135 1 1 6.23-6.23 4.5 3.43 135 0 0-6.23 6.23"></path>
+            <path d="m8.29 12.71-2.6 2.6a2.5 2.5 0 1 0-1.65 4.65A2.5 2.5 0 1 0 8.7 18.3l2.59-2.59"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/dumbbell.rs b/packages/leptos/src/dumbbell.rs
new file mode 100644
index 0000000..f68fe2f
--- /dev/null
+++ b/packages/leptos/src/dumbbell.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Dumbbell(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.4 14.4 9.6 9.6"></path>
+            <path d="M18.657 21.485a2 2 0 1 1-2.829-2.828l-1.767 1.768a2 2 0 1 1-2.829-2.829l6.364-6.364a2 2 0 1 1 2.829 2.829l-1.768 1.767a2 2 0 1 1 2.828 2.829z"></path>
+            <path d="m21.5 21.5-1.4-1.4"></path>
+            <path d="M3.9 3.9 2.5 2.5"></path>
+            <path d="M6.404 12.768a2 2 0 1 1-2.829-2.829l1.768-1.767a2 2 0 1 1-2.828-2.829l2.828-2.828a2 2 0 1 1 2.829 2.828l1.767-1.768a2 2 0 1 1 2.829 2.829z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ear.rs b/packages/leptos/src/ear.rs
new file mode 100644
index 0000000..0ad290b
--- /dev/null
+++ b/packages/leptos/src/ear.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ear(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8.5a6.5 6.5 0 1 1 13 0c0 6-6 6-6 10a3.5 3.5 0 1 1-7 0"></path>
+            <path d="M15 8.5a2.5 2.5 0 0 0-5 0v1a2 2 0 1 1 0 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ear_off.rs b/packages/leptos/src/ear_off.rs
new file mode 100644
index 0000000..cd0ac9d
--- /dev/null
+++ b/packages/leptos/src/ear_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EarOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 18.5a3.5 3.5 0 1 0 7 0c0-1.57.92-2.52 2.04-3.46"></path>
+            <path d="M6 8.5c0-.75.13-1.47.36-2.14"></path>
+            <path d="M8.8 3.15A6.5 6.5 0 0 1 19 8.5c0 1.63-.44 2.81-1.09 3.76"></path>
+            <path d="M12.5 6A2.5 2.5 0 0 1 15 8.5M10 13a2 2 0 0 0 1.82-1.18"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/earth.rs b/packages/leptos/src/earth.rs
new file mode 100644
index 0000000..5a1dc9a
--- /dev/null
+++ b/packages/leptos/src/earth.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Earth(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.54 15H17a2 2 0 0 0-2 2v4.54"></path>
+            <path d="M7 3.34V5a3 3 0 0 0 3 3a2 2 0 0 1 2 2c0 1.1.9 2 2 2a2 2 0 0 0 2-2c0-1.1.9-2 2-2h3.17"></path>
+            <path d="M11 21.95V18a2 2 0 0 0-2-2a2 2 0 0 1-2-2v-1a2 2 0 0 0-2-2H2.05"></path>
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/earth_lock.rs b/packages/leptos/src/earth_lock.rs
new file mode 100644
index 0000000..36d6dff
--- /dev/null
+++ b/packages/leptos/src/earth_lock.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EarthLock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 3.34V5a3 3 0 0 0 3 3"></path>
+            <path d="M11 21.95V18a2 2 0 0 0-2-2 2 2 0 0 1-2-2v-1a2 2 0 0 0-2-2H2.05"></path>
+            <path d="M21.54 15H17a2 2 0 0 0-2 2v4.54"></path>
+            <path d="M12 2a10 10 0 1 0 9.54 13"></path>
+            <path d="M20 6V4a2 2 0 1 0-4 0v2"></path>
+            <rect width="8" height="5" x="14" y="6" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/eclipse.rs b/packages/leptos/src/eclipse.rs
new file mode 100644
index 0000000..214f4c3
--- /dev/null
+++ b/packages/leptos/src/eclipse.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Eclipse(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M12 2a7 7 0 1 0 10 10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/egg.rs b/packages/leptos/src/egg.rs
new file mode 100644
index 0000000..9517ec9
--- /dev/null
+++ b/packages/leptos/src/egg.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Egg(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22c6.23-.05 7.87-5.57 7.5-10-.36-4.34-3.95-9.96-7.5-10-3.55.04-7.14 5.66-7.5 10-.37 4.43 1.27 9.95 7.5 10z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/egg_fried.rs b/packages/leptos/src/egg_fried.rs
new file mode 100644
index 0000000..6519c6e
--- /dev/null
+++ b/packages/leptos/src/egg_fried.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EggFried(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11.5" cy="12.5" r="3.5"></circle>
+            <path d="M3 8c0-3.5 2.5-6 6.5-6 5 0 4.83 3 7.5 5s5 2 5 6c0 4.5-2.5 6.5-7 6.5-2.5 0-2.5 2.5-6 2.5s-7-2-7-5.5c0-3 1.5-3 1.5-5C3.5 10 3 9 3 8Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/egg_off.rs b/packages/leptos/src/egg_off.rs
new file mode 100644
index 0000000..fdb28da
--- /dev/null
+++ b/packages/leptos/src/egg_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EggOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6.399 6.399C5.362 8.157 4.65 10.189 4.5 12c-.37 4.43 1.27 9.95 7.5 10 3.256-.026 5.259-1.547 6.375-3.625"></path>
+            <path d="M19.532 13.875A14.07 14.07 0 0 0 19.5 12c-.36-4.34-3.95-9.96-7.5-10-1.04.012-2.082.502-3.046 1.297"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ellipsis.rs b/packages/leptos/src/ellipsis.rs
new file mode 100644
index 0000000..22e6abd
--- /dev/null
+++ b/packages/leptos/src/ellipsis.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ellipsis(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="1"></circle>
+            <circle cx="19" cy="12" r="1"></circle>
+            <circle cx="5" cy="12" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ellipsis_vertical.rs b/packages/leptos/src/ellipsis_vertical.rs
new file mode 100644
index 0000000..b834c53
--- /dev/null
+++ b/packages/leptos/src/ellipsis_vertical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EllipsisVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="1"></circle>
+            <circle cx="12" cy="5" r="1"></circle>
+            <circle cx="12" cy="19" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/equal.rs b/packages/leptos/src/equal.rs
new file mode 100644
index 0000000..800a139
--- /dev/null
+++ b/packages/leptos/src/equal.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Equal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="5" x2="19" y1="9" y2="9"></line>
+            <line x1="5" x2="19" y1="15" y2="15"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/equal_approximately.rs b/packages/leptos/src/equal_approximately.rs
new file mode 100644
index 0000000..cffd909
--- /dev/null
+++ b/packages/leptos/src/equal_approximately.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EqualApproximately(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 15a6.5 6.5 0 0 1 7 0 6.5 6.5 0 0 0 7 0"></path>
+            <path d="M5 9a6.5 6.5 0 0 1 7 0 6.5 6.5 0 0 0 7 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/equal_not.rs b/packages/leptos/src/equal_not.rs
new file mode 100644
index 0000000..4a315ae
--- /dev/null
+++ b/packages/leptos/src/equal_not.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EqualNot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="5" x2="19" y1="9" y2="9"></line>
+            <line x1="5" x2="19" y1="15" y2="15"></line>
+            <line x1="19" x2="5" y1="5" y2="19"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/eraser.rs b/packages/leptos/src/eraser.rs
new file mode 100644
index 0000000..7b2c564
--- /dev/null
+++ b/packages/leptos/src/eraser.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Eraser(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 21-4.3-4.3c-1-1-1-2.5 0-3.4l9.6-9.6c1-1 2.5-1 3.4 0l5.6 5.6c1 1 1 2.5 0 3.4L13 21"></path>
+            <path d="M22 21H7"></path>
+            <path d="m5 11 9 9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ethernet_port.rs b/packages/leptos/src/ethernet_port.rs
new file mode 100644
index 0000000..0a6e3e1
--- /dev/null
+++ b/packages/leptos/src/ethernet_port.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EthernetPort(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3z"></path>
+            <path d="M6 8v1"></path>
+            <path d="M10 8v1"></path>
+            <path d="M14 8v1"></path>
+            <path d="M18 8v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/euro.rs b/packages/leptos/src/euro.rs
new file mode 100644
index 0000000..e880fb7
--- /dev/null
+++ b/packages/leptos/src/euro.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Euro(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10h12"></path>
+            <path d="M4 14h9"></path>
+            <path d="M19 6a7.7 7.7 0 0 0-5.2-2A7.9 7.9 0 0 0 6 12c0 4.4 3.5 8 7.8 8 2 0 3.8-.8 5.2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/expand.rs b/packages/leptos/src/expand.rs
new file mode 100644
index 0000000..7442cd1
--- /dev/null
+++ b/packages/leptos/src/expand.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Expand(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21 21-6-6m6 6v-4.8m0 4.8h-4.8"></path>
+            <path d="M3 16.2V21m0 0h4.8M3 21l6-6"></path>
+            <path d="M21 7.8V3m0 0h-4.8M21 3l-6 6"></path>
+            <path d="M3 7.8V3m0 0h4.8M3 3l6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/external_link.rs b/packages/leptos/src/external_link.rs
new file mode 100644
index 0000000..bcf52a7
--- /dev/null
+++ b/packages/leptos/src/external_link.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ExternalLink(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 3h6v6"></path>
+            <path d="M10 14 21 3"></path>
+            <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/eye.rs b/packages/leptos/src/eye.rs
new file mode 100644
index 0000000..7f5e450
--- /dev/null
+++ b/packages/leptos/src/eye.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Eye(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.062 12.348a1 1 0 0 1 0-.696 10.75 10.75 0 0 1 19.876 0 1 1 0 0 1 0 .696 10.75 10.75 0 0 1-19.876 0"></path>
+            <circle cx="12" cy="12" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/eye_closed.rs b/packages/leptos/src/eye_closed.rs
new file mode 100644
index 0000000..4cf3695
--- /dev/null
+++ b/packages/leptos/src/eye_closed.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EyeClosed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 18-.722-3.25"></path>
+            <path d="M2 8a10.645 10.645 0 0 0 20 0"></path>
+            <path d="m20 15-1.726-2.05"></path>
+            <path d="m4 15 1.726-2.05"></path>
+            <path d="m9 18 .722-3.25"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/eye_off.rs b/packages/leptos/src/eye_off.rs
new file mode 100644
index 0000000..ef3f912
--- /dev/null
+++ b/packages/leptos/src/eye_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn EyeOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.733 5.076a10.744 10.744 0 0 1 11.205 6.575 1 1 0 0 1 0 .696 10.747 10.747 0 0 1-1.444 2.49"></path>
+            <path d="M14.084 14.158a3 3 0 0 1-4.242-4.242"></path>
+            <path d="M17.479 17.499a10.75 10.75 0 0 1-15.417-5.151 1 1 0 0 1 0-.696 10.75 10.75 0 0 1 4.446-5.143"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/facebook.rs b/packages/leptos/src/facebook.rs
new file mode 100644
index 0000000..fd05d81
--- /dev/null
+++ b/packages/leptos/src/facebook.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Facebook(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 2h-3a5 5 0 0 0-5 5v3H7v4h3v8h4v-8h3l1-4h-4V7a1 1 0 0 1 1-1h3z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/factory.rs b/packages/leptos/src/factory.rs
new file mode 100644
index 0000000..3bb2425
--- /dev/null
+++ b/packages/leptos/src/factory.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Factory(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V8l-7 5V8l-7 5V4a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"></path>
+            <path d="M17 18h1"></path>
+            <path d="M12 18h1"></path>
+            <path d="M7 18h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fan.rs b/packages/leptos/src/fan.rs
new file mode 100644
index 0000000..52e6fd0
--- /dev/null
+++ b/packages/leptos/src/fan.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Fan(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.827 16.379a6.082 6.082 0 0 1-8.618-7.002l5.412 1.45a6.082 6.082 0 0 1 7.002-8.618l-1.45 5.412a6.082 6.082 0 0 1 8.618 7.002l-5.412-1.45a6.082 6.082 0 0 1-7.002 8.618l1.45-5.412Z"></path>
+            <path d="M12 12v.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fast_forward.rs b/packages/leptos/src/fast_forward.rs
new file mode 100644
index 0000000..39a7a4d
--- /dev/null
+++ b/packages/leptos/src/fast_forward.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FastForward(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="13 19 22 12 13 5 13 19"></polygon>
+            <polygon points="2 19 11 12 2 5 2 19"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/feather.rs b/packages/leptos/src/feather.rs
new file mode 100644
index 0000000..24b470d
--- /dev/null
+++ b/packages/leptos/src/feather.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Feather(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.67 19a2 2 0 0 0 1.416-.588l6.154-6.172a6 6 0 0 0-8.49-8.49L5.586 9.914A2 2 0 0 0 5 11.328V18a1 1 0 0 0 1 1z"></path>
+            <path d="M16 8 2 22"></path>
+            <path d="M17.5 15H9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fence.rs b/packages/leptos/src/fence.rs
new file mode 100644
index 0000000..e961843
--- /dev/null
+++ b/packages/leptos/src/fence.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Fence(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 3 2 5v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z"></path>
+            <path d="M6 8h4"></path>
+            <path d="M6 18h4"></path>
+            <path d="m12 3-2 2v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z"></path>
+            <path d="M14 8h4"></path>
+            <path d="M14 18h4"></path>
+            <path d="m20 3-2 2v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ferris_wheel.rs b/packages/leptos/src/ferris_wheel.rs
new file mode 100644
index 0000000..2a896bc
--- /dev/null
+++ b/packages/leptos/src/ferris_wheel.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FerrisWheel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="2"></circle>
+            <path d="M12 2v4"></path>
+            <path d="m6.8 15-3.5 2"></path>
+            <path d="m20.7 7-3.5 2"></path>
+            <path d="M6.8 9 3.3 7"></path>
+            <path d="m20.7 17-3.5-2"></path>
+            <path d="m9 22 3-8 3 8"></path>
+            <path d="M8 22h8"></path>
+            <path d="M18 18.7a9 9 0 1 0-12 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/figma.rs b/packages/leptos/src/figma.rs
new file mode 100644
index 0000000..835b8a1
--- /dev/null
+++ b/packages/leptos/src/figma.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Figma(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 5.5A3.5 3.5 0 0 1 8.5 2H12v7H8.5A3.5 3.5 0 0 1 5 5.5z"></path>
+            <path d="M12 2h3.5a3.5 3.5 0 1 1 0 7H12V2z"></path>
+            <path d="M12 12.5a3.5 3.5 0 1 1 7 0 3.5 3.5 0 1 1-7 0z"></path>
+            <path d="M5 19.5A3.5 3.5 0 0 1 8.5 16H12v3.5a3.5 3.5 0 1 1-7 0z"></path>
+            <path d="M5 12.5A3.5 3.5 0 0 1 8.5 9H12v7H8.5A3.5 3.5 0 0 1 5 12.5z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file.rs b/packages/leptos/src/file.rs
new file mode 100644
index 0000000..aeac6cb
--- /dev/null
+++ b/packages/leptos/src/file.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn File(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_archive.rs b/packages/leptos/src/file_archive.rs
new file mode 100644
index 0000000..20aea75
--- /dev/null
+++ b/packages/leptos/src/file_archive.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileArchive(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 12v-1"></path>
+            <path d="M10 18v-2"></path>
+            <path d="M10 7V6"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M15.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v16a2 2 0 0 0 .274 1.01"></path>
+            <circle cx="10" cy="20" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_audio.rs b/packages/leptos/src/file_audio.rs
new file mode 100644
index 0000000..cb7cd2b
--- /dev/null
+++ b/packages/leptos/src/file_audio.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileAudio(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.5 22h.5a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M2 19a2 2 0 1 1 4 0v1a2 2 0 1 1-4 0v-4a6 6 0 0 1 12 0v4a2 2 0 1 1-4 0v-1a2 2 0 1 1 4 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_audio_2.rs b/packages/leptos/src/file_audio_2.rs
new file mode 100644
index 0000000..386b9e9
--- /dev/null
+++ b/packages/leptos/src/file_audio_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileAudio2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v2"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <circle cx="3" cy="17" r="1"></circle>
+            <path d="M2 17v-3a4 4 0 0 1 8 0v3"></path>
+            <circle cx="9" cy="17" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_axis_3_d.rs b/packages/leptos/src/file_axis_3_d.rs
new file mode 100644
index 0000000..08c13a9
--- /dev/null
+++ b/packages/leptos/src/file_axis_3_d.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileAxis3D(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m8 18 4-4"></path>
+            <path d="M8 10v8h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_badge.rs b/packages/leptos/src/file_badge.rs
new file mode 100644
index 0000000..4d51717
--- /dev/null
+++ b/packages/leptos/src/file_badge.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileBadge(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22h6a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M5 17a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z"></path>
+            <path d="M7 16.5 8 22l-3-1-3 1 1-5.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_badge_2.rs b/packages/leptos/src/file_badge_2.rs
new file mode 100644
index 0000000..c4fdee9
--- /dev/null
+++ b/packages/leptos/src/file_badge_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileBadge2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <circle cx="12" cy="10" r="3"></circle>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m14 12.5 1 5.5-3-1-3 1 1-5.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_box.rs b/packages/leptos/src/file_box.rs
new file mode 100644
index 0000000..e1839cd
--- /dev/null
+++ b/packages/leptos/src/file_box.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileBox(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M3 13.1a2 2 0 0 0-1 1.76v3.24a2 2 0 0 0 .97 1.78L6 21.7a2 2 0 0 0 2.03.01L11 19.9a2 2 0 0 0 1-1.76V14.9a2 2 0 0 0-.97-1.78L8 11.3a2 2 0 0 0-2.03-.01Z"></path>
+            <path d="M7 17v5"></path>
+            <path d="M11.7 14.2 7 17l-4.7-2.8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_chart_column.rs b/packages/leptos/src/file_chart_column.rs
new file mode 100644
index 0000000..4b7a875
--- /dev/null
+++ b/packages/leptos/src/file_chart_column.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileChartColumn(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M8 18v-1"></path>
+            <path d="M12 18v-6"></path>
+            <path d="M16 18v-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_chart_column_increasing.rs b/packages/leptos/src/file_chart_column_increasing.rs
new file mode 100644
index 0000000..142467b
--- /dev/null
+++ b/packages/leptos/src/file_chart_column_increasing.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileChartColumnIncreasing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M8 18v-2"></path>
+            <path d="M12 18v-4"></path>
+            <path d="M16 18v-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_chart_line.rs b/packages/leptos/src/file_chart_line.rs
new file mode 100644
index 0000000..0124247
--- /dev/null
+++ b/packages/leptos/src/file_chart_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileChartLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m16 13-3.5 3.5-2-2L8 17"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_chart_pie.rs b/packages/leptos/src/file_chart_pie.rs
new file mode 100644
index 0000000..7cff3f6
--- /dev/null
+++ b/packages/leptos/src/file_chart_pie.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileChartPie(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M16 22h2a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3.5"></path>
+            <path d="M4.017 11.512a6 6 0 1 0 8.466 8.475"></path>
+            <path d="M9 16a1 1 0 0 1-1-1v-4c0-.552.45-1.008.995-.917a6 6 0 0 1 4.922 4.922c.091.544-.365.995-.917.995z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_check.rs b/packages/leptos/src/file_check.rs
new file mode 100644
index 0000000..b5017b3
--- /dev/null
+++ b/packages/leptos/src/file_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m9 15 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_check_2.rs b/packages/leptos/src/file_check_2.rs
new file mode 100644
index 0000000..0103d2a
--- /dev/null
+++ b/packages/leptos/src/file_check_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileCheck2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m3 15 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_clock.rs b/packages/leptos/src/file_clock.rs
new file mode 100644
index 0000000..a79504b
--- /dev/null
+++ b/packages/leptos/src/file_clock.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileClock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 22h2a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <circle cx="8" cy="16" r="6"></circle>
+            <path d="M9.5 17.5 8 16.25V14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_code.rs b/packages/leptos/src/file_code.rs
new file mode 100644
index 0000000..ef109fb
--- /dev/null
+++ b/packages/leptos/src/file_code.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 12.5 8 15l2 2.5"></path>
+            <path d="m14 12.5 2 2.5-2 2.5"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_code_2.rs b/packages/leptos/src/file_code_2.rs
new file mode 100644
index 0000000..d80d2d8
--- /dev/null
+++ b/packages/leptos/src/file_code_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileCode2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m5 12-3 3 3 3"></path>
+            <path d="m9 18 3-3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_cog.rs b/packages/leptos/src/file_cog.rs
new file mode 100644
index 0000000..d03c9f9
--- /dev/null
+++ b/packages/leptos/src/file_cog.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m3.2 12.9-.9-.4"></path>
+            <path d="m3.2 15.1-.9.4"></path>
+            <path d="M4.677 21.5a2 2 0 0 0 1.313.5H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v2.5"></path>
+            <path d="m4.9 11.2-.4-.9"></path>
+            <path d="m4.9 16.8-.4.9"></path>
+            <path d="m7.5 10.3-.4.9"></path>
+            <path d="m7.5 17.7-.4-.9"></path>
+            <path d="m9.7 12.5-.9.4"></path>
+            <path d="m9.7 15.5-.9-.4"></path>
+            <circle cx="6" cy="14" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_diff.rs b/packages/leptos/src/file_diff.rs
new file mode 100644
index 0000000..3a23aac
--- /dev/null
+++ b/packages/leptos/src/file_diff.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileDiff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M9 10h6"></path>
+            <path d="M12 13V7"></path>
+            <path d="M9 17h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_digit.rs b/packages/leptos/src/file_digit.rs
new file mode 100644
index 0000000..7172b01
--- /dev/null
+++ b/packages/leptos/src/file_digit.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileDigit(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <rect width="4" height="6" x="2" y="12" rx="2"></rect>
+            <path d="M10 12h2v6"></path>
+            <path d="M10 18h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_down.rs b/packages/leptos/src/file_down.rs
new file mode 100644
index 0000000..8ebaa05
--- /dev/null
+++ b/packages/leptos/src/file_down.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M12 18v-6"></path>
+            <path d="m9 15 3 3 3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_heart.rs b/packages/leptos/src/file_heart.rs
new file mode 100644
index 0000000..c56aa94
--- /dev/null
+++ b/packages/leptos/src/file_heart.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileHeart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v2"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M10.29 10.7a2.43 2.43 0 0 0-2.66-.52c-.29.12-.56.3-.78.53l-.35.34-.35-.34a2.43 2.43 0 0 0-2.65-.53c-.3.12-.56.3-.79.53-.95.94-1 2.53.2 3.74L6.5 18l3.6-3.55c1.2-1.21 1.14-2.8.19-3.74Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_image.rs b/packages/leptos/src/file_image.rs
new file mode 100644
index 0000000..651a687
--- /dev/null
+++ b/packages/leptos/src/file_image.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileImage(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <circle cx="10" cy="12" r="2"></circle>
+            <path d="m20 17-1.296-1.296a2.41 2.41 0 0 0-3.408 0L9 22"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_input.rs b/packages/leptos/src/file_input.rs
new file mode 100644
index 0000000..fea557a
--- /dev/null
+++ b/packages/leptos/src/file_input.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileInput(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M2 15h10"></path>
+            <path d="m9 18 3-3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_json.rs b/packages/leptos/src/file_json.rs
new file mode 100644
index 0000000..2c811be
--- /dev/null
+++ b/packages/leptos/src/file_json.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileJson(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M10 12a1 1 0 0 0-1 1v1a1 1 0 0 1-1 1 1 1 0 0 1 1 1v1a1 1 0 0 0 1 1"></path>
+            <path d="M14 18a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-1a1 1 0 0 0-1-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_json_2.rs b/packages/leptos/src/file_json_2.rs
new file mode 100644
index 0000000..32d954c
--- /dev/null
+++ b/packages/leptos/src/file_json_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileJson2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M4 12a1 1 0 0 0-1 1v1a1 1 0 0 1-1 1 1 1 0 0 1 1 1v1a1 1 0 0 0 1 1"></path>
+            <path d="M8 18a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-1a1 1 0 0 0-1-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_key.rs b/packages/leptos/src/file_key.rs
new file mode 100644
index 0000000..89c52dc
--- /dev/null
+++ b/packages/leptos/src/file_key.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileKey(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <circle cx="10" cy="16" r="2"></circle>
+            <path d="m16 10-4.5 4.5"></path>
+            <path d="m15 11 1 1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_key_2.rs b/packages/leptos/src/file_key_2.rs
new file mode 100644
index 0000000..041174c
--- /dev/null
+++ b/packages/leptos/src/file_key_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileKey2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v6"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <circle cx="4" cy="16" r="2"></circle>
+            <path d="m10 10-4.5 4.5"></path>
+            <path d="m9 11 1 1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_lock.rs b/packages/leptos/src/file_lock.rs
new file mode 100644
index 0000000..4524eca
--- /dev/null
+++ b/packages/leptos/src/file_lock.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileLock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <rect width="8" height="6" x="8" y="12" rx="1"></rect>
+            <path d="M10 12v-2a2 2 0 1 1 4 0v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_lock_2.rs b/packages/leptos/src/file_lock_2.rs
new file mode 100644
index 0000000..8680b77
--- /dev/null
+++ b/packages/leptos/src/file_lock_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileLock2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v1"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <rect width="8" height="5" x="2" y="13" rx="1"></rect>
+            <path d="M8 13v-2a2 2 0 1 0-4 0v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_minus.rs b/packages/leptos/src/file_minus.rs
new file mode 100644
index 0000000..757563d
--- /dev/null
+++ b/packages/leptos/src/file_minus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M9 15h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_minus_2.rs b/packages/leptos/src/file_minus_2.rs
new file mode 100644
index 0000000..8deed0e
--- /dev/null
+++ b/packages/leptos/src/file_minus_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileMinus2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M3 15h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_music.rs b/packages/leptos/src/file_music.rs
new file mode 100644
index 0000000..f4c401a
--- /dev/null
+++ b/packages/leptos/src/file_music.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileMusic(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v8.4"></path>
+            <path d="M8 18v-7.7L16 9v7"></path>
+            <circle cx="14" cy="16" r="2"></circle>
+            <circle cx="6" cy="18" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_output.rs b/packages/leptos/src/file_output.rs
new file mode 100644
index 0000000..5f6c5a1
--- /dev/null
+++ b/packages/leptos/src/file_output.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileOutput(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M4 7V4a2 2 0 0 1 2-2 2 2 0 0 0-2 2"></path>
+            <path d="M4.063 20.999a2 2 0 0 0 2 1L18 22a2 2 0 0 0 2-2V7l-5-5H6"></path>
+            <path d="m5 11-3 3"></path>
+            <path d="m5 17-3-3h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_pen.rs b/packages/leptos/src/file_pen.rs
new file mode 100644
index 0000000..99d1a77
--- /dev/null
+++ b/packages/leptos/src/file_pen.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FilePen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v9.5"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M13.378 15.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_pen_line.rs b/packages/leptos/src/file_pen_line.rs
new file mode 100644
index 0000000..ae6b123
--- /dev/null
+++ b/packages/leptos/src/file_pen_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FilePenLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 5-2.414-2.414A2 2 0 0 0 14.172 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2"></path>
+            <path d="M21.378 12.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"></path>
+            <path d="M8 18h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_plus.rs b/packages/leptos/src/file_plus.rs
new file mode 100644
index 0000000..ec80d65
--- /dev/null
+++ b/packages/leptos/src/file_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FilePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M9 15h6"></path>
+            <path d="M12 18v-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_plus_2.rs b/packages/leptos/src/file_plus_2.rs
new file mode 100644
index 0000000..8229f81
--- /dev/null
+++ b/packages/leptos/src/file_plus_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FilePlus2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M3 15h6"></path>
+            <path d="M6 12v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_question.rs b/packages/leptos/src/file_question.rs
new file mode 100644
index 0000000..add656b
--- /dev/null
+++ b/packages/leptos/src/file_question.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileQuestion(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17h.01"></path>
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z"></path>
+            <path d="M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_scan.rs b/packages/leptos/src/file_scan.rs
new file mode 100644
index 0000000..b836da6
--- /dev/null
+++ b/packages/leptos/src/file_scan.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileScan(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10V7l-5-5H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M16 14a2 2 0 0 0-2 2"></path>
+            <path d="M20 14a2 2 0 0 1 2 2"></path>
+            <path d="M20 22a2 2 0 0 0 2-2"></path>
+            <path d="M16 22a2 2 0 0 1-2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_search.rs b/packages/leptos/src/file_search.rs
new file mode 100644
index 0000000..a0a6c22
--- /dev/null
+++ b/packages/leptos/src/file_search.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M4.268 21a2 2 0 0 0 1.727 1H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"></path>
+            <path d="m9 18-1.5-1.5"></path>
+            <circle cx="5" cy="14" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_search_2.rs b/packages/leptos/src/file_search_2.rs
new file mode 100644
index 0000000..7555111
--- /dev/null
+++ b/packages/leptos/src/file_search_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileSearch2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <circle cx="11.5" cy="14.5" r="2.5"></circle>
+            <path d="M13.3 16.3 15 18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_sliders.rs b/packages/leptos/src/file_sliders.rs
new file mode 100644
index 0000000..55ee9f6
--- /dev/null
+++ b/packages/leptos/src/file_sliders.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileSliders(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M8 12h8"></path>
+            <path d="M10 11v2"></path>
+            <path d="M8 17h8"></path>
+            <path d="M14 16v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_spreadsheet.rs b/packages/leptos/src/file_spreadsheet.rs
new file mode 100644
index 0000000..0f6defc
--- /dev/null
+++ b/packages/leptos/src/file_spreadsheet.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileSpreadsheet(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M8 13h2"></path>
+            <path d="M14 13h2"></path>
+            <path d="M8 17h2"></path>
+            <path d="M14 17h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_stack.rs b/packages/leptos/src/file_stack.rs
new file mode 100644
index 0000000..e903fc5
--- /dev/null
+++ b/packages/leptos/src/file_stack.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileStack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 7h-3a2 2 0 0 1-2-2V2"></path>
+            <path d="M21 6v6.5c0 .8-.7 1.5-1.5 1.5h-7c-.8 0-1.5-.7-1.5-1.5v-9c0-.8.7-1.5 1.5-1.5H17Z"></path>
+            <path d="M7 8v8.8c0 .3.2.6.4.8.2.2.5.4.8.4H15"></path>
+            <path d="M3 12v8.8c0 .3.2.6.4.8.2.2.5.4.8.4H11"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_symlink.rs b/packages/leptos/src/file_symlink.rs
new file mode 100644
index 0000000..154a571
--- /dev/null
+++ b/packages/leptos/src/file_symlink.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileSymlink(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10 18 3-3-3-3"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M4 11V4a2 2 0 0 1 2-2h9l5 5v13a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_terminal.rs b/packages/leptos/src/file_terminal.rs
new file mode 100644
index 0000000..004a7c0
--- /dev/null
+++ b/packages/leptos/src/file_terminal.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileTerminal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m8 16 2-2-2-2"></path>
+            <path d="M12 18h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_text.rs b/packages/leptos/src/file_text.rs
new file mode 100644
index 0000000..cd44bb6
--- /dev/null
+++ b/packages/leptos/src/file_text.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M10 9H8"></path>
+            <path d="M16 13H8"></path>
+            <path d="M16 17H8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_type.rs b/packages/leptos/src/file_type.rs
new file mode 100644
index 0000000..3ba4cf3
--- /dev/null
+++ b/packages/leptos/src/file_type.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileType(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M9 13v-1h6v1"></path>
+            <path d="M12 12v6"></path>
+            <path d="M11 18h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_type_2.rs b/packages/leptos/src/file_type_2.rs
new file mode 100644
index 0000000..102fe20
--- /dev/null
+++ b/packages/leptos/src/file_type_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileType2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M2 13v-1h6v1"></path>
+            <path d="M5 12v6"></path>
+            <path d="M4 18h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_up.rs b/packages/leptos/src/file_up.rs
new file mode 100644
index 0000000..4226053
--- /dev/null
+++ b/packages/leptos/src/file_up.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M12 12v6"></path>
+            <path d="m15 15-3-3-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_user.rs b/packages/leptos/src/file_user.rs
new file mode 100644
index 0000000..33eb3ae
--- /dev/null
+++ b/packages/leptos/src/file_user.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileUser(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M15 18a3 3 0 1 0-6 0"></path>
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z"></path>
+            <circle cx="12" cy="13" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_video.rs b/packages/leptos/src/file_video.rs
new file mode 100644
index 0000000..abcaa65
--- /dev/null
+++ b/packages/leptos/src/file_video.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileVideo(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m10 11 5 3-5 3v-6Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_video_2.rs b/packages/leptos/src/file_video_2.rs
new file mode 100644
index 0000000..abe6d1b
--- /dev/null
+++ b/packages/leptos/src/file_video_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileVideo2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <rect width="8" height="6" x="2" y="12" rx="1"></rect>
+            <path d="m10 15.5 4 2.5v-6l-4 2.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_volume.rs b/packages/leptos/src/file_volume.rs
new file mode 100644
index 0000000..e640e52
--- /dev/null
+++ b/packages/leptos/src/file_volume.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileVolume(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 11a5 5 0 0 1 0 6"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M4 6.765V4a2 2 0 0 1 2-2h9l5 5v13a2 2 0 0 1-2 2H6a2 2 0 0 1-.93-.23"></path>
+            <path d="M7 10.51a.5.5 0 0 0-.826-.38l-1.893 1.628A1 1 0 0 1 3.63 12H2.5a.5.5 0 0 0-.5.5v3a.5.5 0 0 0 .5.5h1.129a1 1 0 0 1 .652.242l1.893 1.63a.5.5 0 0 0 .826-.38z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_volume_2.rs b/packages/leptos/src/file_volume_2.rs
new file mode 100644
index 0000000..9cf34b1
--- /dev/null
+++ b/packages/leptos/src/file_volume_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileVolume2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M8 15h.01"></path>
+            <path d="M11.5 13.5a2.5 2.5 0 0 1 0 3"></path>
+            <path d="M15 12a5 5 0 0 1 0 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_warning.rs b/packages/leptos/src/file_warning.rs
new file mode 100644
index 0000000..7c746d7
--- /dev/null
+++ b/packages/leptos/src/file_warning.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileWarning(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M12 9v4"></path>
+            <path d="M12 17h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_x.rs b/packages/leptos/src/file_x.rs
new file mode 100644
index 0000000..9a75456
--- /dev/null
+++ b/packages/leptos/src/file_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m14.5 12.5-5 5"></path>
+            <path d="m9.5 12.5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/file_x_2.rs b/packages/leptos/src/file_x_2.rs
new file mode 100644
index 0000000..fe3bd22
--- /dev/null
+++ b/packages/leptos/src/file_x_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FileX2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"></path>
+            <path d="M14 2v4a2 2 0 0 0 2 2h4"></path>
+            <path d="m8 12.5-5 5"></path>
+            <path d="m3 12.5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/files.rs b/packages/leptos/src/files.rs
new file mode 100644
index 0000000..2427197
--- /dev/null
+++ b/packages/leptos/src/files.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Files(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 7h-3a2 2 0 0 1-2-2V2"></path>
+            <path d="M9 18a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h7l4 4v10a2 2 0 0 1-2 2Z"></path>
+            <path d="M3 7.6v12.8A1.6 1.6 0 0 0 4.6 22h9.8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/film.rs b/packages/leptos/src/film.rs
new file mode 100644
index 0000000..65513ce
--- /dev/null
+++ b/packages/leptos/src/film.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Film(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M7 3v18"></path>
+            <path d="M3 7.5h4"></path>
+            <path d="M3 12h18"></path>
+            <path d="M3 16.5h4"></path>
+            <path d="M17 3v18"></path>
+            <path d="M17 7.5h4"></path>
+            <path d="M17 16.5h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/filter.rs b/packages/leptos/src/filter.rs
new file mode 100644
index 0000000..cc20f5f
--- /dev/null
+++ b/packages/leptos/src/filter.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Filter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/filter_x.rs b/packages/leptos/src/filter_x.rs
new file mode 100644
index 0000000..34d90f1
--- /dev/null
+++ b/packages/leptos/src/filter_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FilterX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.013 3H2l8 9.46V19l4 2v-8.54l.9-1.055"></path>
+            <path d="m22 3-5 5"></path>
+            <path d="m17 3 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fingerprint.rs b/packages/leptos/src/fingerprint.rs
new file mode 100644
index 0000000..cde94e9
--- /dev/null
+++ b/packages/leptos/src/fingerprint.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Fingerprint(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 10a2 2 0 0 0-2 2c0 1.02-.1 2.51-.26 4"></path>
+            <path d="M14 13.12c0 2.38 0 6.38-1 8.88"></path>
+            <path d="M17.29 21.02c.12-.6.43-2.3.5-3.02"></path>
+            <path d="M2 12a10 10 0 0 1 18-6"></path>
+            <path d="M2 16h.01"></path>
+            <path d="M21.8 16c.2-2 .131-5.354 0-6"></path>
+            <path d="M5 19.5C5.5 18 6 15 6 12a6 6 0 0 1 .34-2"></path>
+            <path d="M8.65 22c.21-.66.45-1.32.57-2"></path>
+            <path d="M9 6.8a6 6 0 0 1 9 5.2v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fire_extinguisher.rs b/packages/leptos/src/fire_extinguisher.rs
new file mode 100644
index 0000000..e46ebdf
--- /dev/null
+++ b/packages/leptos/src/fire_extinguisher.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FireExtinguisher(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 6.5V3a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v3.5"></path>
+            <path d="M9 18h8"></path>
+            <path d="M18 3h-3"></path>
+            <path d="M11 3a6 6 0 0 0-6 6v11"></path>
+            <path d="M5 13h4"></path>
+            <path d="M17 10a4 4 0 0 0-8 0v10a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fish.rs b/packages/leptos/src/fish.rs
new file mode 100644
index 0000000..76c64c0
--- /dev/null
+++ b/packages/leptos/src/fish.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Fish(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6.5 12c.94-3.46 4.94-6 8.5-6 3.56 0 6.06 2.54 7 6-.94 3.47-3.44 6-7 6s-7.56-2.53-8.5-6Z"></path>
+            <path d="M18 12v.5"></path>
+            <path d="M16 17.93a9.77 9.77 0 0 1 0-11.86"></path>
+            <path d="M7 10.67C7 8 5.58 5.97 2.73 5.5c-1 1.5-1 5 .23 6.5-1.24 1.5-1.24 5-.23 6.5C5.58 18.03 7 16 7 13.33"></path>
+            <path d="M10.46 7.26C10.2 5.88 9.17 4.24 8 3h5.8a2 2 0 0 1 1.98 1.67l.23 1.4"></path>
+            <path d="m16.01 17.93-.23 1.4A2 2 0 0 1 13.8 21H9.5a5.96 5.96 0 0 0 1.49-3.98"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fish_off.rs b/packages/leptos/src/fish_off.rs
new file mode 100644
index 0000000..30eba45
--- /dev/null
+++ b/packages/leptos/src/fish_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FishOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 12.47v.03m0-.5v.47m-.475 5.056A6.744 6.744 0 0 1 15 18c-3.56 0-7.56-2.53-8.5-6 .348-1.28 1.114-2.433 2.121-3.38m3.444-2.088A8.802 8.802 0 0 1 15 6c3.56 0 6.06 2.54 7 6-.309 1.14-.786 2.177-1.413 3.058"></path>
+            <path d="M7 10.67C7 8 5.58 5.97 2.73 5.5c-1 1.5-1 5 .23 6.5-1.24 1.5-1.24 5-.23 6.5C5.58 18.03 7 16 7 13.33m7.48-4.372A9.77 9.77 0 0 1 16 6.07m0 11.86a9.77 9.77 0 0 1-1.728-3.618"></path>
+            <path d="m16.01 17.93-.23 1.4A2 2 0 0 1 13.8 21H9.5a5.96 5.96 0 0 0 1.49-3.98M8.53 3h5.27a2 2 0 0 1 1.98 1.67l.23 1.4M2 2l20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fish_symbol.rs b/packages/leptos/src/fish_symbol.rs
new file mode 100644
index 0000000..8110eba
--- /dev/null
+++ b/packages/leptos/src/fish_symbol.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FishSymbol(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 16s9-15 20-4C11 23 2 8 2 8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flag.rs b/packages/leptos/src/flag.rs
new file mode 100644
index 0000000..72d5925
--- /dev/null
+++ b/packages/leptos/src/flag.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Flag(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 15s1-1 4-1 5 2 8 2 4-1 4-1V3s-1 1-4 1-5-2-8-2-4 1-4 1z"></path>
+            <line x1="4" x2="4" y1="22" y2="15"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flag_off.rs b/packages/leptos/src/flag_off.rs
new file mode 100644
index 0000000..f0c4e51
--- /dev/null
+++ b/packages/leptos/src/flag_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlagOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2c3 0 5 2 8 2s4-1 4-1v11"></path>
+            <path d="M4 22V4"></path>
+            <path d="M4 15s1-1 4-1 5 2 8 2"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flag_triangle_left.rs b/packages/leptos/src/flag_triangle_left.rs
new file mode 100644
index 0000000..b0fe14a
--- /dev/null
+++ b/packages/leptos/src/flag_triangle_left.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlagTriangleLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 22V2L7 7l10 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flag_triangle_right.rs b/packages/leptos/src/flag_triangle_right.rs
new file mode 100644
index 0000000..835df40
--- /dev/null
+++ b/packages/leptos/src/flag_triangle_right.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlagTriangleRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 22V2l10 5-10 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flame.rs b/packages/leptos/src/flame.rs
new file mode 100644
index 0000000..981f40b
--- /dev/null
+++ b/packages/leptos/src/flame.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Flame(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.5 14.5A2.5 2.5 0 0 0 11 12c0-1.38-.5-2-1-3-1.072-2.143-.224-4.054 2-6 .5 2.5 2 4.9 4 6.5 2 1.6 3 3.5 3 5.5a7 7 0 1 1-14 0c0-1.153.433-2.294 1-3a2.5 2.5 0 0 0 2.5 2.5z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flame_kindling.rs b/packages/leptos/src/flame_kindling.rs
new file mode 100644
index 0000000..0e98ea4
--- /dev/null
+++ b/packages/leptos/src/flame_kindling.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlameKindling(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2c1 3 2.5 3.5 3.5 4.5A5 5 0 0 1 17 10a5 5 0 1 1-10 0c0-.3 0-.6.1-.9a2 2 0 1 0 3.3-2C8 4.5 11 2 12 2Z"></path>
+            <path d="m5 22 14-4"></path>
+            <path d="m5 18 14 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flashlight.rs b/packages/leptos/src/flashlight.rs
new file mode 100644
index 0000000..91a7d22
--- /dev/null
+++ b/packages/leptos/src/flashlight.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Flashlight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 6c0 2-2 2-2 4v10a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2V10c0-2-2-2-2-4V2h12z"></path>
+            <line x1="6" x2="18" y1="6" y2="6"></line>
+            <line x1="12" x2="12" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flashlight_off.rs b/packages/leptos/src/flashlight_off.rs
new file mode 100644
index 0000000..9301ee1
--- /dev/null
+++ b/packages/leptos/src/flashlight_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlashlightOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 16v4a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2V10c0-2-2-2-2-4"></path>
+            <path d="M7 2h11v4c0 2-2 2-2 4v1"></path>
+            <line x1="11" x2="18" y1="6" y2="6"></line>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flask_conical.rs b/packages/leptos/src/flask_conical.rs
new file mode 100644
index 0000000..abec1c9
--- /dev/null
+++ b/packages/leptos/src/flask_conical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlaskConical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v7.527a2 2 0 0 1-.211.896L4.72 20.55a1 1 0 0 0 .9 1.45h12.76a1 1 0 0 0 .9-1.45l-5.069-10.127A2 2 0 0 1 14 9.527V2"></path>
+            <path d="M8.5 2h7"></path>
+            <path d="M7 16h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flask_conical_off.rs b/packages/leptos/src/flask_conical_off.rs
new file mode 100644
index 0000000..a3dc41a
--- /dev/null
+++ b/packages/leptos/src/flask_conical_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlaskConicalOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10 4.72 20.55a1 1 0 0 0 .9 1.45h12.76a1 1 0 0 0 .9-1.45l-1.272-2.542"></path>
+            <path d="M10 2v2.343"></path>
+            <path d="M14 2v6.343"></path>
+            <path d="M8.5 2h7"></path>
+            <path d="M7 16h9"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flask_round.rs b/packages/leptos/src/flask_round.rs
new file mode 100644
index 0000000..8a4b241
--- /dev/null
+++ b/packages/leptos/src/flask_round.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlaskRound(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v7.31"></path>
+            <path d="M14 9.3V1.99"></path>
+            <path d="M8.5 2h7"></path>
+            <path d="M14 9.3a6.5 6.5 0 1 1-4 0"></path>
+            <path d="M5.52 16h12.96"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flip_horizontal.rs b/packages/leptos/src/flip_horizontal.rs
new file mode 100644
index 0000000..92f713e
--- /dev/null
+++ b/packages/leptos/src/flip_horizontal.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlipHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h3"></path>
+            <path d="M16 3h3a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-3"></path>
+            <path d="M12 20v2"></path>
+            <path d="M12 14v2"></path>
+            <path d="M12 8v2"></path>
+            <path d="M12 2v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flip_horizontal_2.rs b/packages/leptos/src/flip_horizontal_2.rs
new file mode 100644
index 0000000..5e4f8ce
--- /dev/null
+++ b/packages/leptos/src/flip_horizontal_2.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlipHorizontal2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 7 5 5-5 5V7"></path>
+            <path d="m21 7-5 5 5 5V7"></path>
+            <path d="M12 20v2"></path>
+            <path d="M12 14v2"></path>
+            <path d="M12 8v2"></path>
+            <path d="M12 2v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flip_vertical.rs b/packages/leptos/src/flip_vertical.rs
new file mode 100644
index 0000000..d8e1abf
--- /dev/null
+++ b/packages/leptos/src/flip_vertical.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlipVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 8V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v3"></path>
+            <path d="M21 16v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-3"></path>
+            <path d="M4 12H2"></path>
+            <path d="M10 12H8"></path>
+            <path d="M16 12h-2"></path>
+            <path d="M22 12h-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flip_vertical_2.rs b/packages/leptos/src/flip_vertical_2.rs
new file mode 100644
index 0000000..b8f9927
--- /dev/null
+++ b/packages/leptos/src/flip_vertical_2.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FlipVertical2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 3-5 5-5-5h10"></path>
+            <path d="m17 21-5-5-5 5h10"></path>
+            <path d="M4 12H2"></path>
+            <path d="M10 12H8"></path>
+            <path d="M16 12h-2"></path>
+            <path d="M22 12h-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flower.rs b/packages/leptos/src/flower.rs
new file mode 100644
index 0000000..42df184
--- /dev/null
+++ b/packages/leptos/src/flower.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Flower(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3"></circle>
+            <path d="M12 16.5A4.5 4.5 0 1 1 7.5 12 4.5 4.5 0 1 1 12 7.5a4.5 4.5 0 1 1 4.5 4.5 4.5 4.5 0 1 1-4.5 4.5"></path>
+            <path d="M12 7.5V9"></path>
+            <path d="M7.5 12H9"></path>
+            <path d="M16.5 12H15"></path>
+            <path d="M12 16.5V15"></path>
+            <path d="m8 8 1.88 1.88"></path>
+            <path d="M14.12 9.88 16 8"></path>
+            <path d="m8 16 1.88-1.88"></path>
+            <path d="M14.12 14.12 16 16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/flower_2.rs b/packages/leptos/src/flower_2.rs
new file mode 100644
index 0000000..79c39c7
--- /dev/null
+++ b/packages/leptos/src/flower_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Flower2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5a3 3 0 1 1 3 3m-3-3a3 3 0 1 0-3 3m3-3v1M9 8a3 3 0 1 0 3 3M9 8h1m5 0a3 3 0 1 1-3 3m3-3h-1m-2 3v-1"></path>
+            <circle cx="12" cy="8" r="2"></circle>
+            <path d="M12 10v12"></path>
+            <path d="M12 22c4.2 0 7-1.667 7-5-4.2 0-7 1.667-7 5Z"></path>
+            <path d="M12 22c-4.2 0-7-1.667-7-5 4.2 0 7 1.667 7 5Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/focus.rs b/packages/leptos/src/focus.rs
new file mode 100644
index 0000000..cdc3ef8
--- /dev/null
+++ b/packages/leptos/src/focus.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Focus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3"></circle>
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fold_horizontal.rs b/packages/leptos/src/fold_horizontal.rs
new file mode 100644
index 0000000..e8f5bdd
--- /dev/null
+++ b/packages/leptos/src/fold_horizontal.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FoldHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12h6"></path>
+            <path d="M22 12h-6"></path>
+            <path d="M12 2v2"></path>
+            <path d="M12 8v2"></path>
+            <path d="M12 14v2"></path>
+            <path d="M12 20v2"></path>
+            <path d="m19 9-3 3 3 3"></path>
+            <path d="m5 15 3-3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fold_vertical.rs b/packages/leptos/src/fold_vertical.rs
new file mode 100644
index 0000000..9b00352
--- /dev/null
+++ b/packages/leptos/src/fold_vertical.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FoldVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-6"></path>
+            <path d="M12 8V2"></path>
+            <path d="M4 12H2"></path>
+            <path d="M10 12H8"></path>
+            <path d="M16 12h-2"></path>
+            <path d="M22 12h-2"></path>
+            <path d="m15 19-3-3-3 3"></path>
+            <path d="m15 5-3 3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder.rs b/packages/leptos/src/folder.rs
new file mode 100644
index 0000000..bc6929c
--- /dev/null
+++ b/packages/leptos/src/folder.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Folder(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_archive.rs b/packages/leptos/src/folder_archive.rs
new file mode 100644
index 0000000..e9999ec
--- /dev/null
+++ b/packages/leptos/src/folder_archive.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderArchive(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="15" cy="19" r="2"></circle>
+            <path d="M20.9 19.8A2 2 0 0 0 22 18V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2h5.1"></path>
+            <path d="M15 11v-1"></path>
+            <path d="M15 17v-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_check.rs b/packages/leptos/src/folder_check.rs
new file mode 100644
index 0000000..6ac6e2f
--- /dev/null
+++ b/packages/leptos/src/folder_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+            <path d="m9 13 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_clock.rs b/packages/leptos/src/folder_clock.rs
new file mode 100644
index 0000000..f365962
--- /dev/null
+++ b/packages/leptos/src/folder_clock.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderClock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="16" cy="16" r="6"></circle>
+            <path d="M7 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2"></path>
+            <path d="M16 14v2l1 1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_closed.rs b/packages/leptos/src/folder_closed.rs
new file mode 100644
index 0000000..579304a
--- /dev/null
+++ b/packages/leptos/src/folder_closed.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderClosed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+            <path d="M2 10h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_code.rs b/packages/leptos/src/folder_code.rs
new file mode 100644
index 0000000..918195a
--- /dev/null
+++ b/packages/leptos/src/folder_code.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10.5 8 13l2 2.5"></path>
+            <path d="m14 10.5 2 2.5-2 2.5"></path>
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_cog.rs b/packages/leptos/src/folder_cog.rs
new file mode 100644
index 0000000..a451199
--- /dev/null
+++ b/packages/leptos/src/folder_cog.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3"></circle>
+            <path d="M10.3 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v3.3"></path>
+            <path d="m21.7 19.4-.9-.3"></path>
+            <path d="m15.2 16.9-.9-.3"></path>
+            <path d="m16.6 21.7.3-.9"></path>
+            <path d="m19.1 15.2.3-.9"></path>
+            <path d="m19.6 21.7-.4-1"></path>
+            <path d="m16.8 15.3-.4-1"></path>
+            <path d="m14.3 19.6 1-.4"></path>
+            <path d="m20.7 16.8 1-.4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_dot.rs b/packages/leptos/src/folder_dot.rs
new file mode 100644
index 0000000..45d0d94
--- /dev/null
+++ b/packages/leptos/src/folder_dot.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"></path>
+            <circle cx="12" cy="13" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_down.rs b/packages/leptos/src/folder_down.rs
new file mode 100644
index 0000000..52e10a1
--- /dev/null
+++ b/packages/leptos/src/folder_down.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+            <path d="M12 10v6"></path>
+            <path d="m15 13-3 3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_git.rs b/packages/leptos/src/folder_git.rs
new file mode 100644
index 0000000..be861f3
--- /dev/null
+++ b/packages/leptos/src/folder_git.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderGit(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="2"></circle>
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+            <path d="M14 13h3"></path>
+            <path d="M7 13h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_git_2.rs b/packages/leptos/src/folder_git_2.rs
new file mode 100644
index 0000000..ecada10
--- /dev/null
+++ b/packages/leptos/src/folder_git_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderGit2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v5"></path>
+            <circle cx="13" cy="12" r="2"></circle>
+            <path d="M18 19c-2.8 0-5-2.2-5-5v8"></path>
+            <circle cx="20" cy="19" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_heart.rs b/packages/leptos/src/folder_heart.rs
new file mode 100644
index 0000000..711e275
--- /dev/null
+++ b/packages/leptos/src/folder_heart.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderHeart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v1.5"></path>
+            <path d="M13.9 17.45c-1.2-1.2-1.14-2.8-.2-3.73a2.43 2.43 0 0 1 3.44 0l.36.34.34-.34a2.43 2.43 0 0 1 3.45-.01c.95.95 1 2.53-.2 3.74L17.5 21Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_input.rs b/packages/leptos/src/folder_input.rs
new file mode 100644
index 0000000..eb7c016
--- /dev/null
+++ b/packages/leptos/src/folder_input.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderInput(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-1"></path>
+            <path d="M2 13h10"></path>
+            <path d="m9 16 3-3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_kanban.rs b/packages/leptos/src/folder_kanban.rs
new file mode 100644
index 0000000..4e998f3
--- /dev/null
+++ b/packages/leptos/src/folder_kanban.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderKanban(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"></path>
+            <path d="M8 10v4"></path>
+            <path d="M12 10v2"></path>
+            <path d="M16 10v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_key.rs b/packages/leptos/src/folder_key.rs
new file mode 100644
index 0000000..51cf137
--- /dev/null
+++ b/packages/leptos/src/folder_key.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderKey(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="16" cy="20" r="2"></circle>
+            <path d="M10 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v2"></path>
+            <path d="m22 14-4.5 4.5"></path>
+            <path d="m21 15 1 1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_lock.rs b/packages/leptos/src/folder_lock.rs
new file mode 100644
index 0000000..c7eb297
--- /dev/null
+++ b/packages/leptos/src/folder_lock.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderLock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="5" x="14" y="17" rx="1"></rect>
+            <path d="M10 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v2.5"></path>
+            <path d="M20 17v-2a2 2 0 1 0-4 0v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_minus.rs b/packages/leptos/src/folder_minus.rs
new file mode 100644
index 0000000..4905f4b
--- /dev/null
+++ b/packages/leptos/src/folder_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 13h6"></path>
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_open.rs b/packages/leptos/src/folder_open.rs
new file mode 100644
index 0000000..0944e86
--- /dev/null
+++ b/packages/leptos/src/folder_open.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_open_dot.rs b/packages/leptos/src/folder_open_dot.rs
new file mode 100644
index 0000000..0788754
--- /dev/null
+++ b/packages/leptos/src/folder_open_dot.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderOpenDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 14 1.45-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.55 6a2 2 0 0 1-1.94 1.5H4a2 2 0 0 1-2-2V5c0-1.1.9-2 2-2h3.93a2 2 0 0 1 1.66.9l.82 1.2a2 2 0 0 0 1.66.9H18a2 2 0 0 1 2 2v2"></path>
+            <circle cx="14" cy="15" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_output.rs b/packages/leptos/src/folder_output.rs
new file mode 100644
index 0000000..edb9a14
--- /dev/null
+++ b/packages/leptos/src/folder_output.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderOutput(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 7.5V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-1.5"></path>
+            <path d="M2 13h10"></path>
+            <path d="m5 10-3 3 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_pen.rs b/packages/leptos/src/folder_pen.rs
new file mode 100644
index 0000000..20b4f80
--- /dev/null
+++ b/packages/leptos/src/folder_pen.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderPen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 11.5V5a2 2 0 0 1 2-2h3.9c.7 0 1.3.3 1.7.9l.8 1.2c.4.6 1 .9 1.7.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-9.5"></path>
+            <path d="M11.378 13.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_plus.rs b/packages/leptos/src/folder_plus.rs
new file mode 100644
index 0000000..d9fdd38
--- /dev/null
+++ b/packages/leptos/src/folder_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 10v6"></path>
+            <path d="M9 13h6"></path>
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_root.rs b/packages/leptos/src/folder_root.rs
new file mode 100644
index 0000000..394fb12
--- /dev/null
+++ b/packages/leptos/src/folder_root.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderRoot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"></path>
+            <circle cx="12" cy="13" r="2"></circle>
+            <path d="M12 15v5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_search.rs b/packages/leptos/src/folder_search.rs
new file mode 100644
index 0000000..2b31c8a
--- /dev/null
+++ b/packages/leptos/src/folder_search.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.7 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v4.1"></path>
+            <path d="m21 21-1.9-1.9"></path>
+            <circle cx="17" cy="17" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_search_2.rs b/packages/leptos/src/folder_search_2.rs
new file mode 100644
index 0000000..fba6b1f
--- /dev/null
+++ b/packages/leptos/src/folder_search_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderSearch2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11.5" cy="12.5" r="2.5"></circle>
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+            <path d="M13.3 14.3 15 16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_symlink.rs b/packages/leptos/src/folder_symlink.rs
new file mode 100644
index 0000000..aedcb6d
--- /dev/null
+++ b/packages/leptos/src/folder_symlink.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderSymlink(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h7"></path>
+            <path d="m8 16 3-3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_sync.rs b/packages/leptos/src/folder_sync.rs
new file mode 100644
index 0000000..3a1998b
--- /dev/null
+++ b/packages/leptos/src/folder_sync.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderSync(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v.5"></path>
+            <path d="M12 10v4h4"></path>
+            <path d="m12 14 1.535-1.605a5 5 0 0 1 8 1.5"></path>
+            <path d="M22 22v-4h-4"></path>
+            <path d="m22 18-1.535 1.605a5 5 0 0 1-8-1.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_tree.rs b/packages/leptos/src/folder_tree.rs
new file mode 100644
index 0000000..3f19343
--- /dev/null
+++ b/packages/leptos/src/folder_tree.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderTree(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10a1 1 0 0 0 1-1V6a1 1 0 0 0-1-1h-2.5a1 1 0 0 1-.8-.4l-.9-1.2A1 1 0 0 0 15 3h-2a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z"></path>
+            <path d="M20 21a1 1 0 0 0 1-1v-3a1 1 0 0 0-1-1h-2.9a1 1 0 0 1-.88-.55l-.42-.85a1 1 0 0 0-.92-.6H13a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z"></path>
+            <path d="M3 5a2 2 0 0 0 2 2h3"></path>
+            <path d="M3 3v13a2 2 0 0 0 2 2h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_up.rs b/packages/leptos/src/folder_up.rs
new file mode 100644
index 0000000..7146a6a
--- /dev/null
+++ b/packages/leptos/src/folder_up.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+            <path d="M12 10v6"></path>
+            <path d="m9 13 3-3 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folder_x.rs b/packages/leptos/src/folder_x.rs
new file mode 100644
index 0000000..954e20a
--- /dev/null
+++ b/packages/leptos/src/folder_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn FolderX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"></path>
+            <path d="m9.5 10.5 5 5"></path>
+            <path d="m14.5 10.5-5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/folders.rs b/packages/leptos/src/folders.rs
new file mode 100644
index 0000000..341be35
--- /dev/null
+++ b/packages/leptos/src/folders.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Folders(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 17a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-3.9a2 2 0 0 1-1.69-.9l-.81-1.2a2 2 0 0 0-1.67-.9H8a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2Z"></path>
+            <path d="M2 8v11a2 2 0 0 0 2 2h14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/footprints.rs b/packages/leptos/src/footprints.rs
new file mode 100644
index 0000000..bef9b87
--- /dev/null
+++ b/packages/leptos/src/footprints.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Footprints(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 16v-2.38C4 11.5 2.97 10.5 3 8c.03-2.72 1.49-6 4.5-6C9.37 2 10 3.8 10 5.5c0 3.11-2 5.66-2 8.68V16a2 2 0 1 1-4 0Z"></path>
+            <path d="M20 20v-2.38c0-2.12 1.03-3.12 1-5.62-.03-2.72-1.49-6-4.5-6C14.63 6 14 7.8 14 9.5c0 3.11 2 5.66 2 8.68V20a2 2 0 1 0 4 0Z"></path>
+            <path d="M16 17h4"></path>
+            <path d="M4 13h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/forklift.rs b/packages/leptos/src/forklift.rs
new file mode 100644
index 0000000..f53937b
--- /dev/null
+++ b/packages/leptos/src/forklift.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Forklift(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12H5a2 2 0 0 0-2 2v5"></path>
+            <circle cx="13" cy="19" r="2"></circle>
+            <circle cx="5" cy="19" r="2"></circle>
+            <path d="M8 19h3m5-17v17h6M6 12V7c0-1.1.9-2 2-2h3l5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/forward.rs b/packages/leptos/src/forward.rs
new file mode 100644
index 0000000..4ae128f
--- /dev/null
+++ b/packages/leptos/src/forward.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Forward(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="15 17 20 12 15 7"></polyline>
+            <path d="M4 18v-2a4 4 0 0 1 4-4h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/frame.rs b/packages/leptos/src/frame.rs
new file mode 100644
index 0000000..3f6b80b
--- /dev/null
+++ b/packages/leptos/src/frame.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Frame(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="22" x2="2" y1="6" y2="6"></line>
+            <line x1="22" x2="2" y1="18" y2="18"></line>
+            <line x1="6" x2="6" y1="2" y2="22"></line>
+            <line x1="18" x2="18" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/framer.rs b/packages/leptos/src/framer.rs
new file mode 100644
index 0000000..f47d948
--- /dev/null
+++ b/packages/leptos/src/framer.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Framer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 16V9h14V2H5l14 14h-7m-7 0 7 7v-7m-7 0h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/frown.rs b/packages/leptos/src/frown.rs
new file mode 100644
index 0000000..3fea26c
--- /dev/null
+++ b/packages/leptos/src/frown.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Frown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M16 16s-1.5-2-4-2-4 2-4 2"></path>
+            <line x1="9" x2="9.01" y1="9" y2="9"></line>
+            <line x1="15" x2="15.01" y1="9" y2="9"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fuel.rs b/packages/leptos/src/fuel.rs
new file mode 100644
index 0000000..3c02860
--- /dev/null
+++ b/packages/leptos/src/fuel.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Fuel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="3" x2="15" y1="22" y2="22"></line>
+            <line x1="4" x2="14" y1="9" y2="9"></line>
+            <path d="M14 22V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v18"></path>
+            <path d="M14 13h2a2 2 0 0 1 2 2v2a2 2 0 0 0 2 2a2 2 0 0 0 2-2V9.83a2 2 0 0 0-.59-1.42L18 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/fullscreen.rs b/packages/leptos/src/fullscreen.rs
new file mode 100644
index 0000000..6ba643f
--- /dev/null
+++ b/packages/leptos/src/fullscreen.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Fullscreen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+            <rect width="10" height="8" x="7" y="8" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gallery_horizontal.rs b/packages/leptos/src/gallery_horizontal.rs
new file mode 100644
index 0000000..7b705fb
--- /dev/null
+++ b/packages/leptos/src/gallery_horizontal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GalleryHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 3v18"></path>
+            <rect width="12" height="18" x="6" y="3" rx="2"></rect>
+            <path d="M22 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gallery_horizontal_end.rs b/packages/leptos/src/gallery_horizontal_end.rs
new file mode 100644
index 0000000..d865643
--- /dev/null
+++ b/packages/leptos/src/gallery_horizontal_end.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GalleryHorizontalEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 7v10"></path>
+            <path d="M6 5v14"></path>
+            <rect width="12" height="18" x="10" y="3" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gallery_thumbnails.rs b/packages/leptos/src/gallery_thumbnails.rs
new file mode 100644
index 0000000..70fc79e
--- /dev/null
+++ b/packages/leptos/src/gallery_thumbnails.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GalleryThumbnails(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="14" x="3" y="3" rx="2"></rect>
+            <path d="M4 21h1"></path>
+            <path d="M9 21h1"></path>
+            <path d="M14 21h1"></path>
+            <path d="M19 21h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gallery_vertical.rs b/packages/leptos/src/gallery_vertical.rs
new file mode 100644
index 0000000..cd89e4e
--- /dev/null
+++ b/packages/leptos/src/gallery_vertical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GalleryVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 2h18"></path>
+            <rect width="18" height="12" x="3" y="6" rx="2"></rect>
+            <path d="M3 22h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gallery_vertical_end.rs b/packages/leptos/src/gallery_vertical_end.rs
new file mode 100644
index 0000000..737a6fe
--- /dev/null
+++ b/packages/leptos/src/gallery_vertical_end.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GalleryVerticalEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 2h10"></path>
+            <path d="M5 6h14"></path>
+            <rect width="18" height="12" x="3" y="10" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gamepad.rs b/packages/leptos/src/gamepad.rs
new file mode 100644
index 0000000..8322610
--- /dev/null
+++ b/packages/leptos/src/gamepad.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Gamepad(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="6" x2="10" y1="12" y2="12"></line>
+            <line x1="8" x2="8" y1="10" y2="14"></line>
+            <line x1="15" x2="15.01" y1="13" y2="13"></line>
+            <line x1="18" x2="18.01" y1="11" y2="11"></line>
+            <rect width="20" height="12" x="2" y="6" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gamepad_2.rs b/packages/leptos/src/gamepad_2.rs
new file mode 100644
index 0000000..df0c542
--- /dev/null
+++ b/packages/leptos/src/gamepad_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Gamepad2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="6" x2="10" y1="11" y2="11"></line>
+            <line x1="8" x2="8" y1="9" y2="13"></line>
+            <line x1="15" x2="15.01" y1="12" y2="12"></line>
+            <line x1="18" x2="18.01" y1="10" y2="10"></line>
+            <path d="M17.32 5H6.68a4 4 0 0 0-3.978 3.59c-.006.052-.01.101-.017.152C2.604 9.416 2 14.456 2 16a3 3 0 0 0 3 3c1 0 1.5-.5 2-1l1.414-1.414A2 2 0 0 1 9.828 16h4.344a2 2 0 0 1 1.414.586L17 18c.5.5 1 1 2 1a3 3 0 0 0 3-3c0-1.545-.604-6.584-.685-7.258-.007-.05-.011-.1-.017-.151A4 4 0 0 0 17.32 5z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gauge.rs b/packages/leptos/src/gauge.rs
new file mode 100644
index 0000000..027fabd
--- /dev/null
+++ b/packages/leptos/src/gauge.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Gauge(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 14 4-4"></path>
+            <path d="M3.34 19a10 10 0 1 1 17.32 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gavel.rs b/packages/leptos/src/gavel.rs
new file mode 100644
index 0000000..a505ce3
--- /dev/null
+++ b/packages/leptos/src/gavel.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Gavel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14.5 12.5-8 8a2.119 2.119 0 1 1-3-3l8-8"></path>
+            <path d="m16 16 6-6"></path>
+            <path d="m8 8 6-6"></path>
+            <path d="m9 7 8 8"></path>
+            <path d="m21 11-8-8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gem.rs b/packages/leptos/src/gem.rs
new file mode 100644
index 0000000..ee78a06
--- /dev/null
+++ b/packages/leptos/src/gem.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Gem(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 3h12l4 6-10 13L2 9Z"></path>
+            <path d="M11 3 8 9l4 13 4-13-3-6"></path>
+            <path d="M2 9h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ghost.rs b/packages/leptos/src/ghost.rs
new file mode 100644
index 0000000..35a458b
--- /dev/null
+++ b/packages/leptos/src/ghost.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ghost(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 10h.01"></path>
+            <path d="M15 10h.01"></path>
+            <path d="M12 2a8 8 0 0 0-8 8v12l3-3 2.5 2.5L12 19l2.5 2.5L17 19l3 3V10a8 8 0 0 0-8-8z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gift.rs b/packages/leptos/src/gift.rs
new file mode 100644
index 0000000..08592bf
--- /dev/null
+++ b/packages/leptos/src/gift.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Gift(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="3" y="8" width="18" height="4" rx="1"></rect>
+            <path d="M12 8v13"></path>
+            <path d="M19 12v7a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2v-7"></path>
+            <path d="M7.5 8a2.5 2.5 0 0 1 0-5A4.8 8 0 0 1 12 8a4.8 8 0 0 1 4.5-5 2.5 2.5 0 0 1 0 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_branch.rs b/packages/leptos/src/git_branch.rs
new file mode 100644
index 0000000..105f1b2
--- /dev/null
+++ b/packages/leptos/src/git_branch.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitBranch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="6" x2="6" y1="3" y2="15"></line>
+            <circle cx="18" cy="6" r="3"></circle>
+            <circle cx="6" cy="18" r="3"></circle>
+            <path d="M18 9a9 9 0 0 1-9 9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_branch_plus.rs b/packages/leptos/src/git_branch_plus.rs
new file mode 100644
index 0000000..267a54e
--- /dev/null
+++ b/packages/leptos/src/git_branch_plus.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitBranchPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 3v12"></path>
+            <path d="M18 9a3 3 0 1 0 0-6 3 3 0 0 0 0 6z"></path>
+            <path d="M6 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6z"></path>
+            <path d="M15 6a9 9 0 0 0-9 9"></path>
+            <path d="M18 15v6"></path>
+            <path d="M21 18h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_commit_horizontal.rs b/packages/leptos/src/git_commit_horizontal.rs
new file mode 100644
index 0000000..d227fb7
--- /dev/null
+++ b/packages/leptos/src/git_commit_horizontal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitCommitHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3"></circle>
+            <line x1="3" x2="9" y1="12" y2="12"></line>
+            <line x1="15" x2="21" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_commit_vertical.rs b/packages/leptos/src/git_commit_vertical.rs
new file mode 100644
index 0000000..1f7f6e0
--- /dev/null
+++ b/packages/leptos/src/git_commit_vertical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitCommitVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v6"></path>
+            <circle cx="12" cy="12" r="3"></circle>
+            <path d="M12 15v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_compare.rs b/packages/leptos/src/git_compare.rs
new file mode 100644
index 0000000..d4b306e
--- /dev/null
+++ b/packages/leptos/src/git_compare.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitCompare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3"></circle>
+            <circle cx="6" cy="6" r="3"></circle>
+            <path d="M13 6h3a2 2 0 0 1 2 2v7"></path>
+            <path d="M11 18H8a2 2 0 0 1-2-2V9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_compare_arrows.rs b/packages/leptos/src/git_compare_arrows.rs
new file mode 100644
index 0000000..db4eb92
--- /dev/null
+++ b/packages/leptos/src/git_compare_arrows.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitCompareArrows(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="5" cy="6" r="3"></circle>
+            <path d="M12 6h5a2 2 0 0 1 2 2v7"></path>
+            <path d="m15 9-3-3 3-3"></path>
+            <circle cx="19" cy="18" r="3"></circle>
+            <path d="M12 18H7a2 2 0 0 1-2-2V9"></path>
+            <path d="m9 15 3 3-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_fork.rs b/packages/leptos/src/git_fork.rs
new file mode 100644
index 0000000..b09c9a0
--- /dev/null
+++ b/packages/leptos/src/git_fork.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitFork(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="18" r="3"></circle>
+            <circle cx="6" cy="6" r="3"></circle>
+            <circle cx="18" cy="6" r="3"></circle>
+            <path d="M18 9v2c0 .6-.4 1-1 1H7c-.6 0-1-.4-1-1V9"></path>
+            <path d="M12 12v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_graph.rs b/packages/leptos/src/git_graph.rs
new file mode 100644
index 0000000..2150b2c
--- /dev/null
+++ b/packages/leptos/src/git_graph.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitGraph(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="5" cy="6" r="3"></circle>
+            <path d="M5 9v6"></path>
+            <circle cx="5" cy="18" r="3"></circle>
+            <path d="M12 3v18"></path>
+            <circle cx="19" cy="6" r="3"></circle>
+            <path d="M16 15.7A9 9 0 0 0 19 9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_merge.rs b/packages/leptos/src/git_merge.rs
new file mode 100644
index 0000000..b66650e
--- /dev/null
+++ b/packages/leptos/src/git_merge.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitMerge(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3"></circle>
+            <circle cx="6" cy="6" r="3"></circle>
+            <path d="M6 21V9a9 9 0 0 0 9 9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_pull_request.rs b/packages/leptos/src/git_pull_request.rs
new file mode 100644
index 0000000..1697519
--- /dev/null
+++ b/packages/leptos/src/git_pull_request.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitPullRequest(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3"></circle>
+            <circle cx="6" cy="6" r="3"></circle>
+            <path d="M13 6h3a2 2 0 0 1 2 2v7"></path>
+            <line x1="6" x2="6" y1="9" y2="21"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_pull_request_arrow.rs b/packages/leptos/src/git_pull_request_arrow.rs
new file mode 100644
index 0000000..605113f
--- /dev/null
+++ b/packages/leptos/src/git_pull_request_arrow.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitPullRequestArrow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="5" cy="6" r="3"></circle>
+            <path d="M5 9v12"></path>
+            <circle cx="19" cy="18" r="3"></circle>
+            <path d="m15 9-3-3 3-3"></path>
+            <path d="M12 6h5a2 2 0 0 1 2 2v7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_pull_request_closed.rs b/packages/leptos/src/git_pull_request_closed.rs
new file mode 100644
index 0000000..41d3c39
--- /dev/null
+++ b/packages/leptos/src/git_pull_request_closed.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitPullRequestClosed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="6" r="3"></circle>
+            <path d="M6 9v12"></path>
+            <path d="m21 3-6 6"></path>
+            <path d="m21 9-6-6"></path>
+            <path d="M18 11.5V15"></path>
+            <circle cx="18" cy="18" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_pull_request_create.rs b/packages/leptos/src/git_pull_request_create.rs
new file mode 100644
index 0000000..2006414
--- /dev/null
+++ b/packages/leptos/src/git_pull_request_create.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitPullRequestCreate(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="6" r="3"></circle>
+            <path d="M6 9v12"></path>
+            <path d="M13 6h3a2 2 0 0 1 2 2v3"></path>
+            <path d="M18 15v6"></path>
+            <path d="M21 18h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_pull_request_create_arrow.rs b/packages/leptos/src/git_pull_request_create_arrow.rs
new file mode 100644
index 0000000..ac78329
--- /dev/null
+++ b/packages/leptos/src/git_pull_request_create_arrow.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitPullRequestCreateArrow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="5" cy="6" r="3"></circle>
+            <path d="M5 9v12"></path>
+            <path d="m15 9-3-3 3-3"></path>
+            <path d="M12 6h5a2 2 0 0 1 2 2v3"></path>
+            <path d="M19 15v6"></path>
+            <path d="M22 18h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/git_pull_request_draft.rs b/packages/leptos/src/git_pull_request_draft.rs
new file mode 100644
index 0000000..789940b
--- /dev/null
+++ b/packages/leptos/src/git_pull_request_draft.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GitPullRequestDraft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3"></circle>
+            <circle cx="6" cy="6" r="3"></circle>
+            <path d="M18 6V5"></path>
+            <path d="M18 11v-1"></path>
+            <line x1="6" x2="6" y1="9" y2="21"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/github.rs b/packages/leptos/src/github.rs
new file mode 100644
index 0000000..cc801a7
--- /dev/null
+++ b/packages/leptos/src/github.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Github(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4"></path>
+            <path d="M9 18c-4.51 2-5-2-7-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/gitlab.rs b/packages/leptos/src/gitlab.rs
new file mode 100644
index 0000000..36545f7
--- /dev/null
+++ b/packages/leptos/src/gitlab.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Gitlab(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m22 13.29-3.33-10a.42.42 0 0 0-.14-.18.38.38 0 0 0-.22-.11.39.39 0 0 0-.23.07.42.42 0 0 0-.14.18l-2.26 6.67H8.32L6.1 3.26a.42.42 0 0 0-.1-.18.38.38 0 0 0-.26-.08.39.39 0 0 0-.23.07.42.42 0 0 0-.14.18L2 13.29a.74.74 0 0 0 .27.83L12 21l9.69-6.88a.71.71 0 0 0 .31-.83Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/glass_water.rs b/packages/leptos/src/glass_water.rs
new file mode 100644
index 0000000..f8e3646
--- /dev/null
+++ b/packages/leptos/src/glass_water.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GlassWater(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5.116 4.104A1 1 0 0 1 6.11 3h11.78a1 1 0 0 1 .994 1.105L17.19 20.21A2 2 0 0 1 15.2 22H8.8a2 2 0 0 1-2-1.79z"></path>
+            <path d="M6 12a5 5 0 0 1 6 0 5 5 0 0 0 6 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/glasses.rs b/packages/leptos/src/glasses.rs
new file mode 100644
index 0000000..9ab4f3c
--- /dev/null
+++ b/packages/leptos/src/glasses.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Glasses(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="15" r="4"></circle>
+            <circle cx="18" cy="15" r="4"></circle>
+            <path d="M14 15a2 2 0 0 0-2-2 2 2 0 0 0-2 2"></path>
+            <path d="M2.5 13 5 7c.7-1.3 1.4-2 3-2"></path>
+            <path d="M21.5 13 19 7c-.7-1.3-1.5-2-3-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/globe.rs b/packages/leptos/src/globe.rs
new file mode 100644
index 0000000..f0285bf
--- /dev/null
+++ b/packages/leptos/src/globe.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Globe(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"></path>
+            <path d="M2 12h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/globe_lock.rs b/packages/leptos/src/globe_lock.rs
new file mode 100644
index 0000000..501529e
--- /dev/null
+++ b/packages/leptos/src/globe_lock.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GlobeLock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.686 15A14.5 14.5 0 0 1 12 22a14.5 14.5 0 0 1 0-20 10 10 0 1 0 9.542 13"></path>
+            <path d="M2 12h8.5"></path>
+            <path d="M20 6V4a2 2 0 1 0-4 0v2"></path>
+            <rect width="8" height="5" x="14" y="6" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/goal.rs b/packages/leptos/src/goal.rs
new file mode 100644
index 0000000..9329427
--- /dev/null
+++ b/packages/leptos/src/goal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Goal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V2l8 4-8 4"></path>
+            <path d="M20.561 10.222a9 9 0 1 1-12.55-5.29"></path>
+            <path d="M8.002 9.997a5 5 0 1 0 8.9 2.02"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grab.rs b/packages/leptos/src/grab.rs
new file mode 100644
index 0000000..b2eee45
--- /dev/null
+++ b/packages/leptos/src/grab.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Grab(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 11.5V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1.4"></path>
+            <path d="M14 10V8a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2"></path>
+            <path d="M10 9.9V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v5"></path>
+            <path d="M6 14a2 2 0 0 0-2-2a2 2 0 0 0-2 2"></path>
+            <path d="M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-4a8 8 0 0 1-8-8 2 2 0 1 1 4 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/graduation_cap.rs b/packages/leptos/src/graduation_cap.rs
new file mode 100644
index 0000000..a46d577
--- /dev/null
+++ b/packages/leptos/src/graduation_cap.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GraduationCap(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.42 10.922a1 1 0 0 0-.019-1.838L12.83 5.18a2 2 0 0 0-1.66 0L2.6 9.08a1 1 0 0 0 0 1.832l8.57 3.908a2 2 0 0 0 1.66 0z"></path>
+            <path d="M22 10v6"></path>
+            <path d="M6 12.5V16a6 3 0 0 0 12 0v-3.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grape.rs b/packages/leptos/src/grape.rs
new file mode 100644
index 0000000..a17bc6b
--- /dev/null
+++ b/packages/leptos/src/grape.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Grape(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 5V2l-5.89 5.89"></path>
+            <circle cx="16.6" cy="15.89" r="3"></circle>
+            <circle cx="8.11" cy="7.4" r="3"></circle>
+            <circle cx="12.35" cy="11.65" r="3"></circle>
+            <circle cx="13.91" cy="5.85" r="3"></circle>
+            <circle cx="18.15" cy="10.09" r="3"></circle>
+            <circle cx="6.56" cy="13.2" r="3"></circle>
+            <circle cx="10.8" cy="17.44" r="3"></circle>
+            <circle cx="5" cy="19" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grid_2_x_2.rs b/packages/leptos/src/grid_2_x_2.rs
new file mode 100644
index 0000000..e4300ca
--- /dev/null
+++ b/packages/leptos/src/grid_2_x_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Grid2X2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 12h18"></path>
+            <path d="M12 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grid_2_x_2_check.rs b/packages/leptos/src/grid_2_x_2_check.rs
new file mode 100644
index 0000000..a7ca2ba
--- /dev/null
+++ b/packages/leptos/src/grid_2_x_2_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Grid2X2Check(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"></path>
+            <path d="m16 19 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grid_2_x_2_plus.rs b/packages/leptos/src/grid_2_x_2_plus.rs
new file mode 100644
index 0000000..3882193
--- /dev/null
+++ b/packages/leptos/src/grid_2_x_2_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Grid2X2Plus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"></path>
+            <path d="M16 19h6"></path>
+            <path d="M19 22v-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grid_2_x_2_x.rs b/packages/leptos/src/grid_2_x_2_x.rs
new file mode 100644
index 0000000..a8c635d
--- /dev/null
+++ b/packages/leptos/src/grid_2_x_2_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Grid2X2X(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"></path>
+            <path d="m16 16 5 5"></path>
+            <path d="m16 21 5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grid_3_x_3.rs b/packages/leptos/src/grid_3_x_3.rs
new file mode 100644
index 0000000..d90250c
--- /dev/null
+++ b/packages/leptos/src/grid_3_x_3.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Grid3X3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 9h18"></path>
+            <path d="M3 15h18"></path>
+            <path d="M9 3v18"></path>
+            <path d="M15 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grip.rs b/packages/leptos/src/grip.rs
new file mode 100644
index 0000000..aee2576
--- /dev/null
+++ b/packages/leptos/src/grip.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Grip(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="5" r="1"></circle>
+            <circle cx="19" cy="5" r="1"></circle>
+            <circle cx="5" cy="5" r="1"></circle>
+            <circle cx="12" cy="12" r="1"></circle>
+            <circle cx="19" cy="12" r="1"></circle>
+            <circle cx="5" cy="12" r="1"></circle>
+            <circle cx="12" cy="19" r="1"></circle>
+            <circle cx="19" cy="19" r="1"></circle>
+            <circle cx="5" cy="19" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grip_horizontal.rs b/packages/leptos/src/grip_horizontal.rs
new file mode 100644
index 0000000..3b1f6a9
--- /dev/null
+++ b/packages/leptos/src/grip_horizontal.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GripHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="9" r="1"></circle>
+            <circle cx="19" cy="9" r="1"></circle>
+            <circle cx="5" cy="9" r="1"></circle>
+            <circle cx="12" cy="15" r="1"></circle>
+            <circle cx="19" cy="15" r="1"></circle>
+            <circle cx="5" cy="15" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/grip_vertical.rs b/packages/leptos/src/grip_vertical.rs
new file mode 100644
index 0000000..4993389
--- /dev/null
+++ b/packages/leptos/src/grip_vertical.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn GripVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="9" cy="12" r="1"></circle>
+            <circle cx="9" cy="5" r="1"></circle>
+            <circle cx="9" cy="19" r="1"></circle>
+            <circle cx="15" cy="12" r="1"></circle>
+            <circle cx="15" cy="5" r="1"></circle>
+            <circle cx="15" cy="19" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/group.rs b/packages/leptos/src/group.rs
new file mode 100644
index 0000000..75c8076
--- /dev/null
+++ b/packages/leptos/src/group.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Group(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5c0-1.1.9-2 2-2h2"></path>
+            <path d="M17 3h2c1.1 0 2 .9 2 2v2"></path>
+            <path d="M21 17v2c0 1.1-.9 2-2 2h-2"></path>
+            <path d="M7 21H5c-1.1 0-2-.9-2-2v-2"></path>
+            <rect width="7" height="5" x="7" y="7" rx="1"></rect>
+            <rect width="7" height="5" x="10" y="12" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/guitar.rs b/packages/leptos/src/guitar.rs
new file mode 100644
index 0000000..a8ddbfa
--- /dev/null
+++ b/packages/leptos/src/guitar.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Guitar(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11.9 12.1 4.514-4.514"></path>
+            <path d="M20.1 2.3a1 1 0 0 0-1.4 0l-1.114 1.114A2 2 0 0 0 17 4.828v1.344a2 2 0 0 1-.586 1.414A2 2 0 0 1 17.828 7h1.344a2 2 0 0 0 1.414-.586L21.7 5.3a1 1 0 0 0 0-1.4z"></path>
+            <path d="m6 16 2 2"></path>
+            <path d="M8.2 9.9C8.7 8.8 9.8 8 11 8c2.8 0 5 2.2 5 5 0 1.2-.8 2.3-1.9 2.8l-.9.4A2 2 0 0 0 12 18a4 4 0 0 1-4 4c-3.3 0-6-2.7-6-6a4 4 0 0 1 4-4 2 2 0 0 0 1.8-1.2z"></path>
+            <circle cx="11.5" cy="12.5" r=".5" fill="currentColor"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ham.rs b/packages/leptos/src/ham.rs
new file mode 100644
index 0000000..8eb8764
--- /dev/null
+++ b/packages/leptos/src/ham.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ham(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.144 21.144A7.274 10.445 45 1 0 2.856 10.856"></path>
+            <path d="M13.144 21.144A7.274 4.365 45 0 0 2.856 10.856a7.274 4.365 45 0 0 10.288 10.288"></path>
+            <path d="M16.565 10.435 18.6 8.4a2.501 2.501 0 1 0 1.65-4.65 2.5 2.5 0 1 0-4.66 1.66l-2.024 2.025"></path>
+            <path d="m8.5 16.5-1-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hammer.rs b/packages/leptos/src/hammer.rs
new file mode 100644
index 0000000..6f24a70
--- /dev/null
+++ b/packages/leptos/src/hammer.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Hammer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 12-8.373 8.373a1 1 0 1 1-3-3L12 9"></path>
+            <path d="m18 15 4-4"></path>
+            <path d="m21.5 11.5-1.914-1.914A2 2 0 0 1 19 8.172V7l-2.26-2.26a6 6 0 0 0-4.202-1.756L9 2.96l.92.82A6.18 6.18 0 0 1 12 8.4V10l2 2h1.172a2 2 0 0 1 1.414.586L18.5 14.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hand.rs b/packages/leptos/src/hand.rs
new file mode 100644
index 0000000..c81dbf0
--- /dev/null
+++ b/packages/leptos/src/hand.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Hand(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 11V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2"></path>
+            <path d="M14 10V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2"></path>
+            <path d="M10 10.5V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2v8"></path>
+            <path d="M18 8a2 2 0 1 1 4 0v6a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hand_coins.rs b/packages/leptos/src/hand_coins.rs
new file mode 100644
index 0000000..d37ccb4
--- /dev/null
+++ b/packages/leptos/src/hand_coins.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HandCoins(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 15h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 17"></path>
+            <path d="m7 21 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9"></path>
+            <path d="m2 16 6 6"></path>
+            <circle cx="16" cy="9" r="2.9"></circle>
+            <circle cx="6" cy="5" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hand_heart.rs b/packages/leptos/src/hand_heart.rs
new file mode 100644
index 0000000..41d4d9a
--- /dev/null
+++ b/packages/leptos/src/hand_heart.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HandHeart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 14h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 16"></path>
+            <path d="m7 20 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9"></path>
+            <path d="m2 15 6 6"></path>
+            <path d="M19.5 8.5c.7-.7 1.5-1.6 1.5-2.7A2.73 2.73 0 0 0 16 4a2.78 2.78 0 0 0-5 1.8c0 1.2.8 2 1.5 2.8L16 12Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hand_helping.rs b/packages/leptos/src/hand_helping.rs
new file mode 100644
index 0000000..0725882
--- /dev/null
+++ b/packages/leptos/src/hand_helping.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HandHelping(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 12h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 14"></path>
+            <path d="m7 18 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9"></path>
+            <path d="m2 13 6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hand_metal.rs b/packages/leptos/src/hand_metal.rs
new file mode 100644
index 0000000..c07f606
--- /dev/null
+++ b/packages/leptos/src/hand_metal.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HandMetal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 12.5V10a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1.4"></path>
+            <path d="M14 11V9a2 2 0 1 0-4 0v2"></path>
+            <path d="M10 10.5V5a2 2 0 1 0-4 0v9"></path>
+            <path d="m7 15-1.76-1.76a2 2 0 0 0-2.83 2.82l3.6 3.6C7.5 21.14 9.2 22 12 22h2a8 8 0 0 0 8-8V7a2 2 0 1 0-4 0v5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hand_platter.rs b/packages/leptos/src/hand_platter.rs
new file mode 100644
index 0000000..6451ae6
--- /dev/null
+++ b/packages/leptos/src/hand_platter.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HandPlatter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3V2"></path>
+            <path d="m15.4 17.4 3.2-2.8a2 2 0 1 1 2.8 2.9l-3.6 3.3c-.7.8-1.7 1.2-2.8 1.2h-4c-1.1 0-2.1-.4-2.8-1.2l-1.302-1.464A1 1 0 0 0 6.151 19H5"></path>
+            <path d="M2 14h12a2 2 0 0 1 0 4h-2"></path>
+            <path d="M4 10h16"></path>
+            <path d="M5 10a7 7 0 0 1 14 0"></path>
+            <path d="M5 14v6a1 1 0 0 1-1 1H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/handshake.rs b/packages/leptos/src/handshake.rs
new file mode 100644
index 0000000..177867e
--- /dev/null
+++ b/packages/leptos/src/handshake.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Handshake(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11 17 2 2a1 1 0 1 0 3-3"></path>
+            <path d="m14 14 2.5 2.5a1 1 0 1 0 3-3l-3.88-3.88a3 3 0 0 0-4.24 0l-.88.88a1 1 0 1 1-3-3l2.81-2.81a5.79 5.79 0 0 1 7.06-.87l.47.28a2 2 0 0 0 1.42.25L21 4"></path>
+            <path d="m21 3 1 11h-2"></path>
+            <path d="M3 3 2 14l6.5 6.5a1 1 0 1 0 3-3"></path>
+            <path d="M3 4h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hard_drive.rs b/packages/leptos/src/hard_drive.rs
new file mode 100644
index 0000000..dcacc4f
--- /dev/null
+++ b/packages/leptos/src/hard_drive.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HardDrive(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="22" x2="2" y1="12" y2="12"></line>
+            <path d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"></path>
+            <line x1="6" x2="6.01" y1="16" y2="16"></line>
+            <line x1="10" x2="10.01" y1="16" y2="16"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hard_drive_download.rs b/packages/leptos/src/hard_drive_download.rs
new file mode 100644
index 0000000..d718871
--- /dev/null
+++ b/packages/leptos/src/hard_drive_download.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HardDriveDownload(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v8"></path>
+            <path d="m16 6-4 4-4-4"></path>
+            <rect width="20" height="8" x="2" y="14" rx="2"></rect>
+            <path d="M6 18h.01"></path>
+            <path d="M10 18h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hard_drive_upload.rs b/packages/leptos/src/hard_drive_upload.rs
new file mode 100644
index 0000000..95796b2
--- /dev/null
+++ b/packages/leptos/src/hard_drive_upload.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HardDriveUpload(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 6-4-4-4 4"></path>
+            <path d="M12 2v8"></path>
+            <rect width="20" height="8" x="2" y="14" rx="2"></rect>
+            <path d="M6 18h.01"></path>
+            <path d="M10 18h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hard_hat.rs b/packages/leptos/src/hard_hat.rs
new file mode 100644
index 0000000..f299173
--- /dev/null
+++ b/packages/leptos/src/hard_hat.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HardHat(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10V5a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v5"></path>
+            <path d="M14 6a6 6 0 0 1 6 6v3"></path>
+            <path d="M4 15v-3a6 6 0 0 1 6-6"></path>
+            <rect x="2" y="15" width="20" height="4" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hash.rs b/packages/leptos/src/hash.rs
new file mode 100644
index 0000000..58dc5f8
--- /dev/null
+++ b/packages/leptos/src/hash.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Hash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="4" x2="20" y1="9" y2="9"></line>
+            <line x1="4" x2="20" y1="15" y2="15"></line>
+            <line x1="10" x2="8" y1="3" y2="21"></line>
+            <line x1="16" x2="14" y1="3" y2="21"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/haze.rs b/packages/leptos/src/haze.rs
new file mode 100644
index 0000000..28e9bb7
--- /dev/null
+++ b/packages/leptos/src/haze.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Haze(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5.2 6.2 1.4 1.4"></path>
+            <path d="M2 13h2"></path>
+            <path d="M20 13h2"></path>
+            <path d="m17.4 7.6 1.4-1.4"></path>
+            <path d="M22 17H2"></path>
+            <path d="M22 21H2"></path>
+            <path d="M16 13a4 4 0 0 0-8 0"></path>
+            <path d="M12 5V2.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hdmi_port.rs b/packages/leptos/src/hdmi_port.rs
new file mode 100644
index 0000000..cbcbe87
--- /dev/null
+++ b/packages/leptos/src/hdmi_port.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HdmiPort(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 9a1 1 0 0 0-1-1H3a1 1 0 0 0-1 1v4a1 1 0 0 0 1 1h1l2 2h12l2-2h1a1 1 0 0 0 1-1Z"></path>
+            <path d="M7.5 12h9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heading.rs b/packages/leptos/src/heading.rs
new file mode 100644
index 0000000..a21cbce
--- /dev/null
+++ b/packages/leptos/src/heading.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heading(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 12h12"></path>
+            <path d="M6 20V4"></path>
+            <path d="M18 20V4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heading_1.rs b/packages/leptos/src/heading_1.rs
new file mode 100644
index 0000000..5544f05
--- /dev/null
+++ b/packages/leptos/src/heading_1.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heading1(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8"></path>
+            <path d="M4 18V6"></path>
+            <path d="M12 18V6"></path>
+            <path d="m17 12 3-2v8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heading_2.rs b/packages/leptos/src/heading_2.rs
new file mode 100644
index 0000000..76d2d3c
--- /dev/null
+++ b/packages/leptos/src/heading_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heading2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8"></path>
+            <path d="M4 18V6"></path>
+            <path d="M12 18V6"></path>
+            <path d="M21 18h-4c0-4 4-3 4-6 0-1.5-2-2.5-4-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heading_3.rs b/packages/leptos/src/heading_3.rs
new file mode 100644
index 0000000..7bb0f92
--- /dev/null
+++ b/packages/leptos/src/heading_3.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heading3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8"></path>
+            <path d="M4 18V6"></path>
+            <path d="M12 18V6"></path>
+            <path d="M17.5 10.5c1.7-1 3.5 0 3.5 1.5a2 2 0 0 1-2 2"></path>
+            <path d="M17 17.5c2 1.5 4 .3 4-1.5a2 2 0 0 0-2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heading_4.rs b/packages/leptos/src/heading_4.rs
new file mode 100644
index 0000000..e76a9fa
--- /dev/null
+++ b/packages/leptos/src/heading_4.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heading4(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 18V6"></path>
+            <path d="M17 10v3a1 1 0 0 0 1 1h3"></path>
+            <path d="M21 10v8"></path>
+            <path d="M4 12h8"></path>
+            <path d="M4 18V6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heading_5.rs b/packages/leptos/src/heading_5.rs
new file mode 100644
index 0000000..34edfa1
--- /dev/null
+++ b/packages/leptos/src/heading_5.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heading5(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8"></path>
+            <path d="M4 18V6"></path>
+            <path d="M12 18V6"></path>
+            <path d="M17 13v-3h4"></path>
+            <path d="M17 17.7c.4.2.8.3 1.3.3 1.5 0 2.7-1.1 2.7-2.5S19.8 13 18.3 13H17"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heading_6.rs b/packages/leptos/src/heading_6.rs
new file mode 100644
index 0000000..a87f4c4
--- /dev/null
+++ b/packages/leptos/src/heading_6.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heading6(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8"></path>
+            <path d="M4 18V6"></path>
+            <path d="M12 18V6"></path>
+            <circle cx="19" cy="16" r="2"></circle>
+            <path d="M20 10c-2 2-3 3.5-3 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/headphone_off.rs b/packages/leptos/src/headphone_off.rs
new file mode 100644
index 0000000..4bc70b2
--- /dev/null
+++ b/packages/leptos/src/headphone_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HeadphoneOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 14h-1.343"></path>
+            <path d="M9.128 3.47A9 9 0 0 1 21 12v3.343"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M20.414 20.414A2 2 0 0 1 19 21h-1a2 2 0 0 1-2-2v-3"></path>
+            <path d="M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 2.636-6.364"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/headphones.rs b/packages/leptos/src/headphones.rs
new file mode 100644
index 0000000..9daf413
--- /dev/null
+++ b/packages/leptos/src/headphones.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Headphones(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 18 0v7a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/headset.rs b/packages/leptos/src/headset.rs
new file mode 100644
index 0000000..19387bf
--- /dev/null
+++ b/packages/leptos/src/headset.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Headset(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 11h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-5Zm0 0a9 9 0 1 1 18 0m0 0v5a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3Z"></path>
+            <path d="M21 16v2a4 4 0 0 1-4 4h-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heart.rs b/packages/leptos/src/heart.rs
new file mode 100644
index 0000000..93402eb
--- /dev/null
+++ b/packages/leptos/src/heart.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heart_crack.rs b/packages/leptos/src/heart_crack.rs
new file mode 100644
index 0000000..912d9f9
--- /dev/null
+++ b/packages/leptos/src/heart_crack.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HeartCrack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"></path>
+            <path d="m12 13-1-1 2-2-3-3 2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heart_handshake.rs b/packages/leptos/src/heart_handshake.rs
new file mode 100644
index 0000000..b1ff815
--- /dev/null
+++ b/packages/leptos/src/heart_handshake.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HeartHandshake(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"></path>
+            <path d="M12 5 9.04 7.96a2.17 2.17 0 0 0 0 3.08c.82.82 2.13.85 3 .07l2.07-1.9a2.82 2.82 0 0 1 3.79 0l2.96 2.66"></path>
+            <path d="m18 15-2-2"></path>
+            <path d="m15 18-2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heart_off.rs b/packages/leptos/src/heart_off.rs
new file mode 100644
index 0000000..a715164
--- /dev/null
+++ b/packages/leptos/src/heart_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HeartOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" y1="2" x2="22" y2="22"></line>
+            <path d="M16.5 16.5 12 21l-7-7c-1.5-1.45-3-3.2-3-5.5a5.5 5.5 0 0 1 2.14-4.35"></path>
+            <path d="M8.76 3.1c1.15.22 2.13.78 3.24 1.9 1.5-1.5 2.74-2 4.5-2A5.5 5.5 0 0 1 22 8.5c0 2.12-1.3 3.78-2.67 5.17"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heart_pulse.rs b/packages/leptos/src/heart_pulse.rs
new file mode 100644
index 0000000..e40931d
--- /dev/null
+++ b/packages/leptos/src/heart_pulse.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HeartPulse(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"></path>
+            <path d="M3.22 12H9.5l.5-1 2 4.5 2-7 1.5 3.5h5.27"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/heater.rs b/packages/leptos/src/heater.rs
new file mode 100644
index 0000000..46a5062
--- /dev/null
+++ b/packages/leptos/src/heater.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Heater(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 8c2-3-2-3 0-6"></path>
+            <path d="M15.5 8c2-3-2-3 0-6"></path>
+            <path d="M6 10h.01"></path>
+            <path d="M6 14h.01"></path>
+            <path d="M10 16v-4"></path>
+            <path d="M14 16v-4"></path>
+            <path d="M18 16v-4"></path>
+            <path d="M20 6a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3"></path>
+            <path d="M5 20v2"></path>
+            <path d="M19 20v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hexagon.rs b/packages/leptos/src/hexagon.rs
new file mode 100644
index 0000000..37c5017
--- /dev/null
+++ b/packages/leptos/src/hexagon.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Hexagon(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/highlighter.rs b/packages/leptos/src/highlighter.rs
new file mode 100644
index 0000000..33c226a
--- /dev/null
+++ b/packages/leptos/src/highlighter.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Highlighter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 11-6 6v3h9l3-3"></path>
+            <path d="m22 12-4.6 4.6a2 2 0 0 1-2.8 0l-5.2-5.2a2 2 0 0 1 0-2.8L14 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/history.rs b/packages/leptos/src/history.rs
new file mode 100644
index 0000000..9230b36
--- /dev/null
+++ b/packages/leptos/src/history.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn History(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"></path>
+            <path d="M3 3v5h5"></path>
+            <path d="M12 7v5l4 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hop.rs b/packages/leptos/src/hop.rs
new file mode 100644
index 0000000..3a343d3
--- /dev/null
+++ b/packages/leptos/src/hop.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Hop(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.82 16.12c1.69.6 3.91.79 5.18.85.55.03 1-.42.97-.97-.06-1.27-.26-3.5-.85-5.18"></path>
+            <path d="M11.5 6.5c1.64 0 5-.38 6.71-1.07.52-.2.55-.82.12-1.17A10 10 0 0 0 4.26 18.33c.35.43.96.4 1.17-.12.69-1.71 1.07-5.07 1.07-6.71 1.34.45 3.1.9 4.88.62a.88.88 0 0 0 .73-.74c.3-2.14-.15-3.5-.61-4.88"></path>
+            <path d="M15.62 16.95c.2.85.62 2.76.5 4.28a.77.77 0 0 1-.9.7 16.64 16.64 0 0 1-4.08-1.36"></path>
+            <path d="M16.13 21.05c1.65.63 3.68.84 4.87.91a.9.9 0 0 0 .96-.96 17.68 17.68 0 0 0-.9-4.87"></path>
+            <path d="M16.94 15.62c.86.2 2.77.62 4.29.5a.77.77 0 0 0 .7-.9 16.64 16.64 0 0 0-1.36-4.08"></path>
+            <path d="M17.99 5.52a20.82 20.82 0 0 1 3.15 4.5.8.8 0 0 1-.68 1.13c-2.33.2-5.3-.32-8.27-1.57"></path>
+            <path d="M4.93 4.93 3 3a.7.7 0 0 1 0-1"></path>
+            <path d="M9.58 12.18c1.24 2.98 1.77 5.95 1.57 8.28a.8.8 0 0 1-1.13.68 20.82 20.82 0 0 1-4.5-3.15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hop_off.rs b/packages/leptos/src/hop_off.rs
new file mode 100644
index 0000000..3b4b8ba
--- /dev/null
+++ b/packages/leptos/src/hop_off.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HopOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.82 16.12c1.69.6 3.91.79 5.18.85.28.01.53-.09.7-.27"></path>
+            <path d="M11.14 20.57c.52.24 2.44 1.12 4.08 1.37.46.06.86-.25.9-.71.12-1.52-.3-3.43-.5-4.28"></path>
+            <path d="M16.13 21.05c1.65.63 3.68.84 4.87.91a.9.9 0 0 0 .7-.26"></path>
+            <path d="M17.99 5.52a20.83 20.83 0 0 1 3.15 4.5.8.8 0 0 1-.68 1.13c-1.17.1-2.5.02-3.9-.25"></path>
+            <path d="M20.57 11.14c.24.52 1.12 2.44 1.37 4.08.04.3-.08.59-.31.75"></path>
+            <path d="M4.93 4.93a10 10 0 0 0-.67 13.4c.35.43.96.4 1.17-.12.69-1.71 1.07-5.07 1.07-6.71 1.34.45 3.1.9 4.88.62a.85.85 0 0 0 .48-.24"></path>
+            <path d="M5.52 17.99c1.05.95 2.91 2.42 4.5 3.15a.8.8 0 0 0 1.13-.68c.2-2.34-.33-5.3-1.57-8.28"></path>
+            <path d="M8.35 2.68a10 10 0 0 1 9.98 1.58c.43.35.4.96-.12 1.17-1.5.6-4.3.98-6.07 1.05"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hospital.rs b/packages/leptos/src/hospital.rs
new file mode 100644
index 0000000..79cddec
--- /dev/null
+++ b/packages/leptos/src/hospital.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Hospital(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v4"></path>
+            <path d="M14 14h-4"></path>
+            <path d="M14 18h-4"></path>
+            <path d="M14 8h-4"></path>
+            <path d="M18 12h2a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-9a2 2 0 0 1 2-2h2"></path>
+            <path d="M18 22V4a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hotel.rs b/packages/leptos/src/hotel.rs
new file mode 100644
index 0000000..445c595
--- /dev/null
+++ b/packages/leptos/src/hotel.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Hotel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 22v-6.57"></path>
+            <path d="M12 11h.01"></path>
+            <path d="M12 7h.01"></path>
+            <path d="M14 15.43V22"></path>
+            <path d="M15 16a5 5 0 0 0-6 0"></path>
+            <path d="M16 11h.01"></path>
+            <path d="M16 7h.01"></path>
+            <path d="M8 11h.01"></path>
+            <path d="M8 7h.01"></path>
+            <rect x="4" y="2" width="16" height="20" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/hourglass.rs b/packages/leptos/src/hourglass.rs
new file mode 100644
index 0000000..d083408
--- /dev/null
+++ b/packages/leptos/src/hourglass.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Hourglass(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 22h14"></path>
+            <path d="M5 2h14"></path>
+            <path d="M17 22v-4.172a2 2 0 0 0-.586-1.414L12 12l-4.414 4.414A2 2 0 0 0 7 17.828V22"></path>
+            <path d="M7 2v4.172a2 2 0 0 0 .586 1.414L12 12l4.414-4.414A2 2 0 0 0 17 6.172V2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/house.rs b/packages/leptos/src/house.rs
new file mode 100644
index 0000000..b37a72c
--- /dev/null
+++ b/packages/leptos/src/house.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn House(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8"></path>
+            <path d="M3 10a2 2 0 0 1 .709-1.528l7-5.999a2 2 0 0 1 2.582 0l7 5.999A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/house_plug.rs b/packages/leptos/src/house_plug.rs
new file mode 100644
index 0000000..6e307eb
--- /dev/null
+++ b/packages/leptos/src/house_plug.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HousePlug(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 12V8.964"></path>
+            <path d="M14 12V8.964"></path>
+            <path d="M15 12a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2v-2a1 1 0 0 1 1-1z"></path>
+            <path d="M8.5 21H5a2 2 0 0 1-2-2v-9a2 2 0 0 1 .709-1.528l7-5.999a2 2 0 0 1 2.582 0l7 5.999A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2h-5a2 2 0 0 1-2-2v-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/house_plus.rs b/packages/leptos/src/house_plus.rs
new file mode 100644
index 0000000..4f16321
--- /dev/null
+++ b/packages/leptos/src/house_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn HousePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.22 2.416a2 2 0 0 0-2.511.057l-7 5.999A2 2 0 0 0 3 10v9a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7.354"></path>
+            <path d="M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8"></path>
+            <path d="M15 6h6"></path>
+            <path d="M18 3v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ice_cream_bowl.rs b/packages/leptos/src/ice_cream_bowl.rs
new file mode 100644
index 0000000..ea077ce
--- /dev/null
+++ b/packages/leptos/src/ice_cream_bowl.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn IceCreamBowl(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17c5 0 8-2.69 8-6H4c0 3.31 3 6 8 6m-4 4h8m-4-3v3M5.14 11a3.5 3.5 0 1 1 6.71 0"></path>
+            <path d="M12.14 11a3.5 3.5 0 1 1 6.71 0"></path>
+            <path d="M15.5 6.5a3.5 3.5 0 1 0-7 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ice_cream_cone.rs b/packages/leptos/src/ice_cream_cone.rs
new file mode 100644
index 0000000..72d0aeb
--- /dev/null
+++ b/packages/leptos/src/ice_cream_cone.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn IceCreamCone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 11 4.08 10.35a1 1 0 0 0 1.84 0L17 11"></path>
+            <path d="M17 7A5 5 0 0 0 7 7"></path>
+            <path d="M17 7a2 2 0 0 1 0 4H7a2 2 0 0 1 0-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/id_card.rs b/packages/leptos/src/id_card.rs
new file mode 100644
index 0000000..b345686
--- /dev/null
+++ b/packages/leptos/src/id_card.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn IdCard(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 10h2"></path>
+            <path d="M16 14h2"></path>
+            <path d="M6.17 15a3 3 0 0 1 5.66 0"></path>
+            <circle cx="9" cy="11" r="2"></circle>
+            <rect x="2" y="5" width="20" height="14" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/image.rs b/packages/leptos/src/image.rs
new file mode 100644
index 0000000..788c782
--- /dev/null
+++ b/packages/leptos/src/image.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Image(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <circle cx="9" cy="9" r="2"></circle>
+            <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/image_down.rs b/packages/leptos/src/image_down.rs
new file mode 100644
index 0000000..3685410
--- /dev/null
+++ b/packages/leptos/src/image_down.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ImageDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.3 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10l-3.1-3.1a2 2 0 0 0-2.814.014L6 21"></path>
+            <path d="m14 19 3 3v-5.5"></path>
+            <path d="m17 22 3-3"></path>
+            <circle cx="9" cy="9" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/image_minus.rs b/packages/leptos/src/image_minus.rs
new file mode 100644
index 0000000..9acb5d1
--- /dev/null
+++ b/packages/leptos/src/image_minus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ImageMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 9v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7"></path>
+            <line x1="16" x2="22" y1="5" y2="5"></line>
+            <circle cx="9" cy="9" r="2"></circle>
+            <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/image_off.rs b/packages/leptos/src/image_off.rs
new file mode 100644
index 0000000..a929c6a
--- /dev/null
+++ b/packages/leptos/src/image_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ImageOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+            <path d="M10.41 10.41a2 2 0 1 1-2.83-2.83"></path>
+            <line x1="13.5" x2="6" y1="13.5" y2="21"></line>
+            <line x1="18" x2="21" y1="12" y2="15"></line>
+            <path d="M3.59 3.59A1.99 1.99 0 0 0 3 5v14a2 2 0 0 0 2 2h14c.55 0 1.052-.22 1.41-.59"></path>
+            <path d="M21 15V5a2 2 0 0 0-2-2H9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/image_play.rs b/packages/leptos/src/image_play.rs
new file mode 100644
index 0000000..91c6a0d
--- /dev/null
+++ b/packages/leptos/src/image_play.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ImagePlay(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11 16-5 5"></path>
+            <path d="M11 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6.5"></path>
+            <path d="M15.765 22a.5.5 0 0 1-.765-.424V13.38a.5.5 0 0 1 .765-.424l5.878 3.674a1 1 0 0 1 0 1.696z"></path>
+            <circle cx="9" cy="9" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/image_plus.rs b/packages/leptos/src/image_plus.rs
new file mode 100644
index 0000000..8cccf84
--- /dev/null
+++ b/packages/leptos/src/image_plus.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ImagePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 5h6"></path>
+            <path d="M19 2v6"></path>
+            <path d="M21 11.5V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7.5"></path>
+            <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"></path>
+            <circle cx="9" cy="9" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/image_up.rs b/packages/leptos/src/image_up.rs
new file mode 100644
index 0000000..5ba01fc
--- /dev/null
+++ b/packages/leptos/src/image_up.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ImageUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.3 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10l-3.1-3.1a2 2 0 0 0-2.814.014L6 21"></path>
+            <path d="m14 19.5 3-3 3 3"></path>
+            <path d="M17 22v-5.5"></path>
+            <circle cx="9" cy="9" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/images.rs b/packages/leptos/src/images.rs
new file mode 100644
index 0000000..6e98242
--- /dev/null
+++ b/packages/leptos/src/images.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Images(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 22H4a2 2 0 0 1-2-2V6"></path>
+            <path d="m22 13-1.296-1.296a2.41 2.41 0 0 0-3.408 0L11 18"></path>
+            <circle cx="12" cy="8" r="2"></circle>
+            <rect width="16" height="16" x="6" y="2" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/import.rs b/packages/leptos/src/import.rs
new file mode 100644
index 0000000..cc8d893
--- /dev/null
+++ b/packages/leptos/src/import.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Import(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v12"></path>
+            <path d="m8 11 4 4 4-4"></path>
+            <path d="M8 5H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/inbox.rs b/packages/leptos/src/inbox.rs
new file mode 100644
index 0000000..946d050
--- /dev/null
+++ b/packages/leptos/src/inbox.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Inbox(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="22 12 16 12 14 15 10 15 8 12 2 12"></polyline>
+            <path d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/indent_decrease.rs b/packages/leptos/src/indent_decrease.rs
new file mode 100644
index 0000000..12f641c
--- /dev/null
+++ b/packages/leptos/src/indent_decrease.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn IndentDecrease(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12H11"></path>
+            <path d="M21 18H11"></path>
+            <path d="M21 6H11"></path>
+            <path d="m7 8-4 4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/indent_increase.rs b/packages/leptos/src/indent_increase.rs
new file mode 100644
index 0000000..8a67dea
--- /dev/null
+++ b/packages/leptos/src/indent_increase.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn IndentIncrease(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12H11"></path>
+            <path d="M21 18H11"></path>
+            <path d="M21 6H11"></path>
+            <path d="m3 8 4 4-4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/indian_rupee.rs b/packages/leptos/src/indian_rupee.rs
new file mode 100644
index 0000000..76a65e9
--- /dev/null
+++ b/packages/leptos/src/indian_rupee.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn IndianRupee(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 3h12"></path>
+            <path d="M6 8h12"></path>
+            <path d="m6 13 8.5 8"></path>
+            <path d="M6 13h3"></path>
+            <path d="M9 13c6.667 0 6.667-10 0-10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/infinity.rs b/packages/leptos/src/infinity.rs
new file mode 100644
index 0000000..aab233a
--- /dev/null
+++ b/packages/leptos/src/infinity.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Infinity(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12c-2-2.67-4-4-6-4a4 4 0 1 0 0 8c2 0 4-1.33 6-4Zm0 0c2 2.67 4 4 6 4a4 4 0 0 0 0-8c-2 0-4 1.33-6 4Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/info.rs b/packages/leptos/src/info.rs
new file mode 100644
index 0000000..f7bda4f
--- /dev/null
+++ b/packages/leptos/src/info.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Info(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M12 16v-4"></path>
+            <path d="M12 8h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/inspection_panel.rs b/packages/leptos/src/inspection_panel.rs
new file mode 100644
index 0000000..9140eb5
--- /dev/null
+++ b/packages/leptos/src/inspection_panel.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn InspectionPanel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M7 7h.01"></path>
+            <path d="M17 7h.01"></path>
+            <path d="M7 17h.01"></path>
+            <path d="M17 17h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/instagram.rs b/packages/leptos/src/instagram.rs
new file mode 100644
index 0000000..158db9c
--- /dev/null
+++ b/packages/leptos/src/instagram.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Instagram(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="20" x="2" y="2" rx="5" ry="5"></rect>
+            <path d="M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z"></path>
+            <line x1="17.5" x2="17.51" y1="6.5" y2="6.5"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/italic.rs b/packages/leptos/src/italic.rs
new file mode 100644
index 0000000..243164e
--- /dev/null
+++ b/packages/leptos/src/italic.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Italic(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="19" x2="10" y1="4" y2="4"></line>
+            <line x1="14" x2="5" y1="20" y2="20"></line>
+            <line x1="15" x2="9" y1="4" y2="20"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/iteration_ccw.rs b/packages/leptos/src/iteration_ccw.rs
new file mode 100644
index 0000000..bbb9a1d
--- /dev/null
+++ b/packages/leptos/src/iteration_ccw.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn IterationCcw(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10c0-4.4-3.6-8-8-8s-8 3.6-8 8 3.6 8 8 8h8"></path>
+            <polyline points="16 14 20 18 16 22"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/iteration_cw.rs b/packages/leptos/src/iteration_cw.rs
new file mode 100644
index 0000000..973cee6
--- /dev/null
+++ b/packages/leptos/src/iteration_cw.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn IterationCw(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10c0-4.4 3.6-8 8-8s8 3.6 8 8-3.6 8-8 8H4"></path>
+            <polyline points="8 22 4 18 8 14"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/japanese_yen.rs b/packages/leptos/src/japanese_yen.rs
new file mode 100644
index 0000000..1793df4
--- /dev/null
+++ b/packages/leptos/src/japanese_yen.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn JapaneseYen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 9.5V21m0-11.5L6 3m6 6.5L18 3"></path>
+            <path d="M6 15h12"></path>
+            <path d="M6 11h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/joystick.rs b/packages/leptos/src/joystick.rs
new file mode 100644
index 0000000..0a6eeaf
--- /dev/null
+++ b/packages/leptos/src/joystick.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Joystick(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-2Z"></path>
+            <path d="M6 15v-2"></path>
+            <path d="M12 15V9"></path>
+            <circle cx="12" cy="6" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/kanban.rs b/packages/leptos/src/kanban.rs
new file mode 100644
index 0000000..6b2f021
--- /dev/null
+++ b/packages/leptos/src/kanban.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Kanban(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 5v11"></path>
+            <path d="M12 5v6"></path>
+            <path d="M18 5v14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/key.rs b/packages/leptos/src/key.rs
new file mode 100644
index 0000000..e113e76
--- /dev/null
+++ b/packages/leptos/src/key.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Key(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15.5 7.5 2.3 2.3a1 1 0 0 0 1.4 0l2.1-2.1a1 1 0 0 0 0-1.4L19 4"></path>
+            <path d="m21 2-9.6 9.6"></path>
+            <circle cx="7.5" cy="15.5" r="5.5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/key_round.rs b/packages/leptos/src/key_round.rs
new file mode 100644
index 0000000..6fc55c0
--- /dev/null
+++ b/packages/leptos/src/key_round.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn KeyRound(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.586 17.414A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814a6.5 6.5 0 1 0-4-4z"></path>
+            <circle cx="16.5" cy="7.5" r=".5" fill="currentColor"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/key_square.rs b/packages/leptos/src/key_square.rs
new file mode 100644
index 0000000..3f9d494
--- /dev/null
+++ b/packages/leptos/src/key_square.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn KeySquare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.4 2.7a2.5 2.5 0 0 1 3.4 0l5.5 5.5a2.5 2.5 0 0 1 0 3.4l-3.7 3.7a2.5 2.5 0 0 1-3.4 0L8.7 9.8a2.5 2.5 0 0 1 0-3.4z"></path>
+            <path d="m14 7 3 3"></path>
+            <path d="m9.4 10.6-6.814 6.814A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/keyboard.rs b/packages/leptos/src/keyboard.rs
new file mode 100644
index 0000000..a82e961
--- /dev/null
+++ b/packages/leptos/src/keyboard.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Keyboard(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 8h.01"></path>
+            <path d="M12 12h.01"></path>
+            <path d="M14 8h.01"></path>
+            <path d="M16 12h.01"></path>
+            <path d="M18 8h.01"></path>
+            <path d="M6 8h.01"></path>
+            <path d="M7 16h10"></path>
+            <path d="M8 12h.01"></path>
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/keyboard_music.rs b/packages/leptos/src/keyboard_music.rs
new file mode 100644
index 0000000..698c0e7
--- /dev/null
+++ b/packages/leptos/src/keyboard_music.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn KeyboardMusic(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+            <path d="M6 8h4"></path>
+            <path d="M14 8h.01"></path>
+            <path d="M18 8h.01"></path>
+            <path d="M2 12h20"></path>
+            <path d="M6 12v4"></path>
+            <path d="M10 12v4"></path>
+            <path d="M14 12v4"></path>
+            <path d="M18 12v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/keyboard_off.rs b/packages/leptos/src/keyboard_off.rs
new file mode 100644
index 0000000..963db13
--- /dev/null
+++ b/packages/leptos/src/keyboard_off.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn KeyboardOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M 20 4 A2 2 0 0 1 22 6"></path>
+            <path d="M 22 6 L 22 16.41"></path>
+            <path d="M 7 16 L 16 16"></path>
+            <path d="M 9.69 4 L 20 4"></path>
+            <path d="M14 8h.01"></path>
+            <path d="M18 8h.01"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M20 20H4a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2"></path>
+            <path d="M6 8h.01"></path>
+            <path d="M8 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lamp.rs b/packages/leptos/src/lamp.rs
new file mode 100644
index 0000000..ebdf37d
--- /dev/null
+++ b/packages/leptos/src/lamp.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Lamp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2h8l4 10H4L8 2Z"></path>
+            <path d="M12 12v6"></path>
+            <path d="M8 22v-2c0-1.1.9-2 2-2h4a2 2 0 0 1 2 2v2H8Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lamp_ceiling.rs b/packages/leptos/src/lamp_ceiling.rs
new file mode 100644
index 0000000..ac36738
--- /dev/null
+++ b/packages/leptos/src/lamp_ceiling.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LampCeiling(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v5"></path>
+            <path d="M6 7h12l4 9H2l4-9Z"></path>
+            <path d="M9.17 16a3 3 0 1 0 5.66 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lamp_desk.rs b/packages/leptos/src/lamp_desk.rs
new file mode 100644
index 0000000..53eb8bb
--- /dev/null
+++ b/packages/leptos/src/lamp_desk.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LampDesk(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14 5-3 3 2 7 8-8-7-2Z"></path>
+            <path d="m14 5-3 3-3-3 3-3 3 3Z"></path>
+            <path d="M9.5 6.5 4 12l3 6"></path>
+            <path d="M3 22v-2c0-1.1.9-2 2-2h4a2 2 0 0 1 2 2v2H3Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lamp_floor.rs b/packages/leptos/src/lamp_floor.rs
new file mode 100644
index 0000000..b24ca02
--- /dev/null
+++ b/packages/leptos/src/lamp_floor.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LampFloor(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 2h6l3 7H6l3-7Z"></path>
+            <path d="M12 9v13"></path>
+            <path d="M9 22h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lamp_wall_down.rs b/packages/leptos/src/lamp_wall_down.rs
new file mode 100644
index 0000000..51b21b4
--- /dev/null
+++ b/packages/leptos/src/lamp_wall_down.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LampWallDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 13h6l3 7H8l3-7Z"></path>
+            <path d="M14 13V8a2 2 0 0 0-2-2H8"></path>
+            <path d="M4 9h2a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2H4v6Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lamp_wall_up.rs b/packages/leptos/src/lamp_wall_up.rs
new file mode 100644
index 0000000..0722e7a
--- /dev/null
+++ b/packages/leptos/src/lamp_wall_up.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LampWallUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 4h6l3 7H8l3-7Z"></path>
+            <path d="M14 11v5a2 2 0 0 1-2 2H8"></path>
+            <path d="M4 15h2a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2H4v-6Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/land_plot.rs b/packages/leptos/src/land_plot.rs
new file mode 100644
index 0000000..58b14be
--- /dev/null
+++ b/packages/leptos/src/land_plot.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LandPlot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 8 6-3-6-3v10"></path>
+            <path d="m8 11.99-5.5 3.14a1 1 0 0 0 0 1.74l8.5 4.86a2 2 0 0 0 2 0l8.5-4.86a1 1 0 0 0 0-1.74L16 12"></path>
+            <path d="m6.49 12.85 11.02 6.3"></path>
+            <path d="M17.51 12.85 6.5 19.15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/landmark.rs b/packages/leptos/src/landmark.rs
new file mode 100644
index 0000000..dead983
--- /dev/null
+++ b/packages/leptos/src/landmark.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Landmark(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="3" x2="21" y1="22" y2="22"></line>
+            <line x1="6" x2="6" y1="18" y2="11"></line>
+            <line x1="10" x2="10" y1="18" y2="11"></line>
+            <line x1="14" x2="14" y1="18" y2="11"></line>
+            <line x1="18" x2="18" y1="18" y2="11"></line>
+            <polygon points="12 2 20 7 4 7"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/languages.rs b/packages/leptos/src/languages.rs
new file mode 100644
index 0000000..e59af79
--- /dev/null
+++ b/packages/leptos/src/languages.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Languages(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5 8 6 6"></path>
+            <path d="m4 14 6-6 2-3"></path>
+            <path d="M2 5h12"></path>
+            <path d="M7 2h1"></path>
+            <path d="m22 22-5-10-5 10"></path>
+            <path d="M14 18h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/laptop.rs b/packages/leptos/src/laptop.rs
new file mode 100644
index 0000000..0ed6527
--- /dev/null
+++ b/packages/leptos/src/laptop.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Laptop(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/laptop_minimal.rs b/packages/leptos/src/laptop_minimal.rs
new file mode 100644
index 0000000..aded74d
--- /dev/null
+++ b/packages/leptos/src/laptop_minimal.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LaptopMinimal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="12" x="3" y="4" rx="2" ry="2"></rect>
+            <line x1="2" x2="22" y1="20" y2="20"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/laptop_minimal_check.rs b/packages/leptos/src/laptop_minimal_check.rs
new file mode 100644
index 0000000..277074f
--- /dev/null
+++ b/packages/leptos/src/laptop_minimal_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LaptopMinimalCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h20"></path>
+            <path d="m9 10 2 2 4-4"></path>
+            <rect x="3" y="4" width="18" height="12" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lasso.rs b/packages/leptos/src/lasso.rs
new file mode 100644
index 0000000..ffb3f35
--- /dev/null
+++ b/packages/leptos/src/lasso.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Lasso(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 22a5 5 0 0 1-2-4"></path>
+            <path d="M3.3 14A6.8 6.8 0 0 1 2 10c0-4.4 4.5-8 10-8s10 3.6 10 8-4.5 8-10 8a12 12 0 0 1-5-1"></path>
+            <path d="M5 18a2 2 0 1 0 0-4 2 2 0 0 0 0 4z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lasso_select.rs b/packages/leptos/src/lasso_select.rs
new file mode 100644
index 0000000..532e7c8
--- /dev/null
+++ b/packages/leptos/src/lasso_select.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LassoSelect(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 22a5 5 0 0 1-2-4"></path>
+            <path d="M7 16.93c.96.43 1.96.74 2.99.91"></path>
+            <path d="M3.34 14A6.8 6.8 0 0 1 2 10c0-4.42 4.48-8 10-8s10 3.58 10 8a7.19 7.19 0 0 1-.33 2"></path>
+            <path d="M5 18a2 2 0 1 0 0-4 2 2 0 0 0 0 4z"></path>
+            <path d="M14.33 22h-.09a.35.35 0 0 1-.24-.32v-10a.34.34 0 0 1 .33-.34c.08 0 .15.03.21.08l7.34 6a.33.33 0 0 1-.21.59h-4.49l-2.57 3.85a.35.35 0 0 1-.28.14z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/laugh.rs b/packages/leptos/src/laugh.rs
new file mode 100644
index 0000000..9313de1
--- /dev/null
+++ b/packages/leptos/src/laugh.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Laugh(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M18 13a6 6 0 0 1-6 5 6 6 0 0 1-6-5h12Z"></path>
+            <line x1="9" x2="9.01" y1="9" y2="9"></line>
+            <line x1="15" x2="15.01" y1="9" y2="9"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layers.rs b/packages/leptos/src/layers.rs
new file mode 100644
index 0000000..2d30494
--- /dev/null
+++ b/packages/leptos/src/layers.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Layers(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83Z"></path>
+            <path d="m22 17.65-9.17 4.16a2 2 0 0 1-1.66 0L2 17.65"></path>
+            <path d="m22 12.65-9.17 4.16a2 2 0 0 1-1.66 0L2 12.65"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layers_2.rs b/packages/leptos/src/layers_2.rs
new file mode 100644
index 0000000..f5700d3
--- /dev/null
+++ b/packages/leptos/src/layers_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Layers2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16.02 12 5.48 3.13a1 1 0 0 1 0 1.74L13 21.74a2 2 0 0 1-2 0l-8.5-4.87a1 1 0 0 1 0-1.74L7.98 12"></path>
+            <path d="M13 13.74a2 2 0 0 1-2 0L2.5 8.87a1 1 0 0 1 0-1.74L11 2.26a2 2 0 0 1 2 0l8.5 4.87a1 1 0 0 1 0 1.74Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layers_3.rs b/packages/leptos/src/layers_3.rs
new file mode 100644
index 0000000..ab81e66
--- /dev/null
+++ b/packages/leptos/src/layers_3.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Layers3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83Z"></path>
+            <path d="m6.08 9.5-3.5 1.6a1 1 0 0 0 0 1.81l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9a1 1 0 0 0 0-1.83l-3.5-1.59"></path>
+            <path d="m6.08 14.5-3.5 1.6a1 1 0 0 0 0 1.81l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9a1 1 0 0 0 0-1.83l-3.5-1.59"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layout_dashboard.rs b/packages/leptos/src/layout_dashboard.rs
new file mode 100644
index 0000000..8a6ac52
--- /dev/null
+++ b/packages/leptos/src/layout_dashboard.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LayoutDashboard(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="9" x="3" y="3" rx="1"></rect>
+            <rect width="7" height="5" x="14" y="3" rx="1"></rect>
+            <rect width="7" height="9" x="14" y="12" rx="1"></rect>
+            <rect width="7" height="5" x="3" y="16" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layout_grid.rs b/packages/leptos/src/layout_grid.rs
new file mode 100644
index 0000000..d09dc01
--- /dev/null
+++ b/packages/leptos/src/layout_grid.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LayoutGrid(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="7" x="3" y="3" rx="1"></rect>
+            <rect width="7" height="7" x="14" y="3" rx="1"></rect>
+            <rect width="7" height="7" x="14" y="14" rx="1"></rect>
+            <rect width="7" height="7" x="3" y="14" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layout_list.rs b/packages/leptos/src/layout_list.rs
new file mode 100644
index 0000000..c559684
--- /dev/null
+++ b/packages/leptos/src/layout_list.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LayoutList(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="7" x="3" y="3" rx="1"></rect>
+            <rect width="7" height="7" x="3" y="14" rx="1"></rect>
+            <path d="M14 4h7"></path>
+            <path d="M14 9h7"></path>
+            <path d="M14 15h7"></path>
+            <path d="M14 20h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layout_panel_left.rs b/packages/leptos/src/layout_panel_left.rs
new file mode 100644
index 0000000..dcfee58
--- /dev/null
+++ b/packages/leptos/src/layout_panel_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LayoutPanelLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="18" x="3" y="3" rx="1"></rect>
+            <rect width="7" height="7" x="14" y="3" rx="1"></rect>
+            <rect width="7" height="7" x="14" y="14" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layout_panel_top.rs b/packages/leptos/src/layout_panel_top.rs
new file mode 100644
index 0000000..3b45056
--- /dev/null
+++ b/packages/leptos/src/layout_panel_top.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LayoutPanelTop(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="7" x="3" y="3" rx="1"></rect>
+            <rect width="7" height="7" x="3" y="14" rx="1"></rect>
+            <rect width="7" height="7" x="14" y="14" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/layout_template.rs b/packages/leptos/src/layout_template.rs
new file mode 100644
index 0000000..1f48231
--- /dev/null
+++ b/packages/leptos/src/layout_template.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LayoutTemplate(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="7" x="3" y="3" rx="1"></rect>
+            <rect width="9" height="7" x="3" y="14" rx="1"></rect>
+            <rect width="5" height="7" x="16" y="14" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/leaf.rs b/packages/leptos/src/leaf.rs
new file mode 100644
index 0000000..d442233
--- /dev/null
+++ b/packages/leptos/src/leaf.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Leaf(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 20A7 7 0 0 1 9.8 6.1C15.5 5 17 4.48 19 2c1 2 2 4.18 2 8 0 5.5-4.78 10-10 10Z"></path>
+            <path d="M2 21c0-3 1.85-5.36 5.08-6C9.5 14.52 12 13 13 12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/leafy_green.rs b/packages/leptos/src/leafy_green.rs
new file mode 100644
index 0000000..89127c5
--- /dev/null
+++ b/packages/leptos/src/leafy_green.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LeafyGreen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22c1.25-.987 2.27-1.975 3.9-2.2a5.56 5.56 0 0 1 3.8 1.5 4 4 0 0 0 6.187-2.353 3.5 3.5 0 0 0 3.69-5.116A3.5 3.5 0 0 0 20.95 8 3.5 3.5 0 1 0 16 3.05a3.5 3.5 0 0 0-5.831 1.373 3.5 3.5 0 0 0-5.116 3.69 4 4 0 0 0-2.348 6.155C3.499 15.42 4.409 16.712 4.2 18.1 3.926 19.743 3.014 20.732 2 22"></path>
+            <path d="M2 22 17 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lectern.rs b/packages/leptos/src/lectern.rs
new file mode 100644
index 0000000..0034d4c
--- /dev/null
+++ b/packages/leptos/src/lectern.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Lectern(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12h3a2 2 0 0 0 1.902-1.38l1.056-3.333A1 1 0 0 0 21 6H3a1 1 0 0 0-.958 1.287l1.056 3.334A2 2 0 0 0 5 12h3"></path>
+            <path d="M18 6V3a1 1 0 0 0-1-1h-3"></path>
+            <rect width="8" height="12" x="8" y="10" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/letter_text.rs b/packages/leptos/src/letter_text.rs
new file mode 100644
index 0000000..7482ecb
--- /dev/null
+++ b/packages/leptos/src/letter_text.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LetterText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 12h6"></path>
+            <path d="M15 6h6"></path>
+            <path d="m3 13 3.553-7.724a.5.5 0 0 1 .894 0L11 13"></path>
+            <path d="M3 18h18"></path>
+            <path d="M4 11h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lib.rs b/packages/leptos/src/lib.rs
index 0fb5aaa..6e17d5c 100644
--- a/packages/leptos/src/lib.rs
+++ b/packages/leptos/src/lib.rs
@@ -3,3 +3,6161 @@
 //! Lucide is a beautiful & consistent icon toolkit made by the community.
 //!
 //! See [the Rust Lucide book](https://lucide.rustforweb.org/leptos.html) for more documenation.
+
+#[cfg(feature = "a-arrow-down")]
+mod a_arrow_down;
+#[cfg(feature = "a-arrow-up")]
+mod a_arrow_up;
+#[cfg(feature = "a-large-small")]
+mod a_large_small;
+#[cfg(feature = "accessibility")]
+mod accessibility;
+#[cfg(feature = "activity")]
+mod activity;
+#[cfg(feature = "air-vent")]
+mod air_vent;
+#[cfg(feature = "airplay")]
+mod airplay;
+#[cfg(feature = "alarm-clock")]
+mod alarm_clock;
+#[cfg(feature = "alarm-clock-check")]
+mod alarm_clock_check;
+#[cfg(feature = "alarm-clock-minus")]
+mod alarm_clock_minus;
+#[cfg(feature = "alarm-clock-off")]
+mod alarm_clock_off;
+#[cfg(feature = "alarm-clock-plus")]
+mod alarm_clock_plus;
+#[cfg(feature = "alarm-smoke")]
+mod alarm_smoke;
+#[cfg(feature = "album")]
+mod album;
+#[cfg(feature = "align-center")]
+mod align_center;
+#[cfg(feature = "align-center-horizontal")]
+mod align_center_horizontal;
+#[cfg(feature = "align-center-vertical")]
+mod align_center_vertical;
+#[cfg(feature = "align-end-horizontal")]
+mod align_end_horizontal;
+#[cfg(feature = "align-end-vertical")]
+mod align_end_vertical;
+#[cfg(feature = "align-horizontal-distribute-center")]
+mod align_horizontal_distribute_center;
+#[cfg(feature = "align-horizontal-distribute-end")]
+mod align_horizontal_distribute_end;
+#[cfg(feature = "align-horizontal-distribute-start")]
+mod align_horizontal_distribute_start;
+#[cfg(feature = "align-horizontal-justify-center")]
+mod align_horizontal_justify_center;
+#[cfg(feature = "align-horizontal-justify-end")]
+mod align_horizontal_justify_end;
+#[cfg(feature = "align-horizontal-justify-start")]
+mod align_horizontal_justify_start;
+#[cfg(feature = "align-horizontal-space-around")]
+mod align_horizontal_space_around;
+#[cfg(feature = "align-horizontal-space-between")]
+mod align_horizontal_space_between;
+#[cfg(feature = "align-justify")]
+mod align_justify;
+#[cfg(feature = "align-left")]
+mod align_left;
+#[cfg(feature = "align-right")]
+mod align_right;
+#[cfg(feature = "align-start-horizontal")]
+mod align_start_horizontal;
+#[cfg(feature = "align-start-vertical")]
+mod align_start_vertical;
+#[cfg(feature = "align-vertical-distribute-center")]
+mod align_vertical_distribute_center;
+#[cfg(feature = "align-vertical-distribute-end")]
+mod align_vertical_distribute_end;
+#[cfg(feature = "align-vertical-distribute-start")]
+mod align_vertical_distribute_start;
+#[cfg(feature = "align-vertical-justify-center")]
+mod align_vertical_justify_center;
+#[cfg(feature = "align-vertical-justify-end")]
+mod align_vertical_justify_end;
+#[cfg(feature = "align-vertical-justify-start")]
+mod align_vertical_justify_start;
+#[cfg(feature = "align-vertical-space-around")]
+mod align_vertical_space_around;
+#[cfg(feature = "align-vertical-space-between")]
+mod align_vertical_space_between;
+#[cfg(feature = "ambulance")]
+mod ambulance;
+#[cfg(feature = "ampersand")]
+mod ampersand;
+#[cfg(feature = "ampersands")]
+mod ampersands;
+#[cfg(feature = "amphora")]
+mod amphora;
+#[cfg(feature = "anchor")]
+mod anchor;
+#[cfg(feature = "angry")]
+mod angry;
+#[cfg(feature = "annoyed")]
+mod annoyed;
+#[cfg(feature = "antenna")]
+mod antenna;
+#[cfg(feature = "anvil")]
+mod anvil;
+#[cfg(feature = "aperture")]
+mod aperture;
+#[cfg(feature = "app-window")]
+mod app_window;
+#[cfg(feature = "app-window-mac")]
+mod app_window_mac;
+#[cfg(feature = "apple")]
+mod apple;
+#[cfg(feature = "archive")]
+mod archive;
+#[cfg(feature = "archive-restore")]
+mod archive_restore;
+#[cfg(feature = "archive-x")]
+mod archive_x;
+#[cfg(feature = "armchair")]
+mod armchair;
+#[cfg(feature = "arrow-big-down")]
+mod arrow_big_down;
+#[cfg(feature = "arrow-big-down-dash")]
+mod arrow_big_down_dash;
+#[cfg(feature = "arrow-big-left")]
+mod arrow_big_left;
+#[cfg(feature = "arrow-big-left-dash")]
+mod arrow_big_left_dash;
+#[cfg(feature = "arrow-big-right")]
+mod arrow_big_right;
+#[cfg(feature = "arrow-big-right-dash")]
+mod arrow_big_right_dash;
+#[cfg(feature = "arrow-big-up")]
+mod arrow_big_up;
+#[cfg(feature = "arrow-big-up-dash")]
+mod arrow_big_up_dash;
+#[cfg(feature = "arrow-down")]
+mod arrow_down;
+#[cfg(feature = "arrow-down-0-1")]
+mod arrow_down_0_1;
+#[cfg(feature = "arrow-down-1-0")]
+mod arrow_down_1_0;
+#[cfg(feature = "arrow-down-a-z")]
+mod arrow_down_a_z;
+#[cfg(feature = "arrow-down-from-line")]
+mod arrow_down_from_line;
+#[cfg(feature = "arrow-down-left")]
+mod arrow_down_left;
+#[cfg(feature = "arrow-down-narrow-wide")]
+mod arrow_down_narrow_wide;
+#[cfg(feature = "arrow-down-right")]
+mod arrow_down_right;
+#[cfg(feature = "arrow-down-to-dot")]
+mod arrow_down_to_dot;
+#[cfg(feature = "arrow-down-to-line")]
+mod arrow_down_to_line;
+#[cfg(feature = "arrow-down-up")]
+mod arrow_down_up;
+#[cfg(feature = "arrow-down-wide-narrow")]
+mod arrow_down_wide_narrow;
+#[cfg(feature = "arrow-down-z-a")]
+mod arrow_down_z_a;
+#[cfg(feature = "arrow-left")]
+mod arrow_left;
+#[cfg(feature = "arrow-left-from-line")]
+mod arrow_left_from_line;
+#[cfg(feature = "arrow-left-right")]
+mod arrow_left_right;
+#[cfg(feature = "arrow-left-to-line")]
+mod arrow_left_to_line;
+#[cfg(feature = "arrow-right")]
+mod arrow_right;
+#[cfg(feature = "arrow-right-from-line")]
+mod arrow_right_from_line;
+#[cfg(feature = "arrow-right-left")]
+mod arrow_right_left;
+#[cfg(feature = "arrow-right-to-line")]
+mod arrow_right_to_line;
+#[cfg(feature = "arrow-up")]
+mod arrow_up;
+#[cfg(feature = "arrow-up-0-1")]
+mod arrow_up_0_1;
+#[cfg(feature = "arrow-up-1-0")]
+mod arrow_up_1_0;
+#[cfg(feature = "arrow-up-a-z")]
+mod arrow_up_a_z;
+#[cfg(feature = "arrow-up-down")]
+mod arrow_up_down;
+#[cfg(feature = "arrow-up-from-dot")]
+mod arrow_up_from_dot;
+#[cfg(feature = "arrow-up-from-line")]
+mod arrow_up_from_line;
+#[cfg(feature = "arrow-up-left")]
+mod arrow_up_left;
+#[cfg(feature = "arrow-up-narrow-wide")]
+mod arrow_up_narrow_wide;
+#[cfg(feature = "arrow-up-right")]
+mod arrow_up_right;
+#[cfg(feature = "arrow-up-to-line")]
+mod arrow_up_to_line;
+#[cfg(feature = "arrow-up-wide-narrow")]
+mod arrow_up_wide_narrow;
+#[cfg(feature = "arrow-up-z-a")]
+mod arrow_up_z_a;
+#[cfg(feature = "arrows-up-from-line")]
+mod arrows_up_from_line;
+#[cfg(feature = "asterisk")]
+mod asterisk;
+#[cfg(feature = "at-sign")]
+mod at_sign;
+#[cfg(feature = "atom")]
+mod atom;
+#[cfg(feature = "audio-lines")]
+mod audio_lines;
+#[cfg(feature = "audio-waveform")]
+mod audio_waveform;
+#[cfg(feature = "award")]
+mod award;
+#[cfg(feature = "axe")]
+mod axe;
+#[cfg(feature = "axis-3-d")]
+mod axis_3_d;
+#[cfg(feature = "baby")]
+mod baby;
+#[cfg(feature = "backpack")]
+mod backpack;
+#[cfg(feature = "badge")]
+mod badge;
+#[cfg(feature = "badge-alert")]
+mod badge_alert;
+#[cfg(feature = "badge-cent")]
+mod badge_cent;
+#[cfg(feature = "badge-check")]
+mod badge_check;
+#[cfg(feature = "badge-dollar-sign")]
+mod badge_dollar_sign;
+#[cfg(feature = "badge-euro")]
+mod badge_euro;
+#[cfg(feature = "badge-help")]
+mod badge_help;
+#[cfg(feature = "badge-indian-rupee")]
+mod badge_indian_rupee;
+#[cfg(feature = "badge-info")]
+mod badge_info;
+#[cfg(feature = "badge-japanese-yen")]
+mod badge_japanese_yen;
+#[cfg(feature = "badge-minus")]
+mod badge_minus;
+#[cfg(feature = "badge-percent")]
+mod badge_percent;
+#[cfg(feature = "badge-plus")]
+mod badge_plus;
+#[cfg(feature = "badge-pound-sterling")]
+mod badge_pound_sterling;
+#[cfg(feature = "badge-russian-ruble")]
+mod badge_russian_ruble;
+#[cfg(feature = "badge-swiss-franc")]
+mod badge_swiss_franc;
+#[cfg(feature = "badge-x")]
+mod badge_x;
+#[cfg(feature = "baggage-claim")]
+mod baggage_claim;
+#[cfg(feature = "ban")]
+mod ban;
+#[cfg(feature = "banana")]
+mod banana;
+#[cfg(feature = "bandage")]
+mod bandage;
+#[cfg(feature = "banknote")]
+mod banknote;
+#[cfg(feature = "barcode")]
+mod barcode;
+#[cfg(feature = "baseline")]
+mod baseline;
+#[cfg(feature = "bath")]
+mod bath;
+#[cfg(feature = "battery")]
+mod battery;
+#[cfg(feature = "battery-charging")]
+mod battery_charging;
+#[cfg(feature = "battery-full")]
+mod battery_full;
+#[cfg(feature = "battery-low")]
+mod battery_low;
+#[cfg(feature = "battery-medium")]
+mod battery_medium;
+#[cfg(feature = "battery-warning")]
+mod battery_warning;
+#[cfg(feature = "beaker")]
+mod beaker;
+#[cfg(feature = "bean")]
+mod bean;
+#[cfg(feature = "bean-off")]
+mod bean_off;
+#[cfg(feature = "bed")]
+mod bed;
+#[cfg(feature = "bed-double")]
+mod bed_double;
+#[cfg(feature = "bed-single")]
+mod bed_single;
+#[cfg(feature = "beef")]
+mod beef;
+#[cfg(feature = "beer")]
+mod beer;
+#[cfg(feature = "beer-off")]
+mod beer_off;
+#[cfg(feature = "bell")]
+mod bell;
+#[cfg(feature = "bell-dot")]
+mod bell_dot;
+#[cfg(feature = "bell-electric")]
+mod bell_electric;
+#[cfg(feature = "bell-minus")]
+mod bell_minus;
+#[cfg(feature = "bell-off")]
+mod bell_off;
+#[cfg(feature = "bell-plus")]
+mod bell_plus;
+#[cfg(feature = "bell-ring")]
+mod bell_ring;
+#[cfg(feature = "between-horizontal-end")]
+mod between_horizontal_end;
+#[cfg(feature = "between-horizontal-start")]
+mod between_horizontal_start;
+#[cfg(feature = "between-vertical-end")]
+mod between_vertical_end;
+#[cfg(feature = "between-vertical-start")]
+mod between_vertical_start;
+#[cfg(feature = "biceps-flexed")]
+mod biceps_flexed;
+#[cfg(feature = "bike")]
+mod bike;
+#[cfg(feature = "binary")]
+mod binary;
+#[cfg(feature = "binoculars")]
+mod binoculars;
+#[cfg(feature = "biohazard")]
+mod biohazard;
+#[cfg(feature = "bird")]
+mod bird;
+#[cfg(feature = "bitcoin")]
+mod bitcoin;
+#[cfg(feature = "blend")]
+mod blend;
+#[cfg(feature = "blinds")]
+mod blinds;
+#[cfg(feature = "blocks")]
+mod blocks;
+#[cfg(feature = "bluetooth")]
+mod bluetooth;
+#[cfg(feature = "bluetooth-connected")]
+mod bluetooth_connected;
+#[cfg(feature = "bluetooth-off")]
+mod bluetooth_off;
+#[cfg(feature = "bluetooth-searching")]
+mod bluetooth_searching;
+#[cfg(feature = "bold")]
+mod bold;
+#[cfg(feature = "bolt")]
+mod bolt;
+#[cfg(feature = "bomb")]
+mod bomb;
+#[cfg(feature = "bone")]
+mod bone;
+#[cfg(feature = "book")]
+mod book;
+#[cfg(feature = "book-a")]
+mod book_a;
+#[cfg(feature = "book-audio")]
+mod book_audio;
+#[cfg(feature = "book-check")]
+mod book_check;
+#[cfg(feature = "book-copy")]
+mod book_copy;
+#[cfg(feature = "book-dashed")]
+mod book_dashed;
+#[cfg(feature = "book-down")]
+mod book_down;
+#[cfg(feature = "book-headphones")]
+mod book_headphones;
+#[cfg(feature = "book-heart")]
+mod book_heart;
+#[cfg(feature = "book-image")]
+mod book_image;
+#[cfg(feature = "book-key")]
+mod book_key;
+#[cfg(feature = "book-lock")]
+mod book_lock;
+#[cfg(feature = "book-marked")]
+mod book_marked;
+#[cfg(feature = "book-minus")]
+mod book_minus;
+#[cfg(feature = "book-open")]
+mod book_open;
+#[cfg(feature = "book-open-check")]
+mod book_open_check;
+#[cfg(feature = "book-open-text")]
+mod book_open_text;
+#[cfg(feature = "book-plus")]
+mod book_plus;
+#[cfg(feature = "book-text")]
+mod book_text;
+#[cfg(feature = "book-type")]
+mod book_type;
+#[cfg(feature = "book-up")]
+mod book_up;
+#[cfg(feature = "book-up-2")]
+mod book_up_2;
+#[cfg(feature = "book-user")]
+mod book_user;
+#[cfg(feature = "book-x")]
+mod book_x;
+#[cfg(feature = "bookmark")]
+mod bookmark;
+#[cfg(feature = "bookmark-check")]
+mod bookmark_check;
+#[cfg(feature = "bookmark-minus")]
+mod bookmark_minus;
+#[cfg(feature = "bookmark-plus")]
+mod bookmark_plus;
+#[cfg(feature = "bookmark-x")]
+mod bookmark_x;
+#[cfg(feature = "boom-box")]
+mod boom_box;
+#[cfg(feature = "bot")]
+mod bot;
+#[cfg(feature = "bot-message-square")]
+mod bot_message_square;
+#[cfg(feature = "bot-off")]
+mod bot_off;
+#[cfg(feature = "box")]
+mod r#box;
+#[cfg(feature = "boxes")]
+mod boxes;
+#[cfg(feature = "braces")]
+mod braces;
+#[cfg(feature = "brackets")]
+mod brackets;
+#[cfg(feature = "brain")]
+mod brain;
+#[cfg(feature = "brain-circuit")]
+mod brain_circuit;
+#[cfg(feature = "brain-cog")]
+mod brain_cog;
+#[cfg(feature = "brick-wall")]
+mod brick_wall;
+#[cfg(feature = "briefcase")]
+mod briefcase;
+#[cfg(feature = "briefcase-business")]
+mod briefcase_business;
+#[cfg(feature = "briefcase-conveyor-belt")]
+mod briefcase_conveyor_belt;
+#[cfg(feature = "briefcase-medical")]
+mod briefcase_medical;
+#[cfg(feature = "bring-to-front")]
+mod bring_to_front;
+#[cfg(feature = "brush")]
+mod brush;
+#[cfg(feature = "bug")]
+mod bug;
+#[cfg(feature = "bug-off")]
+mod bug_off;
+#[cfg(feature = "bug-play")]
+mod bug_play;
+#[cfg(feature = "building")]
+mod building;
+#[cfg(feature = "building-2")]
+mod building_2;
+#[cfg(feature = "bus")]
+mod bus;
+#[cfg(feature = "bus-front")]
+mod bus_front;
+#[cfg(feature = "cable")]
+mod cable;
+#[cfg(feature = "cable-car")]
+mod cable_car;
+#[cfg(feature = "cake")]
+mod cake;
+#[cfg(feature = "cake-slice")]
+mod cake_slice;
+#[cfg(feature = "calculator")]
+mod calculator;
+#[cfg(feature = "calendar")]
+mod calendar;
+#[cfg(feature = "calendar-1")]
+mod calendar_1;
+#[cfg(feature = "calendar-arrow-down")]
+mod calendar_arrow_down;
+#[cfg(feature = "calendar-arrow-up")]
+mod calendar_arrow_up;
+#[cfg(feature = "calendar-check")]
+mod calendar_check;
+#[cfg(feature = "calendar-check-2")]
+mod calendar_check_2;
+#[cfg(feature = "calendar-clock")]
+mod calendar_clock;
+#[cfg(feature = "calendar-cog")]
+mod calendar_cog;
+#[cfg(feature = "calendar-days")]
+mod calendar_days;
+#[cfg(feature = "calendar-fold")]
+mod calendar_fold;
+#[cfg(feature = "calendar-heart")]
+mod calendar_heart;
+#[cfg(feature = "calendar-minus")]
+mod calendar_minus;
+#[cfg(feature = "calendar-minus-2")]
+mod calendar_minus_2;
+#[cfg(feature = "calendar-off")]
+mod calendar_off;
+#[cfg(feature = "calendar-plus")]
+mod calendar_plus;
+#[cfg(feature = "calendar-plus-2")]
+mod calendar_plus_2;
+#[cfg(feature = "calendar-range")]
+mod calendar_range;
+#[cfg(feature = "calendar-search")]
+mod calendar_search;
+#[cfg(feature = "calendar-x")]
+mod calendar_x;
+#[cfg(feature = "calendar-x-2")]
+mod calendar_x_2;
+#[cfg(feature = "camera")]
+mod camera;
+#[cfg(feature = "camera-off")]
+mod camera_off;
+#[cfg(feature = "candy")]
+mod candy;
+#[cfg(feature = "candy-cane")]
+mod candy_cane;
+#[cfg(feature = "candy-off")]
+mod candy_off;
+#[cfg(feature = "cannabis")]
+mod cannabis;
+#[cfg(feature = "captions")]
+mod captions;
+#[cfg(feature = "captions-off")]
+mod captions_off;
+#[cfg(feature = "car")]
+mod car;
+#[cfg(feature = "car-front")]
+mod car_front;
+#[cfg(feature = "car-taxi-front")]
+mod car_taxi_front;
+#[cfg(feature = "caravan")]
+mod caravan;
+#[cfg(feature = "carrot")]
+mod carrot;
+#[cfg(feature = "case-lower")]
+mod case_lower;
+#[cfg(feature = "case-sensitive")]
+mod case_sensitive;
+#[cfg(feature = "case-upper")]
+mod case_upper;
+#[cfg(feature = "cassette-tape")]
+mod cassette_tape;
+#[cfg(feature = "cast")]
+mod cast;
+#[cfg(feature = "castle")]
+mod castle;
+#[cfg(feature = "cat")]
+mod cat;
+#[cfg(feature = "cctv")]
+mod cctv;
+#[cfg(feature = "chart-area")]
+mod chart_area;
+#[cfg(feature = "chart-bar")]
+mod chart_bar;
+#[cfg(feature = "chart-bar-big")]
+mod chart_bar_big;
+#[cfg(feature = "chart-bar-decreasing")]
+mod chart_bar_decreasing;
+#[cfg(feature = "chart-bar-increasing")]
+mod chart_bar_increasing;
+#[cfg(feature = "chart-bar-stacked")]
+mod chart_bar_stacked;
+#[cfg(feature = "chart-candlestick")]
+mod chart_candlestick;
+#[cfg(feature = "chart-column")]
+mod chart_column;
+#[cfg(feature = "chart-column-big")]
+mod chart_column_big;
+#[cfg(feature = "chart-column-decreasing")]
+mod chart_column_decreasing;
+#[cfg(feature = "chart-column-increasing")]
+mod chart_column_increasing;
+#[cfg(feature = "chart-column-stacked")]
+mod chart_column_stacked;
+#[cfg(feature = "chart-gantt")]
+mod chart_gantt;
+#[cfg(feature = "chart-line")]
+mod chart_line;
+#[cfg(feature = "chart-network")]
+mod chart_network;
+#[cfg(feature = "chart-no-axes-column")]
+mod chart_no_axes_column;
+#[cfg(feature = "chart-no-axes-column-decreasing")]
+mod chart_no_axes_column_decreasing;
+#[cfg(feature = "chart-no-axes-column-increasing")]
+mod chart_no_axes_column_increasing;
+#[cfg(feature = "chart-no-axes-combined")]
+mod chart_no_axes_combined;
+#[cfg(feature = "chart-no-axes-gantt")]
+mod chart_no_axes_gantt;
+#[cfg(feature = "chart-pie")]
+mod chart_pie;
+#[cfg(feature = "chart-scatter")]
+mod chart_scatter;
+#[cfg(feature = "chart-spline")]
+mod chart_spline;
+#[cfg(feature = "check")]
+mod check;
+#[cfg(feature = "check-check")]
+mod check_check;
+#[cfg(feature = "chef-hat")]
+mod chef_hat;
+#[cfg(feature = "cherry")]
+mod cherry;
+#[cfg(feature = "chevron-down")]
+mod chevron_down;
+#[cfg(feature = "chevron-first")]
+mod chevron_first;
+#[cfg(feature = "chevron-last")]
+mod chevron_last;
+#[cfg(feature = "chevron-left")]
+mod chevron_left;
+#[cfg(feature = "chevron-right")]
+mod chevron_right;
+#[cfg(feature = "chevron-up")]
+mod chevron_up;
+#[cfg(feature = "chevrons-down")]
+mod chevrons_down;
+#[cfg(feature = "chevrons-down-up")]
+mod chevrons_down_up;
+#[cfg(feature = "chevrons-left")]
+mod chevrons_left;
+#[cfg(feature = "chevrons-left-right")]
+mod chevrons_left_right;
+#[cfg(feature = "chevrons-left-right-ellipsis")]
+mod chevrons_left_right_ellipsis;
+#[cfg(feature = "chevrons-right")]
+mod chevrons_right;
+#[cfg(feature = "chevrons-right-left")]
+mod chevrons_right_left;
+#[cfg(feature = "chevrons-up")]
+mod chevrons_up;
+#[cfg(feature = "chevrons-up-down")]
+mod chevrons_up_down;
+#[cfg(feature = "chrome")]
+mod chrome;
+#[cfg(feature = "church")]
+mod church;
+#[cfg(feature = "cigarette")]
+mod cigarette;
+#[cfg(feature = "cigarette-off")]
+mod cigarette_off;
+#[cfg(feature = "circle")]
+mod circle;
+#[cfg(feature = "circle-alert")]
+mod circle_alert;
+#[cfg(feature = "circle-arrow-down")]
+mod circle_arrow_down;
+#[cfg(feature = "circle-arrow-left")]
+mod circle_arrow_left;
+#[cfg(feature = "circle-arrow-out-down-left")]
+mod circle_arrow_out_down_left;
+#[cfg(feature = "circle-arrow-out-down-right")]
+mod circle_arrow_out_down_right;
+#[cfg(feature = "circle-arrow-out-up-left")]
+mod circle_arrow_out_up_left;
+#[cfg(feature = "circle-arrow-out-up-right")]
+mod circle_arrow_out_up_right;
+#[cfg(feature = "circle-arrow-right")]
+mod circle_arrow_right;
+#[cfg(feature = "circle-arrow-up")]
+mod circle_arrow_up;
+#[cfg(feature = "circle-check")]
+mod circle_check;
+#[cfg(feature = "circle-check-big")]
+mod circle_check_big;
+#[cfg(feature = "circle-chevron-down")]
+mod circle_chevron_down;
+#[cfg(feature = "circle-chevron-left")]
+mod circle_chevron_left;
+#[cfg(feature = "circle-chevron-right")]
+mod circle_chevron_right;
+#[cfg(feature = "circle-chevron-up")]
+mod circle_chevron_up;
+#[cfg(feature = "circle-dashed")]
+mod circle_dashed;
+#[cfg(feature = "circle-divide")]
+mod circle_divide;
+#[cfg(feature = "circle-dollar-sign")]
+mod circle_dollar_sign;
+#[cfg(feature = "circle-dot")]
+mod circle_dot;
+#[cfg(feature = "circle-dot-dashed")]
+mod circle_dot_dashed;
+#[cfg(feature = "circle-ellipsis")]
+mod circle_ellipsis;
+#[cfg(feature = "circle-equal")]
+mod circle_equal;
+#[cfg(feature = "circle-fading-arrow-up")]
+mod circle_fading_arrow_up;
+#[cfg(feature = "circle-fading-plus")]
+mod circle_fading_plus;
+#[cfg(feature = "circle-gauge")]
+mod circle_gauge;
+#[cfg(feature = "circle-help")]
+mod circle_help;
+#[cfg(feature = "circle-minus")]
+mod circle_minus;
+#[cfg(feature = "circle-off")]
+mod circle_off;
+#[cfg(feature = "circle-parking")]
+mod circle_parking;
+#[cfg(feature = "circle-parking-off")]
+mod circle_parking_off;
+#[cfg(feature = "circle-pause")]
+mod circle_pause;
+#[cfg(feature = "circle-percent")]
+mod circle_percent;
+#[cfg(feature = "circle-play")]
+mod circle_play;
+#[cfg(feature = "circle-plus")]
+mod circle_plus;
+#[cfg(feature = "circle-power")]
+mod circle_power;
+#[cfg(feature = "circle-slash")]
+mod circle_slash;
+#[cfg(feature = "circle-slash-2")]
+mod circle_slash_2;
+#[cfg(feature = "circle-stop")]
+mod circle_stop;
+#[cfg(feature = "circle-user")]
+mod circle_user;
+#[cfg(feature = "circle-user-round")]
+mod circle_user_round;
+#[cfg(feature = "circle-x")]
+mod circle_x;
+#[cfg(feature = "circuit-board")]
+mod circuit_board;
+#[cfg(feature = "citrus")]
+mod citrus;
+#[cfg(feature = "clapperboard")]
+mod clapperboard;
+#[cfg(feature = "clipboard")]
+mod clipboard;
+#[cfg(feature = "clipboard-check")]
+mod clipboard_check;
+#[cfg(feature = "clipboard-copy")]
+mod clipboard_copy;
+#[cfg(feature = "clipboard-list")]
+mod clipboard_list;
+#[cfg(feature = "clipboard-minus")]
+mod clipboard_minus;
+#[cfg(feature = "clipboard-paste")]
+mod clipboard_paste;
+#[cfg(feature = "clipboard-pen")]
+mod clipboard_pen;
+#[cfg(feature = "clipboard-pen-line")]
+mod clipboard_pen_line;
+#[cfg(feature = "clipboard-plus")]
+mod clipboard_plus;
+#[cfg(feature = "clipboard-type")]
+mod clipboard_type;
+#[cfg(feature = "clipboard-x")]
+mod clipboard_x;
+#[cfg(feature = "clock")]
+mod clock;
+#[cfg(feature = "clock-1")]
+mod clock_1;
+#[cfg(feature = "clock-10")]
+mod clock_10;
+#[cfg(feature = "clock-11")]
+mod clock_11;
+#[cfg(feature = "clock-12")]
+mod clock_12;
+#[cfg(feature = "clock-2")]
+mod clock_2;
+#[cfg(feature = "clock-3")]
+mod clock_3;
+#[cfg(feature = "clock-4")]
+mod clock_4;
+#[cfg(feature = "clock-5")]
+mod clock_5;
+#[cfg(feature = "clock-6")]
+mod clock_6;
+#[cfg(feature = "clock-7")]
+mod clock_7;
+#[cfg(feature = "clock-8")]
+mod clock_8;
+#[cfg(feature = "clock-9")]
+mod clock_9;
+#[cfg(feature = "clock-alert")]
+mod clock_alert;
+#[cfg(feature = "clock-arrow-down")]
+mod clock_arrow_down;
+#[cfg(feature = "clock-arrow-up")]
+mod clock_arrow_up;
+#[cfg(feature = "cloud")]
+mod cloud;
+#[cfg(feature = "cloud-alert")]
+mod cloud_alert;
+#[cfg(feature = "cloud-cog")]
+mod cloud_cog;
+#[cfg(feature = "cloud-download")]
+mod cloud_download;
+#[cfg(feature = "cloud-drizzle")]
+mod cloud_drizzle;
+#[cfg(feature = "cloud-fog")]
+mod cloud_fog;
+#[cfg(feature = "cloud-hail")]
+mod cloud_hail;
+#[cfg(feature = "cloud-lightning")]
+mod cloud_lightning;
+#[cfg(feature = "cloud-moon")]
+mod cloud_moon;
+#[cfg(feature = "cloud-moon-rain")]
+mod cloud_moon_rain;
+#[cfg(feature = "cloud-off")]
+mod cloud_off;
+#[cfg(feature = "cloud-rain")]
+mod cloud_rain;
+#[cfg(feature = "cloud-rain-wind")]
+mod cloud_rain_wind;
+#[cfg(feature = "cloud-snow")]
+mod cloud_snow;
+#[cfg(feature = "cloud-sun")]
+mod cloud_sun;
+#[cfg(feature = "cloud-sun-rain")]
+mod cloud_sun_rain;
+#[cfg(feature = "cloud-upload")]
+mod cloud_upload;
+#[cfg(feature = "cloudy")]
+mod cloudy;
+#[cfg(feature = "clover")]
+mod clover;
+#[cfg(feature = "club")]
+mod club;
+#[cfg(feature = "code")]
+mod code;
+#[cfg(feature = "code-xml")]
+mod code_xml;
+#[cfg(feature = "codepen")]
+mod codepen;
+#[cfg(feature = "codesandbox")]
+mod codesandbox;
+#[cfg(feature = "coffee")]
+mod coffee;
+#[cfg(feature = "cog")]
+mod cog;
+#[cfg(feature = "coins")]
+mod coins;
+#[cfg(feature = "columns-2")]
+mod columns_2;
+#[cfg(feature = "columns-3")]
+mod columns_3;
+#[cfg(feature = "columns-4")]
+mod columns_4;
+#[cfg(feature = "combine")]
+mod combine;
+#[cfg(feature = "command")]
+mod command;
+#[cfg(feature = "compass")]
+mod compass;
+#[cfg(feature = "component")]
+mod component;
+#[cfg(feature = "computer")]
+mod computer;
+#[cfg(feature = "concierge-bell")]
+mod concierge_bell;
+#[cfg(feature = "cone")]
+mod cone;
+#[cfg(feature = "construction")]
+mod construction;
+#[cfg(feature = "contact")]
+mod contact;
+#[cfg(feature = "contact-round")]
+mod contact_round;
+#[cfg(feature = "container")]
+mod container;
+#[cfg(feature = "contrast")]
+mod contrast;
+#[cfg(feature = "cookie")]
+mod cookie;
+#[cfg(feature = "cooking-pot")]
+mod cooking_pot;
+#[cfg(feature = "copy")]
+mod copy;
+#[cfg(feature = "copy-check")]
+mod copy_check;
+#[cfg(feature = "copy-minus")]
+mod copy_minus;
+#[cfg(feature = "copy-plus")]
+mod copy_plus;
+#[cfg(feature = "copy-slash")]
+mod copy_slash;
+#[cfg(feature = "copy-x")]
+mod copy_x;
+#[cfg(feature = "copyleft")]
+mod copyleft;
+#[cfg(feature = "copyright")]
+mod copyright;
+#[cfg(feature = "corner-down-left")]
+mod corner_down_left;
+#[cfg(feature = "corner-down-right")]
+mod corner_down_right;
+#[cfg(feature = "corner-left-down")]
+mod corner_left_down;
+#[cfg(feature = "corner-left-up")]
+mod corner_left_up;
+#[cfg(feature = "corner-right-down")]
+mod corner_right_down;
+#[cfg(feature = "corner-right-up")]
+mod corner_right_up;
+#[cfg(feature = "corner-up-left")]
+mod corner_up_left;
+#[cfg(feature = "corner-up-right")]
+mod corner_up_right;
+#[cfg(feature = "cpu")]
+mod cpu;
+#[cfg(feature = "creative-commons")]
+mod creative_commons;
+#[cfg(feature = "credit-card")]
+mod credit_card;
+#[cfg(feature = "croissant")]
+mod croissant;
+#[cfg(feature = "crop")]
+mod crop;
+#[cfg(feature = "cross")]
+mod cross;
+#[cfg(feature = "crosshair")]
+mod crosshair;
+#[cfg(feature = "crown")]
+mod crown;
+#[cfg(feature = "cuboid")]
+mod cuboid;
+#[cfg(feature = "cup-soda")]
+mod cup_soda;
+#[cfg(feature = "currency")]
+mod currency;
+#[cfg(feature = "cylinder")]
+mod cylinder;
+#[cfg(feature = "dam")]
+mod dam;
+#[cfg(feature = "database")]
+mod database;
+#[cfg(feature = "database-backup")]
+mod database_backup;
+#[cfg(feature = "database-zap")]
+mod database_zap;
+#[cfg(feature = "delete")]
+mod delete;
+#[cfg(feature = "dessert")]
+mod dessert;
+#[cfg(feature = "diameter")]
+mod diameter;
+#[cfg(feature = "diamond")]
+mod diamond;
+#[cfg(feature = "diamond-minus")]
+mod diamond_minus;
+#[cfg(feature = "diamond-percent")]
+mod diamond_percent;
+#[cfg(feature = "diamond-plus")]
+mod diamond_plus;
+#[cfg(feature = "dice-1")]
+mod dice_1;
+#[cfg(feature = "dice-2")]
+mod dice_2;
+#[cfg(feature = "dice-3")]
+mod dice_3;
+#[cfg(feature = "dice-4")]
+mod dice_4;
+#[cfg(feature = "dice-5")]
+mod dice_5;
+#[cfg(feature = "dice-6")]
+mod dice_6;
+#[cfg(feature = "dices")]
+mod dices;
+#[cfg(feature = "diff")]
+mod diff;
+#[cfg(feature = "disc")]
+mod disc;
+#[cfg(feature = "disc-2")]
+mod disc_2;
+#[cfg(feature = "disc-3")]
+mod disc_3;
+#[cfg(feature = "disc-album")]
+mod disc_album;
+#[cfg(feature = "divide")]
+mod divide;
+#[cfg(feature = "dna")]
+mod dna;
+#[cfg(feature = "dna-off")]
+mod dna_off;
+#[cfg(feature = "dock")]
+mod dock;
+#[cfg(feature = "dog")]
+mod dog;
+#[cfg(feature = "dollar-sign")]
+mod dollar_sign;
+#[cfg(feature = "donut")]
+mod donut;
+#[cfg(feature = "door-closed")]
+mod door_closed;
+#[cfg(feature = "door-open")]
+mod door_open;
+#[cfg(feature = "dot")]
+mod dot;
+#[cfg(feature = "download")]
+mod download;
+#[cfg(feature = "drafting-compass")]
+mod drafting_compass;
+#[cfg(feature = "drama")]
+mod drama;
+#[cfg(feature = "dribbble")]
+mod dribbble;
+#[cfg(feature = "drill")]
+mod drill;
+#[cfg(feature = "droplet")]
+mod droplet;
+#[cfg(feature = "droplets")]
+mod droplets;
+#[cfg(feature = "drum")]
+mod drum;
+#[cfg(feature = "drumstick")]
+mod drumstick;
+#[cfg(feature = "dumbbell")]
+mod dumbbell;
+#[cfg(feature = "ear")]
+mod ear;
+#[cfg(feature = "ear-off")]
+mod ear_off;
+#[cfg(feature = "earth")]
+mod earth;
+#[cfg(feature = "earth-lock")]
+mod earth_lock;
+#[cfg(feature = "eclipse")]
+mod eclipse;
+#[cfg(feature = "egg")]
+mod egg;
+#[cfg(feature = "egg-fried")]
+mod egg_fried;
+#[cfg(feature = "egg-off")]
+mod egg_off;
+#[cfg(feature = "ellipsis")]
+mod ellipsis;
+#[cfg(feature = "ellipsis-vertical")]
+mod ellipsis_vertical;
+#[cfg(feature = "equal")]
+mod equal;
+#[cfg(feature = "equal-approximately")]
+mod equal_approximately;
+#[cfg(feature = "equal-not")]
+mod equal_not;
+#[cfg(feature = "eraser")]
+mod eraser;
+#[cfg(feature = "ethernet-port")]
+mod ethernet_port;
+#[cfg(feature = "euro")]
+mod euro;
+#[cfg(feature = "expand")]
+mod expand;
+#[cfg(feature = "external-link")]
+mod external_link;
+#[cfg(feature = "eye")]
+mod eye;
+#[cfg(feature = "eye-closed")]
+mod eye_closed;
+#[cfg(feature = "eye-off")]
+mod eye_off;
+#[cfg(feature = "facebook")]
+mod facebook;
+#[cfg(feature = "factory")]
+mod factory;
+#[cfg(feature = "fan")]
+mod fan;
+#[cfg(feature = "fast-forward")]
+mod fast_forward;
+#[cfg(feature = "feather")]
+mod feather;
+#[cfg(feature = "fence")]
+mod fence;
+#[cfg(feature = "ferris-wheel")]
+mod ferris_wheel;
+#[cfg(feature = "figma")]
+mod figma;
+#[cfg(feature = "file")]
+mod file;
+#[cfg(feature = "file-archive")]
+mod file_archive;
+#[cfg(feature = "file-audio")]
+mod file_audio;
+#[cfg(feature = "file-audio-2")]
+mod file_audio_2;
+#[cfg(feature = "file-axis-3-d")]
+mod file_axis_3_d;
+#[cfg(feature = "file-badge")]
+mod file_badge;
+#[cfg(feature = "file-badge-2")]
+mod file_badge_2;
+#[cfg(feature = "file-box")]
+mod file_box;
+#[cfg(feature = "file-chart-column")]
+mod file_chart_column;
+#[cfg(feature = "file-chart-column-increasing")]
+mod file_chart_column_increasing;
+#[cfg(feature = "file-chart-line")]
+mod file_chart_line;
+#[cfg(feature = "file-chart-pie")]
+mod file_chart_pie;
+#[cfg(feature = "file-check")]
+mod file_check;
+#[cfg(feature = "file-check-2")]
+mod file_check_2;
+#[cfg(feature = "file-clock")]
+mod file_clock;
+#[cfg(feature = "file-code")]
+mod file_code;
+#[cfg(feature = "file-code-2")]
+mod file_code_2;
+#[cfg(feature = "file-cog")]
+mod file_cog;
+#[cfg(feature = "file-diff")]
+mod file_diff;
+#[cfg(feature = "file-digit")]
+mod file_digit;
+#[cfg(feature = "file-down")]
+mod file_down;
+#[cfg(feature = "file-heart")]
+mod file_heart;
+#[cfg(feature = "file-image")]
+mod file_image;
+#[cfg(feature = "file-input")]
+mod file_input;
+#[cfg(feature = "file-json")]
+mod file_json;
+#[cfg(feature = "file-json-2")]
+mod file_json_2;
+#[cfg(feature = "file-key")]
+mod file_key;
+#[cfg(feature = "file-key-2")]
+mod file_key_2;
+#[cfg(feature = "file-lock")]
+mod file_lock;
+#[cfg(feature = "file-lock-2")]
+mod file_lock_2;
+#[cfg(feature = "file-minus")]
+mod file_minus;
+#[cfg(feature = "file-minus-2")]
+mod file_minus_2;
+#[cfg(feature = "file-music")]
+mod file_music;
+#[cfg(feature = "file-output")]
+mod file_output;
+#[cfg(feature = "file-pen")]
+mod file_pen;
+#[cfg(feature = "file-pen-line")]
+mod file_pen_line;
+#[cfg(feature = "file-plus")]
+mod file_plus;
+#[cfg(feature = "file-plus-2")]
+mod file_plus_2;
+#[cfg(feature = "file-question")]
+mod file_question;
+#[cfg(feature = "file-scan")]
+mod file_scan;
+#[cfg(feature = "file-search")]
+mod file_search;
+#[cfg(feature = "file-search-2")]
+mod file_search_2;
+#[cfg(feature = "file-sliders")]
+mod file_sliders;
+#[cfg(feature = "file-spreadsheet")]
+mod file_spreadsheet;
+#[cfg(feature = "file-stack")]
+mod file_stack;
+#[cfg(feature = "file-symlink")]
+mod file_symlink;
+#[cfg(feature = "file-terminal")]
+mod file_terminal;
+#[cfg(feature = "file-text")]
+mod file_text;
+#[cfg(feature = "file-type")]
+mod file_type;
+#[cfg(feature = "file-type-2")]
+mod file_type_2;
+#[cfg(feature = "file-up")]
+mod file_up;
+#[cfg(feature = "file-user")]
+mod file_user;
+#[cfg(feature = "file-video")]
+mod file_video;
+#[cfg(feature = "file-video-2")]
+mod file_video_2;
+#[cfg(feature = "file-volume")]
+mod file_volume;
+#[cfg(feature = "file-volume-2")]
+mod file_volume_2;
+#[cfg(feature = "file-warning")]
+mod file_warning;
+#[cfg(feature = "file-x")]
+mod file_x;
+#[cfg(feature = "file-x-2")]
+mod file_x_2;
+#[cfg(feature = "files")]
+mod files;
+#[cfg(feature = "film")]
+mod film;
+#[cfg(feature = "filter")]
+mod filter;
+#[cfg(feature = "filter-x")]
+mod filter_x;
+#[cfg(feature = "fingerprint")]
+mod fingerprint;
+#[cfg(feature = "fire-extinguisher")]
+mod fire_extinguisher;
+#[cfg(feature = "fish")]
+mod fish;
+#[cfg(feature = "fish-off")]
+mod fish_off;
+#[cfg(feature = "fish-symbol")]
+mod fish_symbol;
+#[cfg(feature = "flag")]
+mod flag;
+#[cfg(feature = "flag-off")]
+mod flag_off;
+#[cfg(feature = "flag-triangle-left")]
+mod flag_triangle_left;
+#[cfg(feature = "flag-triangle-right")]
+mod flag_triangle_right;
+#[cfg(feature = "flame")]
+mod flame;
+#[cfg(feature = "flame-kindling")]
+mod flame_kindling;
+#[cfg(feature = "flashlight")]
+mod flashlight;
+#[cfg(feature = "flashlight-off")]
+mod flashlight_off;
+#[cfg(feature = "flask-conical")]
+mod flask_conical;
+#[cfg(feature = "flask-conical-off")]
+mod flask_conical_off;
+#[cfg(feature = "flask-round")]
+mod flask_round;
+#[cfg(feature = "flip-horizontal")]
+mod flip_horizontal;
+#[cfg(feature = "flip-horizontal-2")]
+mod flip_horizontal_2;
+#[cfg(feature = "flip-vertical")]
+mod flip_vertical;
+#[cfg(feature = "flip-vertical-2")]
+mod flip_vertical_2;
+#[cfg(feature = "flower")]
+mod flower;
+#[cfg(feature = "flower-2")]
+mod flower_2;
+#[cfg(feature = "focus")]
+mod focus;
+#[cfg(feature = "fold-horizontal")]
+mod fold_horizontal;
+#[cfg(feature = "fold-vertical")]
+mod fold_vertical;
+#[cfg(feature = "folder")]
+mod folder;
+#[cfg(feature = "folder-archive")]
+mod folder_archive;
+#[cfg(feature = "folder-check")]
+mod folder_check;
+#[cfg(feature = "folder-clock")]
+mod folder_clock;
+#[cfg(feature = "folder-closed")]
+mod folder_closed;
+#[cfg(feature = "folder-code")]
+mod folder_code;
+#[cfg(feature = "folder-cog")]
+mod folder_cog;
+#[cfg(feature = "folder-dot")]
+mod folder_dot;
+#[cfg(feature = "folder-down")]
+mod folder_down;
+#[cfg(feature = "folder-git")]
+mod folder_git;
+#[cfg(feature = "folder-git-2")]
+mod folder_git_2;
+#[cfg(feature = "folder-heart")]
+mod folder_heart;
+#[cfg(feature = "folder-input")]
+mod folder_input;
+#[cfg(feature = "folder-kanban")]
+mod folder_kanban;
+#[cfg(feature = "folder-key")]
+mod folder_key;
+#[cfg(feature = "folder-lock")]
+mod folder_lock;
+#[cfg(feature = "folder-minus")]
+mod folder_minus;
+#[cfg(feature = "folder-open")]
+mod folder_open;
+#[cfg(feature = "folder-open-dot")]
+mod folder_open_dot;
+#[cfg(feature = "folder-output")]
+mod folder_output;
+#[cfg(feature = "folder-pen")]
+mod folder_pen;
+#[cfg(feature = "folder-plus")]
+mod folder_plus;
+#[cfg(feature = "folder-root")]
+mod folder_root;
+#[cfg(feature = "folder-search")]
+mod folder_search;
+#[cfg(feature = "folder-search-2")]
+mod folder_search_2;
+#[cfg(feature = "folder-symlink")]
+mod folder_symlink;
+#[cfg(feature = "folder-sync")]
+mod folder_sync;
+#[cfg(feature = "folder-tree")]
+mod folder_tree;
+#[cfg(feature = "folder-up")]
+mod folder_up;
+#[cfg(feature = "folder-x")]
+mod folder_x;
+#[cfg(feature = "folders")]
+mod folders;
+#[cfg(feature = "footprints")]
+mod footprints;
+#[cfg(feature = "forklift")]
+mod forklift;
+#[cfg(feature = "forward")]
+mod forward;
+#[cfg(feature = "frame")]
+mod frame;
+#[cfg(feature = "framer")]
+mod framer;
+#[cfg(feature = "frown")]
+mod frown;
+#[cfg(feature = "fuel")]
+mod fuel;
+#[cfg(feature = "fullscreen")]
+mod fullscreen;
+#[cfg(feature = "gallery-horizontal")]
+mod gallery_horizontal;
+#[cfg(feature = "gallery-horizontal-end")]
+mod gallery_horizontal_end;
+#[cfg(feature = "gallery-thumbnails")]
+mod gallery_thumbnails;
+#[cfg(feature = "gallery-vertical")]
+mod gallery_vertical;
+#[cfg(feature = "gallery-vertical-end")]
+mod gallery_vertical_end;
+#[cfg(feature = "gamepad")]
+mod gamepad;
+#[cfg(feature = "gamepad-2")]
+mod gamepad_2;
+#[cfg(feature = "gauge")]
+mod gauge;
+#[cfg(feature = "gavel")]
+mod gavel;
+#[cfg(feature = "gem")]
+mod gem;
+#[cfg(feature = "ghost")]
+mod ghost;
+#[cfg(feature = "gift")]
+mod gift;
+#[cfg(feature = "git-branch")]
+mod git_branch;
+#[cfg(feature = "git-branch-plus")]
+mod git_branch_plus;
+#[cfg(feature = "git-commit-horizontal")]
+mod git_commit_horizontal;
+#[cfg(feature = "git-commit-vertical")]
+mod git_commit_vertical;
+#[cfg(feature = "git-compare")]
+mod git_compare;
+#[cfg(feature = "git-compare-arrows")]
+mod git_compare_arrows;
+#[cfg(feature = "git-fork")]
+mod git_fork;
+#[cfg(feature = "git-graph")]
+mod git_graph;
+#[cfg(feature = "git-merge")]
+mod git_merge;
+#[cfg(feature = "git-pull-request")]
+mod git_pull_request;
+#[cfg(feature = "git-pull-request-arrow")]
+mod git_pull_request_arrow;
+#[cfg(feature = "git-pull-request-closed")]
+mod git_pull_request_closed;
+#[cfg(feature = "git-pull-request-create")]
+mod git_pull_request_create;
+#[cfg(feature = "git-pull-request-create-arrow")]
+mod git_pull_request_create_arrow;
+#[cfg(feature = "git-pull-request-draft")]
+mod git_pull_request_draft;
+#[cfg(feature = "github")]
+mod github;
+#[cfg(feature = "gitlab")]
+mod gitlab;
+#[cfg(feature = "glass-water")]
+mod glass_water;
+#[cfg(feature = "glasses")]
+mod glasses;
+#[cfg(feature = "globe")]
+mod globe;
+#[cfg(feature = "globe-lock")]
+mod globe_lock;
+#[cfg(feature = "goal")]
+mod goal;
+#[cfg(feature = "grab")]
+mod grab;
+#[cfg(feature = "graduation-cap")]
+mod graduation_cap;
+#[cfg(feature = "grape")]
+mod grape;
+#[cfg(feature = "grid-2-x-2")]
+mod grid_2_x_2;
+#[cfg(feature = "grid-2-x-2-check")]
+mod grid_2_x_2_check;
+#[cfg(feature = "grid-2-x-2-plus")]
+mod grid_2_x_2_plus;
+#[cfg(feature = "grid-2-x-2-x")]
+mod grid_2_x_2_x;
+#[cfg(feature = "grid-3-x-3")]
+mod grid_3_x_3;
+#[cfg(feature = "grip")]
+mod grip;
+#[cfg(feature = "grip-horizontal")]
+mod grip_horizontal;
+#[cfg(feature = "grip-vertical")]
+mod grip_vertical;
+#[cfg(feature = "group")]
+mod group;
+#[cfg(feature = "guitar")]
+mod guitar;
+#[cfg(feature = "ham")]
+mod ham;
+#[cfg(feature = "hammer")]
+mod hammer;
+#[cfg(feature = "hand")]
+mod hand;
+#[cfg(feature = "hand-coins")]
+mod hand_coins;
+#[cfg(feature = "hand-heart")]
+mod hand_heart;
+#[cfg(feature = "hand-helping")]
+mod hand_helping;
+#[cfg(feature = "hand-metal")]
+mod hand_metal;
+#[cfg(feature = "hand-platter")]
+mod hand_platter;
+#[cfg(feature = "handshake")]
+mod handshake;
+#[cfg(feature = "hard-drive")]
+mod hard_drive;
+#[cfg(feature = "hard-drive-download")]
+mod hard_drive_download;
+#[cfg(feature = "hard-drive-upload")]
+mod hard_drive_upload;
+#[cfg(feature = "hard-hat")]
+mod hard_hat;
+#[cfg(feature = "hash")]
+mod hash;
+#[cfg(feature = "haze")]
+mod haze;
+#[cfg(feature = "hdmi-port")]
+mod hdmi_port;
+#[cfg(feature = "heading")]
+mod heading;
+#[cfg(feature = "heading-1")]
+mod heading_1;
+#[cfg(feature = "heading-2")]
+mod heading_2;
+#[cfg(feature = "heading-3")]
+mod heading_3;
+#[cfg(feature = "heading-4")]
+mod heading_4;
+#[cfg(feature = "heading-5")]
+mod heading_5;
+#[cfg(feature = "heading-6")]
+mod heading_6;
+#[cfg(feature = "headphone-off")]
+mod headphone_off;
+#[cfg(feature = "headphones")]
+mod headphones;
+#[cfg(feature = "headset")]
+mod headset;
+#[cfg(feature = "heart")]
+mod heart;
+#[cfg(feature = "heart-crack")]
+mod heart_crack;
+#[cfg(feature = "heart-handshake")]
+mod heart_handshake;
+#[cfg(feature = "heart-off")]
+mod heart_off;
+#[cfg(feature = "heart-pulse")]
+mod heart_pulse;
+#[cfg(feature = "heater")]
+mod heater;
+#[cfg(feature = "hexagon")]
+mod hexagon;
+#[cfg(feature = "highlighter")]
+mod highlighter;
+#[cfg(feature = "history")]
+mod history;
+#[cfg(feature = "hop")]
+mod hop;
+#[cfg(feature = "hop-off")]
+mod hop_off;
+#[cfg(feature = "hospital")]
+mod hospital;
+#[cfg(feature = "hotel")]
+mod hotel;
+#[cfg(feature = "hourglass")]
+mod hourglass;
+#[cfg(feature = "house")]
+mod house;
+#[cfg(feature = "house-plug")]
+mod house_plug;
+#[cfg(feature = "house-plus")]
+mod house_plus;
+#[cfg(feature = "ice-cream-bowl")]
+mod ice_cream_bowl;
+#[cfg(feature = "ice-cream-cone")]
+mod ice_cream_cone;
+#[cfg(feature = "id-card")]
+mod id_card;
+#[cfg(feature = "image")]
+mod image;
+#[cfg(feature = "image-down")]
+mod image_down;
+#[cfg(feature = "image-minus")]
+mod image_minus;
+#[cfg(feature = "image-off")]
+mod image_off;
+#[cfg(feature = "image-play")]
+mod image_play;
+#[cfg(feature = "image-plus")]
+mod image_plus;
+#[cfg(feature = "image-up")]
+mod image_up;
+#[cfg(feature = "images")]
+mod images;
+#[cfg(feature = "import")]
+mod import;
+#[cfg(feature = "inbox")]
+mod inbox;
+#[cfg(feature = "indent-decrease")]
+mod indent_decrease;
+#[cfg(feature = "indent-increase")]
+mod indent_increase;
+#[cfg(feature = "indian-rupee")]
+mod indian_rupee;
+#[cfg(feature = "infinity")]
+mod infinity;
+#[cfg(feature = "info")]
+mod info;
+#[cfg(feature = "inspection-panel")]
+mod inspection_panel;
+#[cfg(feature = "instagram")]
+mod instagram;
+#[cfg(feature = "italic")]
+mod italic;
+#[cfg(feature = "iteration-ccw")]
+mod iteration_ccw;
+#[cfg(feature = "iteration-cw")]
+mod iteration_cw;
+#[cfg(feature = "japanese-yen")]
+mod japanese_yen;
+#[cfg(feature = "joystick")]
+mod joystick;
+#[cfg(feature = "kanban")]
+mod kanban;
+#[cfg(feature = "key")]
+mod key;
+#[cfg(feature = "key-round")]
+mod key_round;
+#[cfg(feature = "key-square")]
+mod key_square;
+#[cfg(feature = "keyboard")]
+mod keyboard;
+#[cfg(feature = "keyboard-music")]
+mod keyboard_music;
+#[cfg(feature = "keyboard-off")]
+mod keyboard_off;
+#[cfg(feature = "lamp")]
+mod lamp;
+#[cfg(feature = "lamp-ceiling")]
+mod lamp_ceiling;
+#[cfg(feature = "lamp-desk")]
+mod lamp_desk;
+#[cfg(feature = "lamp-floor")]
+mod lamp_floor;
+#[cfg(feature = "lamp-wall-down")]
+mod lamp_wall_down;
+#[cfg(feature = "lamp-wall-up")]
+mod lamp_wall_up;
+#[cfg(feature = "land-plot")]
+mod land_plot;
+#[cfg(feature = "landmark")]
+mod landmark;
+#[cfg(feature = "languages")]
+mod languages;
+#[cfg(feature = "laptop")]
+mod laptop;
+#[cfg(feature = "laptop-minimal")]
+mod laptop_minimal;
+#[cfg(feature = "laptop-minimal-check")]
+mod laptop_minimal_check;
+#[cfg(feature = "lasso")]
+mod lasso;
+#[cfg(feature = "lasso-select")]
+mod lasso_select;
+#[cfg(feature = "laugh")]
+mod laugh;
+#[cfg(feature = "layers")]
+mod layers;
+#[cfg(feature = "layers-2")]
+mod layers_2;
+#[cfg(feature = "layers-3")]
+mod layers_3;
+#[cfg(feature = "layout-dashboard")]
+mod layout_dashboard;
+#[cfg(feature = "layout-grid")]
+mod layout_grid;
+#[cfg(feature = "layout-list")]
+mod layout_list;
+#[cfg(feature = "layout-panel-left")]
+mod layout_panel_left;
+#[cfg(feature = "layout-panel-top")]
+mod layout_panel_top;
+#[cfg(feature = "layout-template")]
+mod layout_template;
+#[cfg(feature = "leaf")]
+mod leaf;
+#[cfg(feature = "leafy-green")]
+mod leafy_green;
+#[cfg(feature = "lectern")]
+mod lectern;
+#[cfg(feature = "letter-text")]
+mod letter_text;
+#[cfg(feature = "library")]
+mod library;
+#[cfg(feature = "library-big")]
+mod library_big;
+#[cfg(feature = "life-buoy")]
+mod life_buoy;
+#[cfg(feature = "ligature")]
+mod ligature;
+#[cfg(feature = "lightbulb")]
+mod lightbulb;
+#[cfg(feature = "lightbulb-off")]
+mod lightbulb_off;
+#[cfg(feature = "link")]
+mod link;
+#[cfg(feature = "link-2")]
+mod link_2;
+#[cfg(feature = "link-2-off")]
+mod link_2_off;
+#[cfg(feature = "linkedin")]
+mod linkedin;
+#[cfg(feature = "list")]
+mod list;
+#[cfg(feature = "list-check")]
+mod list_check;
+#[cfg(feature = "list-checks")]
+mod list_checks;
+#[cfg(feature = "list-collapse")]
+mod list_collapse;
+#[cfg(feature = "list-end")]
+mod list_end;
+#[cfg(feature = "list-filter")]
+mod list_filter;
+#[cfg(feature = "list-minus")]
+mod list_minus;
+#[cfg(feature = "list-music")]
+mod list_music;
+#[cfg(feature = "list-ordered")]
+mod list_ordered;
+#[cfg(feature = "list-plus")]
+mod list_plus;
+#[cfg(feature = "list-restart")]
+mod list_restart;
+#[cfg(feature = "list-start")]
+mod list_start;
+#[cfg(feature = "list-todo")]
+mod list_todo;
+#[cfg(feature = "list-tree")]
+mod list_tree;
+#[cfg(feature = "list-video")]
+mod list_video;
+#[cfg(feature = "list-x")]
+mod list_x;
+#[cfg(feature = "loader")]
+mod loader;
+#[cfg(feature = "loader-circle")]
+mod loader_circle;
+#[cfg(feature = "loader-pinwheel")]
+mod loader_pinwheel;
+#[cfg(feature = "locate")]
+mod locate;
+#[cfg(feature = "locate-fixed")]
+mod locate_fixed;
+#[cfg(feature = "locate-off")]
+mod locate_off;
+#[cfg(feature = "lock")]
+mod lock;
+#[cfg(feature = "lock-keyhole")]
+mod lock_keyhole;
+#[cfg(feature = "lock-keyhole-open")]
+mod lock_keyhole_open;
+#[cfg(feature = "lock-open")]
+mod lock_open;
+#[cfg(feature = "log-in")]
+mod log_in;
+#[cfg(feature = "log-out")]
+mod log_out;
+#[cfg(feature = "logs")]
+mod logs;
+#[cfg(feature = "lollipop")]
+mod lollipop;
+#[cfg(feature = "luggage")]
+mod luggage;
+#[cfg(feature = "magnet")]
+mod magnet;
+#[cfg(feature = "mail")]
+mod mail;
+#[cfg(feature = "mail-check")]
+mod mail_check;
+#[cfg(feature = "mail-minus")]
+mod mail_minus;
+#[cfg(feature = "mail-open")]
+mod mail_open;
+#[cfg(feature = "mail-plus")]
+mod mail_plus;
+#[cfg(feature = "mail-question")]
+mod mail_question;
+#[cfg(feature = "mail-search")]
+mod mail_search;
+#[cfg(feature = "mail-warning")]
+mod mail_warning;
+#[cfg(feature = "mail-x")]
+mod mail_x;
+#[cfg(feature = "mailbox")]
+mod mailbox;
+#[cfg(feature = "mails")]
+mod mails;
+#[cfg(feature = "map")]
+mod map;
+#[cfg(feature = "map-pin")]
+mod map_pin;
+#[cfg(feature = "map-pin-check")]
+mod map_pin_check;
+#[cfg(feature = "map-pin-check-inside")]
+mod map_pin_check_inside;
+#[cfg(feature = "map-pin-house")]
+mod map_pin_house;
+#[cfg(feature = "map-pin-minus")]
+mod map_pin_minus;
+#[cfg(feature = "map-pin-minus-inside")]
+mod map_pin_minus_inside;
+#[cfg(feature = "map-pin-off")]
+mod map_pin_off;
+#[cfg(feature = "map-pin-plus")]
+mod map_pin_plus;
+#[cfg(feature = "map-pin-plus-inside")]
+mod map_pin_plus_inside;
+#[cfg(feature = "map-pin-x")]
+mod map_pin_x;
+#[cfg(feature = "map-pin-x-inside")]
+mod map_pin_x_inside;
+#[cfg(feature = "map-pinned")]
+mod map_pinned;
+#[cfg(feature = "martini")]
+mod martini;
+#[cfg(feature = "maximize")]
+mod maximize;
+#[cfg(feature = "maximize-2")]
+mod maximize_2;
+#[cfg(feature = "medal")]
+mod medal;
+#[cfg(feature = "megaphone")]
+mod megaphone;
+#[cfg(feature = "megaphone-off")]
+mod megaphone_off;
+#[cfg(feature = "meh")]
+mod meh;
+#[cfg(feature = "memory-stick")]
+mod memory_stick;
+#[cfg(feature = "menu")]
+mod menu;
+#[cfg(feature = "merge")]
+mod merge;
+#[cfg(feature = "message-circle")]
+mod message_circle;
+#[cfg(feature = "message-circle-code")]
+mod message_circle_code;
+#[cfg(feature = "message-circle-dashed")]
+mod message_circle_dashed;
+#[cfg(feature = "message-circle-heart")]
+mod message_circle_heart;
+#[cfg(feature = "message-circle-more")]
+mod message_circle_more;
+#[cfg(feature = "message-circle-off")]
+mod message_circle_off;
+#[cfg(feature = "message-circle-plus")]
+mod message_circle_plus;
+#[cfg(feature = "message-circle-question")]
+mod message_circle_question;
+#[cfg(feature = "message-circle-reply")]
+mod message_circle_reply;
+#[cfg(feature = "message-circle-warning")]
+mod message_circle_warning;
+#[cfg(feature = "message-circle-x")]
+mod message_circle_x;
+#[cfg(feature = "message-square")]
+mod message_square;
+#[cfg(feature = "message-square-code")]
+mod message_square_code;
+#[cfg(feature = "message-square-dashed")]
+mod message_square_dashed;
+#[cfg(feature = "message-square-diff")]
+mod message_square_diff;
+#[cfg(feature = "message-square-dot")]
+mod message_square_dot;
+#[cfg(feature = "message-square-heart")]
+mod message_square_heart;
+#[cfg(feature = "message-square-lock")]
+mod message_square_lock;
+#[cfg(feature = "message-square-more")]
+mod message_square_more;
+#[cfg(feature = "message-square-off")]
+mod message_square_off;
+#[cfg(feature = "message-square-plus")]
+mod message_square_plus;
+#[cfg(feature = "message-square-quote")]
+mod message_square_quote;
+#[cfg(feature = "message-square-reply")]
+mod message_square_reply;
+#[cfg(feature = "message-square-share")]
+mod message_square_share;
+#[cfg(feature = "message-square-text")]
+mod message_square_text;
+#[cfg(feature = "message-square-warning")]
+mod message_square_warning;
+#[cfg(feature = "message-square-x")]
+mod message_square_x;
+#[cfg(feature = "messages-square")]
+mod messages_square;
+#[cfg(feature = "mic")]
+mod mic;
+#[cfg(feature = "mic-off")]
+mod mic_off;
+#[cfg(feature = "mic-vocal")]
+mod mic_vocal;
+#[cfg(feature = "microchip")]
+mod microchip;
+#[cfg(feature = "microscope")]
+mod microscope;
+#[cfg(feature = "microwave")]
+mod microwave;
+#[cfg(feature = "milestone")]
+mod milestone;
+#[cfg(feature = "milk")]
+mod milk;
+#[cfg(feature = "milk-off")]
+mod milk_off;
+#[cfg(feature = "minimize")]
+mod minimize;
+#[cfg(feature = "minimize-2")]
+mod minimize_2;
+#[cfg(feature = "minus")]
+mod minus;
+#[cfg(feature = "monitor")]
+mod monitor;
+#[cfg(feature = "monitor-check")]
+mod monitor_check;
+#[cfg(feature = "monitor-cog")]
+mod monitor_cog;
+#[cfg(feature = "monitor-dot")]
+mod monitor_dot;
+#[cfg(feature = "monitor-down")]
+mod monitor_down;
+#[cfg(feature = "monitor-off")]
+mod monitor_off;
+#[cfg(feature = "monitor-pause")]
+mod monitor_pause;
+#[cfg(feature = "monitor-play")]
+mod monitor_play;
+#[cfg(feature = "monitor-smartphone")]
+mod monitor_smartphone;
+#[cfg(feature = "monitor-speaker")]
+mod monitor_speaker;
+#[cfg(feature = "monitor-stop")]
+mod monitor_stop;
+#[cfg(feature = "monitor-up")]
+mod monitor_up;
+#[cfg(feature = "monitor-x")]
+mod monitor_x;
+#[cfg(feature = "moon")]
+mod moon;
+#[cfg(feature = "moon-star")]
+mod moon_star;
+#[cfg(feature = "mountain")]
+mod mountain;
+#[cfg(feature = "mountain-snow")]
+mod mountain_snow;
+#[cfg(feature = "mouse")]
+mod mouse;
+#[cfg(feature = "mouse-off")]
+mod mouse_off;
+#[cfg(feature = "mouse-pointer")]
+mod mouse_pointer;
+#[cfg(feature = "mouse-pointer-2")]
+mod mouse_pointer_2;
+#[cfg(feature = "mouse-pointer-ban")]
+mod mouse_pointer_ban;
+#[cfg(feature = "mouse-pointer-click")]
+mod mouse_pointer_click;
+#[cfg(feature = "move")]
+mod r#move;
+#[cfg(feature = "move-3-d")]
+mod move_3_d;
+#[cfg(feature = "move-diagonal")]
+mod move_diagonal;
+#[cfg(feature = "move-diagonal-2")]
+mod move_diagonal_2;
+#[cfg(feature = "move-down")]
+mod move_down;
+#[cfg(feature = "move-down-left")]
+mod move_down_left;
+#[cfg(feature = "move-down-right")]
+mod move_down_right;
+#[cfg(feature = "move-horizontal")]
+mod move_horizontal;
+#[cfg(feature = "move-left")]
+mod move_left;
+#[cfg(feature = "move-right")]
+mod move_right;
+#[cfg(feature = "move-up")]
+mod move_up;
+#[cfg(feature = "move-up-left")]
+mod move_up_left;
+#[cfg(feature = "move-up-right")]
+mod move_up_right;
+#[cfg(feature = "move-vertical")]
+mod move_vertical;
+#[cfg(feature = "music")]
+mod music;
+#[cfg(feature = "music-2")]
+mod music_2;
+#[cfg(feature = "music-3")]
+mod music_3;
+#[cfg(feature = "music-4")]
+mod music_4;
+#[cfg(feature = "navigation")]
+mod navigation;
+#[cfg(feature = "navigation-2")]
+mod navigation_2;
+#[cfg(feature = "navigation-2-off")]
+mod navigation_2_off;
+#[cfg(feature = "navigation-off")]
+mod navigation_off;
+#[cfg(feature = "network")]
+mod network;
+#[cfg(feature = "newspaper")]
+mod newspaper;
+#[cfg(feature = "nfc")]
+mod nfc;
+#[cfg(feature = "notebook")]
+mod notebook;
+#[cfg(feature = "notebook-pen")]
+mod notebook_pen;
+#[cfg(feature = "notebook-tabs")]
+mod notebook_tabs;
+#[cfg(feature = "notebook-text")]
+mod notebook_text;
+#[cfg(feature = "notepad-text")]
+mod notepad_text;
+#[cfg(feature = "notepad-text-dashed")]
+mod notepad_text_dashed;
+#[cfg(feature = "nut")]
+mod nut;
+#[cfg(feature = "nut-off")]
+mod nut_off;
+#[cfg(feature = "octagon")]
+mod octagon;
+#[cfg(feature = "octagon-alert")]
+mod octagon_alert;
+#[cfg(feature = "octagon-minus")]
+mod octagon_minus;
+#[cfg(feature = "octagon-pause")]
+mod octagon_pause;
+#[cfg(feature = "octagon-x")]
+mod octagon_x;
+#[cfg(feature = "omega")]
+mod omega;
+#[cfg(feature = "option")]
+mod option;
+#[cfg(feature = "orbit")]
+mod orbit;
+#[cfg(feature = "origami")]
+mod origami;
+#[cfg(feature = "package")]
+mod package;
+#[cfg(feature = "package-2")]
+mod package_2;
+#[cfg(feature = "package-check")]
+mod package_check;
+#[cfg(feature = "package-minus")]
+mod package_minus;
+#[cfg(feature = "package-open")]
+mod package_open;
+#[cfg(feature = "package-plus")]
+mod package_plus;
+#[cfg(feature = "package-search")]
+mod package_search;
+#[cfg(feature = "package-x")]
+mod package_x;
+#[cfg(feature = "paint-bucket")]
+mod paint_bucket;
+#[cfg(feature = "paint-roller")]
+mod paint_roller;
+#[cfg(feature = "paintbrush")]
+mod paintbrush;
+#[cfg(feature = "paintbrush-vertical")]
+mod paintbrush_vertical;
+#[cfg(feature = "palette")]
+mod palette;
+#[cfg(feature = "panel-bottom")]
+mod panel_bottom;
+#[cfg(feature = "panel-bottom-close")]
+mod panel_bottom_close;
+#[cfg(feature = "panel-bottom-dashed")]
+mod panel_bottom_dashed;
+#[cfg(feature = "panel-bottom-open")]
+mod panel_bottom_open;
+#[cfg(feature = "panel-left")]
+mod panel_left;
+#[cfg(feature = "panel-left-close")]
+mod panel_left_close;
+#[cfg(feature = "panel-left-dashed")]
+mod panel_left_dashed;
+#[cfg(feature = "panel-left-open")]
+mod panel_left_open;
+#[cfg(feature = "panel-right")]
+mod panel_right;
+#[cfg(feature = "panel-right-close")]
+mod panel_right_close;
+#[cfg(feature = "panel-right-dashed")]
+mod panel_right_dashed;
+#[cfg(feature = "panel-right-open")]
+mod panel_right_open;
+#[cfg(feature = "panel-top")]
+mod panel_top;
+#[cfg(feature = "panel-top-close")]
+mod panel_top_close;
+#[cfg(feature = "panel-top-dashed")]
+mod panel_top_dashed;
+#[cfg(feature = "panel-top-open")]
+mod panel_top_open;
+#[cfg(feature = "panels-left-bottom")]
+mod panels_left_bottom;
+#[cfg(feature = "panels-right-bottom")]
+mod panels_right_bottom;
+#[cfg(feature = "panels-top-left")]
+mod panels_top_left;
+#[cfg(feature = "paperclip")]
+mod paperclip;
+#[cfg(feature = "parentheses")]
+mod parentheses;
+#[cfg(feature = "parking-meter")]
+mod parking_meter;
+#[cfg(feature = "party-popper")]
+mod party_popper;
+#[cfg(feature = "pause")]
+mod pause;
+#[cfg(feature = "paw-print")]
+mod paw_print;
+#[cfg(feature = "pc-case")]
+mod pc_case;
+#[cfg(feature = "pen")]
+mod pen;
+#[cfg(feature = "pen-line")]
+mod pen_line;
+#[cfg(feature = "pen-off")]
+mod pen_off;
+#[cfg(feature = "pen-tool")]
+mod pen_tool;
+#[cfg(feature = "pencil")]
+mod pencil;
+#[cfg(feature = "pencil-line")]
+mod pencil_line;
+#[cfg(feature = "pencil-off")]
+mod pencil_off;
+#[cfg(feature = "pencil-ruler")]
+mod pencil_ruler;
+#[cfg(feature = "pentagon")]
+mod pentagon;
+#[cfg(feature = "percent")]
+mod percent;
+#[cfg(feature = "person-standing")]
+mod person_standing;
+#[cfg(feature = "philippine-peso")]
+mod philippine_peso;
+#[cfg(feature = "phone")]
+mod phone;
+#[cfg(feature = "phone-call")]
+mod phone_call;
+#[cfg(feature = "phone-forwarded")]
+mod phone_forwarded;
+#[cfg(feature = "phone-incoming")]
+mod phone_incoming;
+#[cfg(feature = "phone-missed")]
+mod phone_missed;
+#[cfg(feature = "phone-off")]
+mod phone_off;
+#[cfg(feature = "phone-outgoing")]
+mod phone_outgoing;
+#[cfg(feature = "pi")]
+mod pi;
+#[cfg(feature = "piano")]
+mod piano;
+#[cfg(feature = "pickaxe")]
+mod pickaxe;
+#[cfg(feature = "picture-in-picture")]
+mod picture_in_picture;
+#[cfg(feature = "picture-in-picture-2")]
+mod picture_in_picture_2;
+#[cfg(feature = "piggy-bank")]
+mod piggy_bank;
+#[cfg(feature = "pilcrow")]
+mod pilcrow;
+#[cfg(feature = "pilcrow-left")]
+mod pilcrow_left;
+#[cfg(feature = "pilcrow-right")]
+mod pilcrow_right;
+#[cfg(feature = "pill")]
+mod pill;
+#[cfg(feature = "pill-bottle")]
+mod pill_bottle;
+#[cfg(feature = "pin")]
+mod pin;
+#[cfg(feature = "pin-off")]
+mod pin_off;
+#[cfg(feature = "pipette")]
+mod pipette;
+#[cfg(feature = "pizza")]
+mod pizza;
+#[cfg(feature = "plane")]
+mod plane;
+#[cfg(feature = "plane-landing")]
+mod plane_landing;
+#[cfg(feature = "plane-takeoff")]
+mod plane_takeoff;
+#[cfg(feature = "play")]
+mod play;
+#[cfg(feature = "plug")]
+mod plug;
+#[cfg(feature = "plug-2")]
+mod plug_2;
+#[cfg(feature = "plug-zap")]
+mod plug_zap;
+#[cfg(feature = "plus")]
+mod plus;
+#[cfg(feature = "pocket")]
+mod pocket;
+#[cfg(feature = "pocket-knife")]
+mod pocket_knife;
+#[cfg(feature = "podcast")]
+mod podcast;
+#[cfg(feature = "pointer")]
+mod pointer;
+#[cfg(feature = "pointer-off")]
+mod pointer_off;
+#[cfg(feature = "popcorn")]
+mod popcorn;
+#[cfg(feature = "popsicle")]
+mod popsicle;
+#[cfg(feature = "pound-sterling")]
+mod pound_sterling;
+#[cfg(feature = "power")]
+mod power;
+#[cfg(feature = "power-off")]
+mod power_off;
+#[cfg(feature = "presentation")]
+mod presentation;
+#[cfg(feature = "printer")]
+mod printer;
+#[cfg(feature = "printer-check")]
+mod printer_check;
+#[cfg(feature = "projector")]
+mod projector;
+#[cfg(feature = "proportions")]
+mod proportions;
+#[cfg(feature = "puzzle")]
+mod puzzle;
+#[cfg(feature = "pyramid")]
+mod pyramid;
+#[cfg(feature = "qr-code")]
+mod qr_code;
+#[cfg(feature = "quote")]
+mod quote;
+#[cfg(feature = "rabbit")]
+mod rabbit;
+#[cfg(feature = "radar")]
+mod radar;
+#[cfg(feature = "radiation")]
+mod radiation;
+#[cfg(feature = "radical")]
+mod radical;
+#[cfg(feature = "radio")]
+mod radio;
+#[cfg(feature = "radio-receiver")]
+mod radio_receiver;
+#[cfg(feature = "radio-tower")]
+mod radio_tower;
+#[cfg(feature = "radius")]
+mod radius;
+#[cfg(feature = "rail-symbol")]
+mod rail_symbol;
+#[cfg(feature = "rainbow")]
+mod rainbow;
+#[cfg(feature = "rat")]
+mod rat;
+#[cfg(feature = "ratio")]
+mod ratio;
+#[cfg(feature = "receipt")]
+mod receipt;
+#[cfg(feature = "receipt-cent")]
+mod receipt_cent;
+#[cfg(feature = "receipt-euro")]
+mod receipt_euro;
+#[cfg(feature = "receipt-indian-rupee")]
+mod receipt_indian_rupee;
+#[cfg(feature = "receipt-japanese-yen")]
+mod receipt_japanese_yen;
+#[cfg(feature = "receipt-pound-sterling")]
+mod receipt_pound_sterling;
+#[cfg(feature = "receipt-russian-ruble")]
+mod receipt_russian_ruble;
+#[cfg(feature = "receipt-swiss-franc")]
+mod receipt_swiss_franc;
+#[cfg(feature = "receipt-text")]
+mod receipt_text;
+#[cfg(feature = "rectangle-ellipsis")]
+mod rectangle_ellipsis;
+#[cfg(feature = "rectangle-horizontal")]
+mod rectangle_horizontal;
+#[cfg(feature = "rectangle-vertical")]
+mod rectangle_vertical;
+#[cfg(feature = "recycle")]
+mod recycle;
+#[cfg(feature = "redo")]
+mod redo;
+#[cfg(feature = "redo-2")]
+mod redo_2;
+#[cfg(feature = "redo-dot")]
+mod redo_dot;
+#[cfg(feature = "refresh-ccw")]
+mod refresh_ccw;
+#[cfg(feature = "refresh-ccw-dot")]
+mod refresh_ccw_dot;
+#[cfg(feature = "refresh-cw")]
+mod refresh_cw;
+#[cfg(feature = "refresh-cw-off")]
+mod refresh_cw_off;
+#[cfg(feature = "refrigerator")]
+mod refrigerator;
+#[cfg(feature = "regex")]
+mod regex;
+#[cfg(feature = "remove-formatting")]
+mod remove_formatting;
+#[cfg(feature = "repeat")]
+mod repeat;
+#[cfg(feature = "repeat-1")]
+mod repeat_1;
+#[cfg(feature = "repeat-2")]
+mod repeat_2;
+#[cfg(feature = "replace")]
+mod replace;
+#[cfg(feature = "replace-all")]
+mod replace_all;
+#[cfg(feature = "reply")]
+mod reply;
+#[cfg(feature = "reply-all")]
+mod reply_all;
+#[cfg(feature = "rewind")]
+mod rewind;
+#[cfg(feature = "ribbon")]
+mod ribbon;
+#[cfg(feature = "rocket")]
+mod rocket;
+#[cfg(feature = "rocking-chair")]
+mod rocking_chair;
+#[cfg(feature = "roller-coaster")]
+mod roller_coaster;
+#[cfg(feature = "rotate-3-d")]
+mod rotate_3_d;
+#[cfg(feature = "rotate-ccw")]
+mod rotate_ccw;
+#[cfg(feature = "rotate-ccw-square")]
+mod rotate_ccw_square;
+#[cfg(feature = "rotate-cw")]
+mod rotate_cw;
+#[cfg(feature = "rotate-cw-square")]
+mod rotate_cw_square;
+#[cfg(feature = "route")]
+mod route;
+#[cfg(feature = "route-off")]
+mod route_off;
+#[cfg(feature = "router")]
+mod router;
+#[cfg(feature = "rows-2")]
+mod rows_2;
+#[cfg(feature = "rows-3")]
+mod rows_3;
+#[cfg(feature = "rows-4")]
+mod rows_4;
+#[cfg(feature = "rss")]
+mod rss;
+#[cfg(feature = "ruler")]
+mod ruler;
+#[cfg(feature = "russian-ruble")]
+mod russian_ruble;
+#[cfg(feature = "sailboat")]
+mod sailboat;
+#[cfg(feature = "salad")]
+mod salad;
+#[cfg(feature = "sandwich")]
+mod sandwich;
+#[cfg(feature = "satellite")]
+mod satellite;
+#[cfg(feature = "satellite-dish")]
+mod satellite_dish;
+#[cfg(feature = "save")]
+mod save;
+#[cfg(feature = "save-all")]
+mod save_all;
+#[cfg(feature = "save-off")]
+mod save_off;
+#[cfg(feature = "scale")]
+mod scale;
+#[cfg(feature = "scale-3-d")]
+mod scale_3_d;
+#[cfg(feature = "scaling")]
+mod scaling;
+#[cfg(feature = "scan")]
+mod scan;
+#[cfg(feature = "scan-barcode")]
+mod scan_barcode;
+#[cfg(feature = "scan-eye")]
+mod scan_eye;
+#[cfg(feature = "scan-face")]
+mod scan_face;
+#[cfg(feature = "scan-line")]
+mod scan_line;
+#[cfg(feature = "scan-qr-code")]
+mod scan_qr_code;
+#[cfg(feature = "scan-search")]
+mod scan_search;
+#[cfg(feature = "scan-text")]
+mod scan_text;
+#[cfg(feature = "school")]
+mod school;
+#[cfg(feature = "scissors")]
+mod scissors;
+#[cfg(feature = "scissors-line-dashed")]
+mod scissors_line_dashed;
+#[cfg(feature = "screen-share")]
+mod screen_share;
+#[cfg(feature = "screen-share-off")]
+mod screen_share_off;
+#[cfg(feature = "scroll")]
+mod scroll;
+#[cfg(feature = "scroll-text")]
+mod scroll_text;
+#[cfg(feature = "search")]
+mod search;
+#[cfg(feature = "search-check")]
+mod search_check;
+#[cfg(feature = "search-code")]
+mod search_code;
+#[cfg(feature = "search-slash")]
+mod search_slash;
+#[cfg(feature = "search-x")]
+mod search_x;
+#[cfg(feature = "section")]
+mod section;
+#[cfg(feature = "send")]
+mod send;
+#[cfg(feature = "send-horizontal")]
+mod send_horizontal;
+#[cfg(feature = "send-to-back")]
+mod send_to_back;
+#[cfg(feature = "separator-horizontal")]
+mod separator_horizontal;
+#[cfg(feature = "separator-vertical")]
+mod separator_vertical;
+#[cfg(feature = "server")]
+mod server;
+#[cfg(feature = "server-cog")]
+mod server_cog;
+#[cfg(feature = "server-crash")]
+mod server_crash;
+#[cfg(feature = "server-off")]
+mod server_off;
+#[cfg(feature = "settings")]
+mod settings;
+#[cfg(feature = "settings-2")]
+mod settings_2;
+#[cfg(feature = "shapes")]
+mod shapes;
+#[cfg(feature = "share")]
+mod share;
+#[cfg(feature = "share-2")]
+mod share_2;
+#[cfg(feature = "sheet")]
+mod sheet;
+#[cfg(feature = "shell")]
+mod shell;
+#[cfg(feature = "shield")]
+mod shield;
+#[cfg(feature = "shield-alert")]
+mod shield_alert;
+#[cfg(feature = "shield-ban")]
+mod shield_ban;
+#[cfg(feature = "shield-check")]
+mod shield_check;
+#[cfg(feature = "shield-ellipsis")]
+mod shield_ellipsis;
+#[cfg(feature = "shield-half")]
+mod shield_half;
+#[cfg(feature = "shield-minus")]
+mod shield_minus;
+#[cfg(feature = "shield-off")]
+mod shield_off;
+#[cfg(feature = "shield-plus")]
+mod shield_plus;
+#[cfg(feature = "shield-question")]
+mod shield_question;
+#[cfg(feature = "shield-x")]
+mod shield_x;
+#[cfg(feature = "ship")]
+mod ship;
+#[cfg(feature = "ship-wheel")]
+mod ship_wheel;
+#[cfg(feature = "shirt")]
+mod shirt;
+#[cfg(feature = "shopping-bag")]
+mod shopping_bag;
+#[cfg(feature = "shopping-basket")]
+mod shopping_basket;
+#[cfg(feature = "shopping-cart")]
+mod shopping_cart;
+#[cfg(feature = "shovel")]
+mod shovel;
+#[cfg(feature = "shower-head")]
+mod shower_head;
+#[cfg(feature = "shrink")]
+mod shrink;
+#[cfg(feature = "shrub")]
+mod shrub;
+#[cfg(feature = "shuffle")]
+mod shuffle;
+#[cfg(feature = "sigma")]
+mod sigma;
+#[cfg(feature = "signal")]
+mod signal;
+#[cfg(feature = "signal-high")]
+mod signal_high;
+#[cfg(feature = "signal-low")]
+mod signal_low;
+#[cfg(feature = "signal-medium")]
+mod signal_medium;
+#[cfg(feature = "signal-zero")]
+mod signal_zero;
+#[cfg(feature = "signature")]
+mod signature;
+#[cfg(feature = "signpost")]
+mod signpost;
+#[cfg(feature = "signpost-big")]
+mod signpost_big;
+#[cfg(feature = "siren")]
+mod siren;
+#[cfg(feature = "skip-back")]
+mod skip_back;
+#[cfg(feature = "skip-forward")]
+mod skip_forward;
+#[cfg(feature = "skull")]
+mod skull;
+#[cfg(feature = "slack")]
+mod slack;
+#[cfg(feature = "slash")]
+mod slash;
+#[cfg(feature = "slice")]
+mod slice;
+#[cfg(feature = "sliders-horizontal")]
+mod sliders_horizontal;
+#[cfg(feature = "sliders-vertical")]
+mod sliders_vertical;
+#[cfg(feature = "smartphone")]
+mod smartphone;
+#[cfg(feature = "smartphone-charging")]
+mod smartphone_charging;
+#[cfg(feature = "smartphone-nfc")]
+mod smartphone_nfc;
+#[cfg(feature = "smile")]
+mod smile;
+#[cfg(feature = "smile-plus")]
+mod smile_plus;
+#[cfg(feature = "snail")]
+mod snail;
+#[cfg(feature = "snowflake")]
+mod snowflake;
+#[cfg(feature = "sofa")]
+mod sofa;
+#[cfg(feature = "soup")]
+mod soup;
+#[cfg(feature = "space")]
+mod space;
+#[cfg(feature = "spade")]
+mod spade;
+#[cfg(feature = "sparkle")]
+mod sparkle;
+#[cfg(feature = "sparkles")]
+mod sparkles;
+#[cfg(feature = "speaker")]
+mod speaker;
+#[cfg(feature = "speech")]
+mod speech;
+#[cfg(feature = "spell-check")]
+mod spell_check;
+#[cfg(feature = "spell-check-2")]
+mod spell_check_2;
+#[cfg(feature = "spline")]
+mod spline;
+#[cfg(feature = "split")]
+mod split;
+#[cfg(feature = "spray-can")]
+mod spray_can;
+#[cfg(feature = "sprout")]
+mod sprout;
+#[cfg(feature = "square")]
+mod square;
+#[cfg(feature = "square-activity")]
+mod square_activity;
+#[cfg(feature = "square-arrow-down")]
+mod square_arrow_down;
+#[cfg(feature = "square-arrow-down-left")]
+mod square_arrow_down_left;
+#[cfg(feature = "square-arrow-down-right")]
+mod square_arrow_down_right;
+#[cfg(feature = "square-arrow-left")]
+mod square_arrow_left;
+#[cfg(feature = "square-arrow-out-down-left")]
+mod square_arrow_out_down_left;
+#[cfg(feature = "square-arrow-out-down-right")]
+mod square_arrow_out_down_right;
+#[cfg(feature = "square-arrow-out-up-left")]
+mod square_arrow_out_up_left;
+#[cfg(feature = "square-arrow-out-up-right")]
+mod square_arrow_out_up_right;
+#[cfg(feature = "square-arrow-right")]
+mod square_arrow_right;
+#[cfg(feature = "square-arrow-up")]
+mod square_arrow_up;
+#[cfg(feature = "square-arrow-up-left")]
+mod square_arrow_up_left;
+#[cfg(feature = "square-arrow-up-right")]
+mod square_arrow_up_right;
+#[cfg(feature = "square-asterisk")]
+mod square_asterisk;
+#[cfg(feature = "square-bottom-dashed-scissors")]
+mod square_bottom_dashed_scissors;
+#[cfg(feature = "square-chart-gantt")]
+mod square_chart_gantt;
+#[cfg(feature = "square-check")]
+mod square_check;
+#[cfg(feature = "square-check-big")]
+mod square_check_big;
+#[cfg(feature = "square-chevron-down")]
+mod square_chevron_down;
+#[cfg(feature = "square-chevron-left")]
+mod square_chevron_left;
+#[cfg(feature = "square-chevron-right")]
+mod square_chevron_right;
+#[cfg(feature = "square-chevron-up")]
+mod square_chevron_up;
+#[cfg(feature = "square-code")]
+mod square_code;
+#[cfg(feature = "square-dashed")]
+mod square_dashed;
+#[cfg(feature = "square-dashed-bottom")]
+mod square_dashed_bottom;
+#[cfg(feature = "square-dashed-bottom-code")]
+mod square_dashed_bottom_code;
+#[cfg(feature = "square-dashed-kanban")]
+mod square_dashed_kanban;
+#[cfg(feature = "square-dashed-mouse-pointer")]
+mod square_dashed_mouse_pointer;
+#[cfg(feature = "square-divide")]
+mod square_divide;
+#[cfg(feature = "square-dot")]
+mod square_dot;
+#[cfg(feature = "square-equal")]
+mod square_equal;
+#[cfg(feature = "square-function")]
+mod square_function;
+#[cfg(feature = "square-kanban")]
+mod square_kanban;
+#[cfg(feature = "square-library")]
+mod square_library;
+#[cfg(feature = "square-m")]
+mod square_m;
+#[cfg(feature = "square-menu")]
+mod square_menu;
+#[cfg(feature = "square-minus")]
+mod square_minus;
+#[cfg(feature = "square-mouse-pointer")]
+mod square_mouse_pointer;
+#[cfg(feature = "square-parking")]
+mod square_parking;
+#[cfg(feature = "square-parking-off")]
+mod square_parking_off;
+#[cfg(feature = "square-pen")]
+mod square_pen;
+#[cfg(feature = "square-percent")]
+mod square_percent;
+#[cfg(feature = "square-pi")]
+mod square_pi;
+#[cfg(feature = "square-pilcrow")]
+mod square_pilcrow;
+#[cfg(feature = "square-play")]
+mod square_play;
+#[cfg(feature = "square-plus")]
+mod square_plus;
+#[cfg(feature = "square-power")]
+mod square_power;
+#[cfg(feature = "square-radical")]
+mod square_radical;
+#[cfg(feature = "square-scissors")]
+mod square_scissors;
+#[cfg(feature = "square-sigma")]
+mod square_sigma;
+#[cfg(feature = "square-slash")]
+mod square_slash;
+#[cfg(feature = "square-split-horizontal")]
+mod square_split_horizontal;
+#[cfg(feature = "square-split-vertical")]
+mod square_split_vertical;
+#[cfg(feature = "square-square")]
+mod square_square;
+#[cfg(feature = "square-stack")]
+mod square_stack;
+#[cfg(feature = "square-terminal")]
+mod square_terminal;
+#[cfg(feature = "square-user")]
+mod square_user;
+#[cfg(feature = "square-user-round")]
+mod square_user_round;
+#[cfg(feature = "square-x")]
+mod square_x;
+#[cfg(feature = "squircle")]
+mod squircle;
+#[cfg(feature = "squirrel")]
+mod squirrel;
+#[cfg(feature = "stamp")]
+mod stamp;
+#[cfg(feature = "star")]
+mod star;
+#[cfg(feature = "star-half")]
+mod star_half;
+#[cfg(feature = "star-off")]
+mod star_off;
+#[cfg(feature = "step-back")]
+mod step_back;
+#[cfg(feature = "step-forward")]
+mod step_forward;
+#[cfg(feature = "stethoscope")]
+mod stethoscope;
+#[cfg(feature = "sticker")]
+mod sticker;
+#[cfg(feature = "sticky-note")]
+mod sticky_note;
+#[cfg(feature = "store")]
+mod store;
+#[cfg(feature = "stretch-horizontal")]
+mod stretch_horizontal;
+#[cfg(feature = "stretch-vertical")]
+mod stretch_vertical;
+#[cfg(feature = "strikethrough")]
+mod strikethrough;
+#[cfg(feature = "subscript")]
+mod subscript;
+#[cfg(feature = "sun")]
+mod sun;
+#[cfg(feature = "sun-dim")]
+mod sun_dim;
+#[cfg(feature = "sun-medium")]
+mod sun_medium;
+#[cfg(feature = "sun-moon")]
+mod sun_moon;
+#[cfg(feature = "sun-snow")]
+mod sun_snow;
+#[cfg(feature = "sunrise")]
+mod sunrise;
+#[cfg(feature = "sunset")]
+mod sunset;
+#[cfg(feature = "superscript")]
+mod superscript;
+#[cfg(feature = "swatch-book")]
+mod swatch_book;
+#[cfg(feature = "swiss-franc")]
+mod swiss_franc;
+#[cfg(feature = "switch-camera")]
+mod switch_camera;
+#[cfg(feature = "sword")]
+mod sword;
+#[cfg(feature = "swords")]
+mod swords;
+#[cfg(feature = "syringe")]
+mod syringe;
+#[cfg(feature = "table")]
+mod table;
+#[cfg(feature = "table-2")]
+mod table_2;
+#[cfg(feature = "table-cells-merge")]
+mod table_cells_merge;
+#[cfg(feature = "table-cells-split")]
+mod table_cells_split;
+#[cfg(feature = "table-columns-split")]
+mod table_columns_split;
+#[cfg(feature = "table-of-contents")]
+mod table_of_contents;
+#[cfg(feature = "table-properties")]
+mod table_properties;
+#[cfg(feature = "table-rows-split")]
+mod table_rows_split;
+#[cfg(feature = "tablet")]
+mod tablet;
+#[cfg(feature = "tablet-smartphone")]
+mod tablet_smartphone;
+#[cfg(feature = "tablets")]
+mod tablets;
+#[cfg(feature = "tag")]
+mod tag;
+#[cfg(feature = "tags")]
+mod tags;
+#[cfg(feature = "tally-1")]
+mod tally_1;
+#[cfg(feature = "tally-2")]
+mod tally_2;
+#[cfg(feature = "tally-3")]
+mod tally_3;
+#[cfg(feature = "tally-4")]
+mod tally_4;
+#[cfg(feature = "tally-5")]
+mod tally_5;
+#[cfg(feature = "tangent")]
+mod tangent;
+#[cfg(feature = "target")]
+mod target;
+#[cfg(feature = "telescope")]
+mod telescope;
+#[cfg(feature = "tent")]
+mod tent;
+#[cfg(feature = "tent-tree")]
+mod tent_tree;
+#[cfg(feature = "terminal")]
+mod terminal;
+#[cfg(feature = "test-tube")]
+mod test_tube;
+#[cfg(feature = "test-tube-diagonal")]
+mod test_tube_diagonal;
+#[cfg(feature = "test-tubes")]
+mod test_tubes;
+#[cfg(feature = "text")]
+mod text;
+#[cfg(feature = "text-cursor")]
+mod text_cursor;
+#[cfg(feature = "text-cursor-input")]
+mod text_cursor_input;
+#[cfg(feature = "text-quote")]
+mod text_quote;
+#[cfg(feature = "text-search")]
+mod text_search;
+#[cfg(feature = "text-select")]
+mod text_select;
+#[cfg(feature = "theater")]
+mod theater;
+#[cfg(feature = "thermometer")]
+mod thermometer;
+#[cfg(feature = "thermometer-snowflake")]
+mod thermometer_snowflake;
+#[cfg(feature = "thermometer-sun")]
+mod thermometer_sun;
+#[cfg(feature = "thumbs-down")]
+mod thumbs_down;
+#[cfg(feature = "thumbs-up")]
+mod thumbs_up;
+#[cfg(feature = "ticket")]
+mod ticket;
+#[cfg(feature = "ticket-check")]
+mod ticket_check;
+#[cfg(feature = "ticket-minus")]
+mod ticket_minus;
+#[cfg(feature = "ticket-percent")]
+mod ticket_percent;
+#[cfg(feature = "ticket-plus")]
+mod ticket_plus;
+#[cfg(feature = "ticket-slash")]
+mod ticket_slash;
+#[cfg(feature = "ticket-x")]
+mod ticket_x;
+#[cfg(feature = "tickets")]
+mod tickets;
+#[cfg(feature = "tickets-plane")]
+mod tickets_plane;
+#[cfg(feature = "timer")]
+mod timer;
+#[cfg(feature = "timer-off")]
+mod timer_off;
+#[cfg(feature = "timer-reset")]
+mod timer_reset;
+#[cfg(feature = "toggle-left")]
+mod toggle_left;
+#[cfg(feature = "toggle-right")]
+mod toggle_right;
+#[cfg(feature = "toilet")]
+mod toilet;
+#[cfg(feature = "tornado")]
+mod tornado;
+#[cfg(feature = "torus")]
+mod torus;
+#[cfg(feature = "touchpad")]
+mod touchpad;
+#[cfg(feature = "touchpad-off")]
+mod touchpad_off;
+#[cfg(feature = "tower-control")]
+mod tower_control;
+#[cfg(feature = "toy-brick")]
+mod toy_brick;
+#[cfg(feature = "tractor")]
+mod tractor;
+#[cfg(feature = "traffic-cone")]
+mod traffic_cone;
+#[cfg(feature = "train-front")]
+mod train_front;
+#[cfg(feature = "train-front-tunnel")]
+mod train_front_tunnel;
+#[cfg(feature = "train-track")]
+mod train_track;
+#[cfg(feature = "tram-front")]
+mod tram_front;
+#[cfg(feature = "trash")]
+mod trash;
+#[cfg(feature = "trash-2")]
+mod trash_2;
+#[cfg(feature = "tree-deciduous")]
+mod tree_deciduous;
+#[cfg(feature = "tree-palm")]
+mod tree_palm;
+#[cfg(feature = "tree-pine")]
+mod tree_pine;
+#[cfg(feature = "trees")]
+mod trees;
+#[cfg(feature = "trello")]
+mod trello;
+#[cfg(feature = "trending-down")]
+mod trending_down;
+#[cfg(feature = "trending-up")]
+mod trending_up;
+#[cfg(feature = "trending-up-down")]
+mod trending_up_down;
+#[cfg(feature = "triangle")]
+mod triangle;
+#[cfg(feature = "triangle-alert")]
+mod triangle_alert;
+#[cfg(feature = "triangle-right")]
+mod triangle_right;
+#[cfg(feature = "trophy")]
+mod trophy;
+#[cfg(feature = "truck")]
+mod truck;
+#[cfg(feature = "turtle")]
+mod turtle;
+#[cfg(feature = "tv")]
+mod tv;
+#[cfg(feature = "tv-minimal")]
+mod tv_minimal;
+#[cfg(feature = "tv-minimal-play")]
+mod tv_minimal_play;
+#[cfg(feature = "twitch")]
+mod twitch;
+#[cfg(feature = "twitter")]
+mod twitter;
+#[cfg(feature = "type")]
+mod r#type;
+#[cfg(feature = "type-outline")]
+mod type_outline;
+#[cfg(feature = "umbrella")]
+mod umbrella;
+#[cfg(feature = "umbrella-off")]
+mod umbrella_off;
+#[cfg(feature = "underline")]
+mod underline;
+#[cfg(feature = "undo")]
+mod undo;
+#[cfg(feature = "undo-2")]
+mod undo_2;
+#[cfg(feature = "undo-dot")]
+mod undo_dot;
+#[cfg(feature = "unfold-horizontal")]
+mod unfold_horizontal;
+#[cfg(feature = "unfold-vertical")]
+mod unfold_vertical;
+#[cfg(feature = "ungroup")]
+mod ungroup;
+#[cfg(feature = "university")]
+mod university;
+#[cfg(feature = "unlink")]
+mod unlink;
+#[cfg(feature = "unlink-2")]
+mod unlink_2;
+#[cfg(feature = "unplug")]
+mod unplug;
+#[cfg(feature = "upload")]
+mod upload;
+#[cfg(feature = "usb")]
+mod usb;
+#[cfg(feature = "user")]
+mod user;
+#[cfg(feature = "user-check")]
+mod user_check;
+#[cfg(feature = "user-cog")]
+mod user_cog;
+#[cfg(feature = "user-minus")]
+mod user_minus;
+#[cfg(feature = "user-pen")]
+mod user_pen;
+#[cfg(feature = "user-plus")]
+mod user_plus;
+#[cfg(feature = "user-round")]
+mod user_round;
+#[cfg(feature = "user-round-check")]
+mod user_round_check;
+#[cfg(feature = "user-round-cog")]
+mod user_round_cog;
+#[cfg(feature = "user-round-minus")]
+mod user_round_minus;
+#[cfg(feature = "user-round-pen")]
+mod user_round_pen;
+#[cfg(feature = "user-round-plus")]
+mod user_round_plus;
+#[cfg(feature = "user-round-search")]
+mod user_round_search;
+#[cfg(feature = "user-round-x")]
+mod user_round_x;
+#[cfg(feature = "user-search")]
+mod user_search;
+#[cfg(feature = "user-x")]
+mod user_x;
+#[cfg(feature = "users")]
+mod users;
+#[cfg(feature = "users-round")]
+mod users_round;
+#[cfg(feature = "utensils")]
+mod utensils;
+#[cfg(feature = "utensils-crossed")]
+mod utensils_crossed;
+#[cfg(feature = "utility-pole")]
+mod utility_pole;
+#[cfg(feature = "variable")]
+mod variable;
+#[cfg(feature = "vault")]
+mod vault;
+#[cfg(feature = "vegan")]
+mod vegan;
+#[cfg(feature = "venetian-mask")]
+mod venetian_mask;
+#[cfg(feature = "vibrate")]
+mod vibrate;
+#[cfg(feature = "vibrate-off")]
+mod vibrate_off;
+#[cfg(feature = "video")]
+mod video;
+#[cfg(feature = "video-off")]
+mod video_off;
+#[cfg(feature = "videotape")]
+mod videotape;
+#[cfg(feature = "view")]
+mod view;
+#[cfg(feature = "voicemail")]
+mod voicemail;
+#[cfg(feature = "volleyball")]
+mod volleyball;
+#[cfg(feature = "volume")]
+mod volume;
+#[cfg(feature = "volume-1")]
+mod volume_1;
+#[cfg(feature = "volume-2")]
+mod volume_2;
+#[cfg(feature = "volume-off")]
+mod volume_off;
+#[cfg(feature = "volume-x")]
+mod volume_x;
+#[cfg(feature = "vote")]
+mod vote;
+#[cfg(feature = "wallet")]
+mod wallet;
+#[cfg(feature = "wallet-cards")]
+mod wallet_cards;
+#[cfg(feature = "wallet-minimal")]
+mod wallet_minimal;
+#[cfg(feature = "wallpaper")]
+mod wallpaper;
+#[cfg(feature = "wand")]
+mod wand;
+#[cfg(feature = "wand-sparkles")]
+mod wand_sparkles;
+#[cfg(feature = "warehouse")]
+mod warehouse;
+#[cfg(feature = "washing-machine")]
+mod washing_machine;
+#[cfg(feature = "watch")]
+mod watch;
+#[cfg(feature = "waves")]
+mod waves;
+#[cfg(feature = "waypoints")]
+mod waypoints;
+#[cfg(feature = "webcam")]
+mod webcam;
+#[cfg(feature = "webhook")]
+mod webhook;
+#[cfg(feature = "webhook-off")]
+mod webhook_off;
+#[cfg(feature = "weight")]
+mod weight;
+#[cfg(feature = "wheat")]
+mod wheat;
+#[cfg(feature = "wheat-off")]
+mod wheat_off;
+#[cfg(feature = "whole-word")]
+mod whole_word;
+#[cfg(feature = "wifi")]
+mod wifi;
+#[cfg(feature = "wifi-high")]
+mod wifi_high;
+#[cfg(feature = "wifi-low")]
+mod wifi_low;
+#[cfg(feature = "wifi-off")]
+mod wifi_off;
+#[cfg(feature = "wifi-zero")]
+mod wifi_zero;
+#[cfg(feature = "wind")]
+mod wind;
+#[cfg(feature = "wind-arrow-down")]
+mod wind_arrow_down;
+#[cfg(feature = "wine")]
+mod wine;
+#[cfg(feature = "wine-off")]
+mod wine_off;
+#[cfg(feature = "workflow")]
+mod workflow;
+#[cfg(feature = "worm")]
+mod worm;
+#[cfg(feature = "wrap-text")]
+mod wrap_text;
+#[cfg(feature = "wrench")]
+mod wrench;
+#[cfg(feature = "x")]
+mod x;
+#[cfg(feature = "youtube")]
+mod youtube;
+#[cfg(feature = "zap")]
+mod zap;
+#[cfg(feature = "zap-off")]
+mod zap_off;
+#[cfg(feature = "zoom-in")]
+mod zoom_in;
+#[cfg(feature = "zoom-out")]
+mod zoom_out;
+
+#[cfg(feature = "a-arrow-down")]
+pub use a_arrow_down::*;
+#[cfg(feature = "a-arrow-up")]
+pub use a_arrow_up::*;
+#[cfg(feature = "a-large-small")]
+pub use a_large_small::*;
+#[cfg(feature = "accessibility")]
+pub use accessibility::*;
+#[cfg(feature = "activity")]
+pub use activity::*;
+#[cfg(feature = "air-vent")]
+pub use air_vent::*;
+#[cfg(feature = "airplay")]
+pub use airplay::*;
+#[cfg(feature = "alarm-clock")]
+pub use alarm_clock::*;
+#[cfg(feature = "alarm-clock-check")]
+pub use alarm_clock_check::*;
+#[cfg(feature = "alarm-clock-minus")]
+pub use alarm_clock_minus::*;
+#[cfg(feature = "alarm-clock-off")]
+pub use alarm_clock_off::*;
+#[cfg(feature = "alarm-clock-plus")]
+pub use alarm_clock_plus::*;
+#[cfg(feature = "alarm-smoke")]
+pub use alarm_smoke::*;
+#[cfg(feature = "album")]
+pub use album::*;
+#[cfg(feature = "align-center")]
+pub use align_center::*;
+#[cfg(feature = "align-center-horizontal")]
+pub use align_center_horizontal::*;
+#[cfg(feature = "align-center-vertical")]
+pub use align_center_vertical::*;
+#[cfg(feature = "align-end-horizontal")]
+pub use align_end_horizontal::*;
+#[cfg(feature = "align-end-vertical")]
+pub use align_end_vertical::*;
+#[cfg(feature = "align-horizontal-distribute-center")]
+pub use align_horizontal_distribute_center::*;
+#[cfg(feature = "align-horizontal-distribute-end")]
+pub use align_horizontal_distribute_end::*;
+#[cfg(feature = "align-horizontal-distribute-start")]
+pub use align_horizontal_distribute_start::*;
+#[cfg(feature = "align-horizontal-justify-center")]
+pub use align_horizontal_justify_center::*;
+#[cfg(feature = "align-horizontal-justify-end")]
+pub use align_horizontal_justify_end::*;
+#[cfg(feature = "align-horizontal-justify-start")]
+pub use align_horizontal_justify_start::*;
+#[cfg(feature = "align-horizontal-space-around")]
+pub use align_horizontal_space_around::*;
+#[cfg(feature = "align-horizontal-space-between")]
+pub use align_horizontal_space_between::*;
+#[cfg(feature = "align-justify")]
+pub use align_justify::*;
+#[cfg(feature = "align-left")]
+pub use align_left::*;
+#[cfg(feature = "align-right")]
+pub use align_right::*;
+#[cfg(feature = "align-start-horizontal")]
+pub use align_start_horizontal::*;
+#[cfg(feature = "align-start-vertical")]
+pub use align_start_vertical::*;
+#[cfg(feature = "align-vertical-distribute-center")]
+pub use align_vertical_distribute_center::*;
+#[cfg(feature = "align-vertical-distribute-end")]
+pub use align_vertical_distribute_end::*;
+#[cfg(feature = "align-vertical-distribute-start")]
+pub use align_vertical_distribute_start::*;
+#[cfg(feature = "align-vertical-justify-center")]
+pub use align_vertical_justify_center::*;
+#[cfg(feature = "align-vertical-justify-end")]
+pub use align_vertical_justify_end::*;
+#[cfg(feature = "align-vertical-justify-start")]
+pub use align_vertical_justify_start::*;
+#[cfg(feature = "align-vertical-space-around")]
+pub use align_vertical_space_around::*;
+#[cfg(feature = "align-vertical-space-between")]
+pub use align_vertical_space_between::*;
+#[cfg(feature = "ambulance")]
+pub use ambulance::*;
+#[cfg(feature = "ampersand")]
+pub use ampersand::*;
+#[cfg(feature = "ampersands")]
+pub use ampersands::*;
+#[cfg(feature = "amphora")]
+pub use amphora::*;
+#[cfg(feature = "anchor")]
+pub use anchor::*;
+#[cfg(feature = "angry")]
+pub use angry::*;
+#[cfg(feature = "annoyed")]
+pub use annoyed::*;
+#[cfg(feature = "antenna")]
+pub use antenna::*;
+#[cfg(feature = "anvil")]
+pub use anvil::*;
+#[cfg(feature = "aperture")]
+pub use aperture::*;
+#[cfg(feature = "app-window")]
+pub use app_window::*;
+#[cfg(feature = "app-window-mac")]
+pub use app_window_mac::*;
+#[cfg(feature = "apple")]
+pub use apple::*;
+#[cfg(feature = "archive")]
+pub use archive::*;
+#[cfg(feature = "archive-restore")]
+pub use archive_restore::*;
+#[cfg(feature = "archive-x")]
+pub use archive_x::*;
+#[cfg(feature = "armchair")]
+pub use armchair::*;
+#[cfg(feature = "arrow-big-down")]
+pub use arrow_big_down::*;
+#[cfg(feature = "arrow-big-down-dash")]
+pub use arrow_big_down_dash::*;
+#[cfg(feature = "arrow-big-left")]
+pub use arrow_big_left::*;
+#[cfg(feature = "arrow-big-left-dash")]
+pub use arrow_big_left_dash::*;
+#[cfg(feature = "arrow-big-right")]
+pub use arrow_big_right::*;
+#[cfg(feature = "arrow-big-right-dash")]
+pub use arrow_big_right_dash::*;
+#[cfg(feature = "arrow-big-up")]
+pub use arrow_big_up::*;
+#[cfg(feature = "arrow-big-up-dash")]
+pub use arrow_big_up_dash::*;
+#[cfg(feature = "arrow-down")]
+pub use arrow_down::*;
+#[cfg(feature = "arrow-down-0-1")]
+pub use arrow_down_0_1::*;
+#[cfg(feature = "arrow-down-1-0")]
+pub use arrow_down_1_0::*;
+#[cfg(feature = "arrow-down-a-z")]
+pub use arrow_down_a_z::*;
+#[cfg(feature = "arrow-down-from-line")]
+pub use arrow_down_from_line::*;
+#[cfg(feature = "arrow-down-left")]
+pub use arrow_down_left::*;
+#[cfg(feature = "arrow-down-narrow-wide")]
+pub use arrow_down_narrow_wide::*;
+#[cfg(feature = "arrow-down-right")]
+pub use arrow_down_right::*;
+#[cfg(feature = "arrow-down-to-dot")]
+pub use arrow_down_to_dot::*;
+#[cfg(feature = "arrow-down-to-line")]
+pub use arrow_down_to_line::*;
+#[cfg(feature = "arrow-down-up")]
+pub use arrow_down_up::*;
+#[cfg(feature = "arrow-down-wide-narrow")]
+pub use arrow_down_wide_narrow::*;
+#[cfg(feature = "arrow-down-z-a")]
+pub use arrow_down_z_a::*;
+#[cfg(feature = "arrow-left")]
+pub use arrow_left::*;
+#[cfg(feature = "arrow-left-from-line")]
+pub use arrow_left_from_line::*;
+#[cfg(feature = "arrow-left-right")]
+pub use arrow_left_right::*;
+#[cfg(feature = "arrow-left-to-line")]
+pub use arrow_left_to_line::*;
+#[cfg(feature = "arrow-right")]
+pub use arrow_right::*;
+#[cfg(feature = "arrow-right-from-line")]
+pub use arrow_right_from_line::*;
+#[cfg(feature = "arrow-right-left")]
+pub use arrow_right_left::*;
+#[cfg(feature = "arrow-right-to-line")]
+pub use arrow_right_to_line::*;
+#[cfg(feature = "arrow-up")]
+pub use arrow_up::*;
+#[cfg(feature = "arrow-up-0-1")]
+pub use arrow_up_0_1::*;
+#[cfg(feature = "arrow-up-1-0")]
+pub use arrow_up_1_0::*;
+#[cfg(feature = "arrow-up-a-z")]
+pub use arrow_up_a_z::*;
+#[cfg(feature = "arrow-up-down")]
+pub use arrow_up_down::*;
+#[cfg(feature = "arrow-up-from-dot")]
+pub use arrow_up_from_dot::*;
+#[cfg(feature = "arrow-up-from-line")]
+pub use arrow_up_from_line::*;
+#[cfg(feature = "arrow-up-left")]
+pub use arrow_up_left::*;
+#[cfg(feature = "arrow-up-narrow-wide")]
+pub use arrow_up_narrow_wide::*;
+#[cfg(feature = "arrow-up-right")]
+pub use arrow_up_right::*;
+#[cfg(feature = "arrow-up-to-line")]
+pub use arrow_up_to_line::*;
+#[cfg(feature = "arrow-up-wide-narrow")]
+pub use arrow_up_wide_narrow::*;
+#[cfg(feature = "arrow-up-z-a")]
+pub use arrow_up_z_a::*;
+#[cfg(feature = "arrows-up-from-line")]
+pub use arrows_up_from_line::*;
+#[cfg(feature = "asterisk")]
+pub use asterisk::*;
+#[cfg(feature = "at-sign")]
+pub use at_sign::*;
+#[cfg(feature = "atom")]
+pub use atom::*;
+#[cfg(feature = "audio-lines")]
+pub use audio_lines::*;
+#[cfg(feature = "audio-waveform")]
+pub use audio_waveform::*;
+#[cfg(feature = "award")]
+pub use award::*;
+#[cfg(feature = "axe")]
+pub use axe::*;
+#[cfg(feature = "axis-3-d")]
+pub use axis_3_d::*;
+#[cfg(feature = "baby")]
+pub use baby::*;
+#[cfg(feature = "backpack")]
+pub use backpack::*;
+#[cfg(feature = "badge")]
+pub use badge::*;
+#[cfg(feature = "badge-alert")]
+pub use badge_alert::*;
+#[cfg(feature = "badge-cent")]
+pub use badge_cent::*;
+#[cfg(feature = "badge-check")]
+pub use badge_check::*;
+#[cfg(feature = "badge-dollar-sign")]
+pub use badge_dollar_sign::*;
+#[cfg(feature = "badge-euro")]
+pub use badge_euro::*;
+#[cfg(feature = "badge-help")]
+pub use badge_help::*;
+#[cfg(feature = "badge-indian-rupee")]
+pub use badge_indian_rupee::*;
+#[cfg(feature = "badge-info")]
+pub use badge_info::*;
+#[cfg(feature = "badge-japanese-yen")]
+pub use badge_japanese_yen::*;
+#[cfg(feature = "badge-minus")]
+pub use badge_minus::*;
+#[cfg(feature = "badge-percent")]
+pub use badge_percent::*;
+#[cfg(feature = "badge-plus")]
+pub use badge_plus::*;
+#[cfg(feature = "badge-pound-sterling")]
+pub use badge_pound_sterling::*;
+#[cfg(feature = "badge-russian-ruble")]
+pub use badge_russian_ruble::*;
+#[cfg(feature = "badge-swiss-franc")]
+pub use badge_swiss_franc::*;
+#[cfg(feature = "badge-x")]
+pub use badge_x::*;
+#[cfg(feature = "baggage-claim")]
+pub use baggage_claim::*;
+#[cfg(feature = "ban")]
+pub use ban::*;
+#[cfg(feature = "banana")]
+pub use banana::*;
+#[cfg(feature = "bandage")]
+pub use bandage::*;
+#[cfg(feature = "banknote")]
+pub use banknote::*;
+#[cfg(feature = "barcode")]
+pub use barcode::*;
+#[cfg(feature = "baseline")]
+pub use baseline::*;
+#[cfg(feature = "bath")]
+pub use bath::*;
+#[cfg(feature = "battery")]
+pub use battery::*;
+#[cfg(feature = "battery-charging")]
+pub use battery_charging::*;
+#[cfg(feature = "battery-full")]
+pub use battery_full::*;
+#[cfg(feature = "battery-low")]
+pub use battery_low::*;
+#[cfg(feature = "battery-medium")]
+pub use battery_medium::*;
+#[cfg(feature = "battery-warning")]
+pub use battery_warning::*;
+#[cfg(feature = "beaker")]
+pub use beaker::*;
+#[cfg(feature = "bean")]
+pub use bean::*;
+#[cfg(feature = "bean-off")]
+pub use bean_off::*;
+#[cfg(feature = "bed")]
+pub use bed::*;
+#[cfg(feature = "bed-double")]
+pub use bed_double::*;
+#[cfg(feature = "bed-single")]
+pub use bed_single::*;
+#[cfg(feature = "beef")]
+pub use beef::*;
+#[cfg(feature = "beer")]
+pub use beer::*;
+#[cfg(feature = "beer-off")]
+pub use beer_off::*;
+#[cfg(feature = "bell")]
+pub use bell::*;
+#[cfg(feature = "bell-dot")]
+pub use bell_dot::*;
+#[cfg(feature = "bell-electric")]
+pub use bell_electric::*;
+#[cfg(feature = "bell-minus")]
+pub use bell_minus::*;
+#[cfg(feature = "bell-off")]
+pub use bell_off::*;
+#[cfg(feature = "bell-plus")]
+pub use bell_plus::*;
+#[cfg(feature = "bell-ring")]
+pub use bell_ring::*;
+#[cfg(feature = "between-horizontal-end")]
+pub use between_horizontal_end::*;
+#[cfg(feature = "between-horizontal-start")]
+pub use between_horizontal_start::*;
+#[cfg(feature = "between-vertical-end")]
+pub use between_vertical_end::*;
+#[cfg(feature = "between-vertical-start")]
+pub use between_vertical_start::*;
+#[cfg(feature = "biceps-flexed")]
+pub use biceps_flexed::*;
+#[cfg(feature = "bike")]
+pub use bike::*;
+#[cfg(feature = "binary")]
+pub use binary::*;
+#[cfg(feature = "binoculars")]
+pub use binoculars::*;
+#[cfg(feature = "biohazard")]
+pub use biohazard::*;
+#[cfg(feature = "bird")]
+pub use bird::*;
+#[cfg(feature = "bitcoin")]
+pub use bitcoin::*;
+#[cfg(feature = "blend")]
+pub use blend::*;
+#[cfg(feature = "blinds")]
+pub use blinds::*;
+#[cfg(feature = "blocks")]
+pub use blocks::*;
+#[cfg(feature = "bluetooth")]
+pub use bluetooth::*;
+#[cfg(feature = "bluetooth-connected")]
+pub use bluetooth_connected::*;
+#[cfg(feature = "bluetooth-off")]
+pub use bluetooth_off::*;
+#[cfg(feature = "bluetooth-searching")]
+pub use bluetooth_searching::*;
+#[cfg(feature = "bold")]
+pub use bold::*;
+#[cfg(feature = "bolt")]
+pub use bolt::*;
+#[cfg(feature = "bomb")]
+pub use bomb::*;
+#[cfg(feature = "bone")]
+pub use bone::*;
+#[cfg(feature = "book")]
+pub use book::*;
+#[cfg(feature = "book-a")]
+pub use book_a::*;
+#[cfg(feature = "book-audio")]
+pub use book_audio::*;
+#[cfg(feature = "book-check")]
+pub use book_check::*;
+#[cfg(feature = "book-copy")]
+pub use book_copy::*;
+#[cfg(feature = "book-dashed")]
+pub use book_dashed::*;
+#[cfg(feature = "book-down")]
+pub use book_down::*;
+#[cfg(feature = "book-headphones")]
+pub use book_headphones::*;
+#[cfg(feature = "book-heart")]
+pub use book_heart::*;
+#[cfg(feature = "book-image")]
+pub use book_image::*;
+#[cfg(feature = "book-key")]
+pub use book_key::*;
+#[cfg(feature = "book-lock")]
+pub use book_lock::*;
+#[cfg(feature = "book-marked")]
+pub use book_marked::*;
+#[cfg(feature = "book-minus")]
+pub use book_minus::*;
+#[cfg(feature = "book-open")]
+pub use book_open::*;
+#[cfg(feature = "book-open-check")]
+pub use book_open_check::*;
+#[cfg(feature = "book-open-text")]
+pub use book_open_text::*;
+#[cfg(feature = "book-plus")]
+pub use book_plus::*;
+#[cfg(feature = "book-text")]
+pub use book_text::*;
+#[cfg(feature = "book-type")]
+pub use book_type::*;
+#[cfg(feature = "book-up")]
+pub use book_up::*;
+#[cfg(feature = "book-up-2")]
+pub use book_up_2::*;
+#[cfg(feature = "book-user")]
+pub use book_user::*;
+#[cfg(feature = "book-x")]
+pub use book_x::*;
+#[cfg(feature = "bookmark")]
+pub use bookmark::*;
+#[cfg(feature = "bookmark-check")]
+pub use bookmark_check::*;
+#[cfg(feature = "bookmark-minus")]
+pub use bookmark_minus::*;
+#[cfg(feature = "bookmark-plus")]
+pub use bookmark_plus::*;
+#[cfg(feature = "bookmark-x")]
+pub use bookmark_x::*;
+#[cfg(feature = "boom-box")]
+pub use boom_box::*;
+#[cfg(feature = "bot")]
+pub use bot::*;
+#[cfg(feature = "bot-message-square")]
+pub use bot_message_square::*;
+#[cfg(feature = "bot-off")]
+pub use bot_off::*;
+#[cfg(feature = "boxes")]
+pub use boxes::*;
+#[cfg(feature = "braces")]
+pub use braces::*;
+#[cfg(feature = "brackets")]
+pub use brackets::*;
+#[cfg(feature = "brain")]
+pub use brain::*;
+#[cfg(feature = "brain-circuit")]
+pub use brain_circuit::*;
+#[cfg(feature = "brain-cog")]
+pub use brain_cog::*;
+#[cfg(feature = "brick-wall")]
+pub use brick_wall::*;
+#[cfg(feature = "briefcase")]
+pub use briefcase::*;
+#[cfg(feature = "briefcase-business")]
+pub use briefcase_business::*;
+#[cfg(feature = "briefcase-conveyor-belt")]
+pub use briefcase_conveyor_belt::*;
+#[cfg(feature = "briefcase-medical")]
+pub use briefcase_medical::*;
+#[cfg(feature = "bring-to-front")]
+pub use bring_to_front::*;
+#[cfg(feature = "brush")]
+pub use brush::*;
+#[cfg(feature = "bug")]
+pub use bug::*;
+#[cfg(feature = "bug-off")]
+pub use bug_off::*;
+#[cfg(feature = "bug-play")]
+pub use bug_play::*;
+#[cfg(feature = "building")]
+pub use building::*;
+#[cfg(feature = "building-2")]
+pub use building_2::*;
+#[cfg(feature = "bus")]
+pub use bus::*;
+#[cfg(feature = "bus-front")]
+pub use bus_front::*;
+#[cfg(feature = "cable")]
+pub use cable::*;
+#[cfg(feature = "cable-car")]
+pub use cable_car::*;
+#[cfg(feature = "cake")]
+pub use cake::*;
+#[cfg(feature = "cake-slice")]
+pub use cake_slice::*;
+#[cfg(feature = "calculator")]
+pub use calculator::*;
+#[cfg(feature = "calendar")]
+pub use calendar::*;
+#[cfg(feature = "calendar-1")]
+pub use calendar_1::*;
+#[cfg(feature = "calendar-arrow-down")]
+pub use calendar_arrow_down::*;
+#[cfg(feature = "calendar-arrow-up")]
+pub use calendar_arrow_up::*;
+#[cfg(feature = "calendar-check")]
+pub use calendar_check::*;
+#[cfg(feature = "calendar-check-2")]
+pub use calendar_check_2::*;
+#[cfg(feature = "calendar-clock")]
+pub use calendar_clock::*;
+#[cfg(feature = "calendar-cog")]
+pub use calendar_cog::*;
+#[cfg(feature = "calendar-days")]
+pub use calendar_days::*;
+#[cfg(feature = "calendar-fold")]
+pub use calendar_fold::*;
+#[cfg(feature = "calendar-heart")]
+pub use calendar_heart::*;
+#[cfg(feature = "calendar-minus")]
+pub use calendar_minus::*;
+#[cfg(feature = "calendar-minus-2")]
+pub use calendar_minus_2::*;
+#[cfg(feature = "calendar-off")]
+pub use calendar_off::*;
+#[cfg(feature = "calendar-plus")]
+pub use calendar_plus::*;
+#[cfg(feature = "calendar-plus-2")]
+pub use calendar_plus_2::*;
+#[cfg(feature = "calendar-range")]
+pub use calendar_range::*;
+#[cfg(feature = "calendar-search")]
+pub use calendar_search::*;
+#[cfg(feature = "calendar-x")]
+pub use calendar_x::*;
+#[cfg(feature = "calendar-x-2")]
+pub use calendar_x_2::*;
+#[cfg(feature = "camera")]
+pub use camera::*;
+#[cfg(feature = "camera-off")]
+pub use camera_off::*;
+#[cfg(feature = "candy")]
+pub use candy::*;
+#[cfg(feature = "candy-cane")]
+pub use candy_cane::*;
+#[cfg(feature = "candy-off")]
+pub use candy_off::*;
+#[cfg(feature = "cannabis")]
+pub use cannabis::*;
+#[cfg(feature = "captions")]
+pub use captions::*;
+#[cfg(feature = "captions-off")]
+pub use captions_off::*;
+#[cfg(feature = "car")]
+pub use car::*;
+#[cfg(feature = "car-front")]
+pub use car_front::*;
+#[cfg(feature = "car-taxi-front")]
+pub use car_taxi_front::*;
+#[cfg(feature = "caravan")]
+pub use caravan::*;
+#[cfg(feature = "carrot")]
+pub use carrot::*;
+#[cfg(feature = "case-lower")]
+pub use case_lower::*;
+#[cfg(feature = "case-sensitive")]
+pub use case_sensitive::*;
+#[cfg(feature = "case-upper")]
+pub use case_upper::*;
+#[cfg(feature = "cassette-tape")]
+pub use cassette_tape::*;
+#[cfg(feature = "cast")]
+pub use cast::*;
+#[cfg(feature = "castle")]
+pub use castle::*;
+#[cfg(feature = "cat")]
+pub use cat::*;
+#[cfg(feature = "cctv")]
+pub use cctv::*;
+#[cfg(feature = "chart-area")]
+pub use chart_area::*;
+#[cfg(feature = "chart-bar")]
+pub use chart_bar::*;
+#[cfg(feature = "chart-bar-big")]
+pub use chart_bar_big::*;
+#[cfg(feature = "chart-bar-decreasing")]
+pub use chart_bar_decreasing::*;
+#[cfg(feature = "chart-bar-increasing")]
+pub use chart_bar_increasing::*;
+#[cfg(feature = "chart-bar-stacked")]
+pub use chart_bar_stacked::*;
+#[cfg(feature = "chart-candlestick")]
+pub use chart_candlestick::*;
+#[cfg(feature = "chart-column")]
+pub use chart_column::*;
+#[cfg(feature = "chart-column-big")]
+pub use chart_column_big::*;
+#[cfg(feature = "chart-column-decreasing")]
+pub use chart_column_decreasing::*;
+#[cfg(feature = "chart-column-increasing")]
+pub use chart_column_increasing::*;
+#[cfg(feature = "chart-column-stacked")]
+pub use chart_column_stacked::*;
+#[cfg(feature = "chart-gantt")]
+pub use chart_gantt::*;
+#[cfg(feature = "chart-line")]
+pub use chart_line::*;
+#[cfg(feature = "chart-network")]
+pub use chart_network::*;
+#[cfg(feature = "chart-no-axes-column")]
+pub use chart_no_axes_column::*;
+#[cfg(feature = "chart-no-axes-column-decreasing")]
+pub use chart_no_axes_column_decreasing::*;
+#[cfg(feature = "chart-no-axes-column-increasing")]
+pub use chart_no_axes_column_increasing::*;
+#[cfg(feature = "chart-no-axes-combined")]
+pub use chart_no_axes_combined::*;
+#[cfg(feature = "chart-no-axes-gantt")]
+pub use chart_no_axes_gantt::*;
+#[cfg(feature = "chart-pie")]
+pub use chart_pie::*;
+#[cfg(feature = "chart-scatter")]
+pub use chart_scatter::*;
+#[cfg(feature = "chart-spline")]
+pub use chart_spline::*;
+#[cfg(feature = "check")]
+pub use check::*;
+#[cfg(feature = "check-check")]
+pub use check_check::*;
+#[cfg(feature = "chef-hat")]
+pub use chef_hat::*;
+#[cfg(feature = "cherry")]
+pub use cherry::*;
+#[cfg(feature = "chevron-down")]
+pub use chevron_down::*;
+#[cfg(feature = "chevron-first")]
+pub use chevron_first::*;
+#[cfg(feature = "chevron-last")]
+pub use chevron_last::*;
+#[cfg(feature = "chevron-left")]
+pub use chevron_left::*;
+#[cfg(feature = "chevron-right")]
+pub use chevron_right::*;
+#[cfg(feature = "chevron-up")]
+pub use chevron_up::*;
+#[cfg(feature = "chevrons-down")]
+pub use chevrons_down::*;
+#[cfg(feature = "chevrons-down-up")]
+pub use chevrons_down_up::*;
+#[cfg(feature = "chevrons-left")]
+pub use chevrons_left::*;
+#[cfg(feature = "chevrons-left-right")]
+pub use chevrons_left_right::*;
+#[cfg(feature = "chevrons-left-right-ellipsis")]
+pub use chevrons_left_right_ellipsis::*;
+#[cfg(feature = "chevrons-right")]
+pub use chevrons_right::*;
+#[cfg(feature = "chevrons-right-left")]
+pub use chevrons_right_left::*;
+#[cfg(feature = "chevrons-up")]
+pub use chevrons_up::*;
+#[cfg(feature = "chevrons-up-down")]
+pub use chevrons_up_down::*;
+#[cfg(feature = "chrome")]
+pub use chrome::*;
+#[cfg(feature = "church")]
+pub use church::*;
+#[cfg(feature = "cigarette")]
+pub use cigarette::*;
+#[cfg(feature = "cigarette-off")]
+pub use cigarette_off::*;
+#[cfg(feature = "circle")]
+pub use circle::*;
+#[cfg(feature = "circle-alert")]
+pub use circle_alert::*;
+#[cfg(feature = "circle-arrow-down")]
+pub use circle_arrow_down::*;
+#[cfg(feature = "circle-arrow-left")]
+pub use circle_arrow_left::*;
+#[cfg(feature = "circle-arrow-out-down-left")]
+pub use circle_arrow_out_down_left::*;
+#[cfg(feature = "circle-arrow-out-down-right")]
+pub use circle_arrow_out_down_right::*;
+#[cfg(feature = "circle-arrow-out-up-left")]
+pub use circle_arrow_out_up_left::*;
+#[cfg(feature = "circle-arrow-out-up-right")]
+pub use circle_arrow_out_up_right::*;
+#[cfg(feature = "circle-arrow-right")]
+pub use circle_arrow_right::*;
+#[cfg(feature = "circle-arrow-up")]
+pub use circle_arrow_up::*;
+#[cfg(feature = "circle-check")]
+pub use circle_check::*;
+#[cfg(feature = "circle-check-big")]
+pub use circle_check_big::*;
+#[cfg(feature = "circle-chevron-down")]
+pub use circle_chevron_down::*;
+#[cfg(feature = "circle-chevron-left")]
+pub use circle_chevron_left::*;
+#[cfg(feature = "circle-chevron-right")]
+pub use circle_chevron_right::*;
+#[cfg(feature = "circle-chevron-up")]
+pub use circle_chevron_up::*;
+#[cfg(feature = "circle-dashed")]
+pub use circle_dashed::*;
+#[cfg(feature = "circle-divide")]
+pub use circle_divide::*;
+#[cfg(feature = "circle-dollar-sign")]
+pub use circle_dollar_sign::*;
+#[cfg(feature = "circle-dot")]
+pub use circle_dot::*;
+#[cfg(feature = "circle-dot-dashed")]
+pub use circle_dot_dashed::*;
+#[cfg(feature = "circle-ellipsis")]
+pub use circle_ellipsis::*;
+#[cfg(feature = "circle-equal")]
+pub use circle_equal::*;
+#[cfg(feature = "circle-fading-arrow-up")]
+pub use circle_fading_arrow_up::*;
+#[cfg(feature = "circle-fading-plus")]
+pub use circle_fading_plus::*;
+#[cfg(feature = "circle-gauge")]
+pub use circle_gauge::*;
+#[cfg(feature = "circle-help")]
+pub use circle_help::*;
+#[cfg(feature = "circle-minus")]
+pub use circle_minus::*;
+#[cfg(feature = "circle-off")]
+pub use circle_off::*;
+#[cfg(feature = "circle-parking")]
+pub use circle_parking::*;
+#[cfg(feature = "circle-parking-off")]
+pub use circle_parking_off::*;
+#[cfg(feature = "circle-pause")]
+pub use circle_pause::*;
+#[cfg(feature = "circle-percent")]
+pub use circle_percent::*;
+#[cfg(feature = "circle-play")]
+pub use circle_play::*;
+#[cfg(feature = "circle-plus")]
+pub use circle_plus::*;
+#[cfg(feature = "circle-power")]
+pub use circle_power::*;
+#[cfg(feature = "circle-slash")]
+pub use circle_slash::*;
+#[cfg(feature = "circle-slash-2")]
+pub use circle_slash_2::*;
+#[cfg(feature = "circle-stop")]
+pub use circle_stop::*;
+#[cfg(feature = "circle-user")]
+pub use circle_user::*;
+#[cfg(feature = "circle-user-round")]
+pub use circle_user_round::*;
+#[cfg(feature = "circle-x")]
+pub use circle_x::*;
+#[cfg(feature = "circuit-board")]
+pub use circuit_board::*;
+#[cfg(feature = "citrus")]
+pub use citrus::*;
+#[cfg(feature = "clapperboard")]
+pub use clapperboard::*;
+#[cfg(feature = "clipboard")]
+pub use clipboard::*;
+#[cfg(feature = "clipboard-check")]
+pub use clipboard_check::*;
+#[cfg(feature = "clipboard-copy")]
+pub use clipboard_copy::*;
+#[cfg(feature = "clipboard-list")]
+pub use clipboard_list::*;
+#[cfg(feature = "clipboard-minus")]
+pub use clipboard_minus::*;
+#[cfg(feature = "clipboard-paste")]
+pub use clipboard_paste::*;
+#[cfg(feature = "clipboard-pen")]
+pub use clipboard_pen::*;
+#[cfg(feature = "clipboard-pen-line")]
+pub use clipboard_pen_line::*;
+#[cfg(feature = "clipboard-plus")]
+pub use clipboard_plus::*;
+#[cfg(feature = "clipboard-type")]
+pub use clipboard_type::*;
+#[cfg(feature = "clipboard-x")]
+pub use clipboard_x::*;
+#[cfg(feature = "clock")]
+pub use clock::*;
+#[cfg(feature = "clock-1")]
+pub use clock_1::*;
+#[cfg(feature = "clock-10")]
+pub use clock_10::*;
+#[cfg(feature = "clock-11")]
+pub use clock_11::*;
+#[cfg(feature = "clock-12")]
+pub use clock_12::*;
+#[cfg(feature = "clock-2")]
+pub use clock_2::*;
+#[cfg(feature = "clock-3")]
+pub use clock_3::*;
+#[cfg(feature = "clock-4")]
+pub use clock_4::*;
+#[cfg(feature = "clock-5")]
+pub use clock_5::*;
+#[cfg(feature = "clock-6")]
+pub use clock_6::*;
+#[cfg(feature = "clock-7")]
+pub use clock_7::*;
+#[cfg(feature = "clock-8")]
+pub use clock_8::*;
+#[cfg(feature = "clock-9")]
+pub use clock_9::*;
+#[cfg(feature = "clock-alert")]
+pub use clock_alert::*;
+#[cfg(feature = "clock-arrow-down")]
+pub use clock_arrow_down::*;
+#[cfg(feature = "clock-arrow-up")]
+pub use clock_arrow_up::*;
+#[cfg(feature = "cloud")]
+pub use cloud::*;
+#[cfg(feature = "cloud-alert")]
+pub use cloud_alert::*;
+#[cfg(feature = "cloud-cog")]
+pub use cloud_cog::*;
+#[cfg(feature = "cloud-download")]
+pub use cloud_download::*;
+#[cfg(feature = "cloud-drizzle")]
+pub use cloud_drizzle::*;
+#[cfg(feature = "cloud-fog")]
+pub use cloud_fog::*;
+#[cfg(feature = "cloud-hail")]
+pub use cloud_hail::*;
+#[cfg(feature = "cloud-lightning")]
+pub use cloud_lightning::*;
+#[cfg(feature = "cloud-moon")]
+pub use cloud_moon::*;
+#[cfg(feature = "cloud-moon-rain")]
+pub use cloud_moon_rain::*;
+#[cfg(feature = "cloud-off")]
+pub use cloud_off::*;
+#[cfg(feature = "cloud-rain")]
+pub use cloud_rain::*;
+#[cfg(feature = "cloud-rain-wind")]
+pub use cloud_rain_wind::*;
+#[cfg(feature = "cloud-snow")]
+pub use cloud_snow::*;
+#[cfg(feature = "cloud-sun")]
+pub use cloud_sun::*;
+#[cfg(feature = "cloud-sun-rain")]
+pub use cloud_sun_rain::*;
+#[cfg(feature = "cloud-upload")]
+pub use cloud_upload::*;
+#[cfg(feature = "cloudy")]
+pub use cloudy::*;
+#[cfg(feature = "clover")]
+pub use clover::*;
+#[cfg(feature = "club")]
+pub use club::*;
+#[cfg(feature = "code")]
+pub use code::*;
+#[cfg(feature = "code-xml")]
+pub use code_xml::*;
+#[cfg(feature = "codepen")]
+pub use codepen::*;
+#[cfg(feature = "codesandbox")]
+pub use codesandbox::*;
+#[cfg(feature = "coffee")]
+pub use coffee::*;
+#[cfg(feature = "cog")]
+pub use cog::*;
+#[cfg(feature = "coins")]
+pub use coins::*;
+#[cfg(feature = "columns-2")]
+pub use columns_2::*;
+#[cfg(feature = "columns-3")]
+pub use columns_3::*;
+#[cfg(feature = "columns-4")]
+pub use columns_4::*;
+#[cfg(feature = "combine")]
+pub use combine::*;
+#[cfg(feature = "command")]
+pub use command::*;
+#[cfg(feature = "compass")]
+pub use compass::*;
+#[cfg(feature = "component")]
+pub use component::*;
+#[cfg(feature = "computer")]
+pub use computer::*;
+#[cfg(feature = "concierge-bell")]
+pub use concierge_bell::*;
+#[cfg(feature = "cone")]
+pub use cone::*;
+#[cfg(feature = "construction")]
+pub use construction::*;
+#[cfg(feature = "contact")]
+pub use contact::*;
+#[cfg(feature = "contact-round")]
+pub use contact_round::*;
+#[cfg(feature = "container")]
+pub use container::*;
+#[cfg(feature = "contrast")]
+pub use contrast::*;
+#[cfg(feature = "cookie")]
+pub use cookie::*;
+#[cfg(feature = "cooking-pot")]
+pub use cooking_pot::*;
+#[cfg(feature = "copy")]
+pub use copy::*;
+#[cfg(feature = "copy-check")]
+pub use copy_check::*;
+#[cfg(feature = "copy-minus")]
+pub use copy_minus::*;
+#[cfg(feature = "copy-plus")]
+pub use copy_plus::*;
+#[cfg(feature = "copy-slash")]
+pub use copy_slash::*;
+#[cfg(feature = "copy-x")]
+pub use copy_x::*;
+#[cfg(feature = "copyleft")]
+pub use copyleft::*;
+#[cfg(feature = "copyright")]
+pub use copyright::*;
+#[cfg(feature = "corner-down-left")]
+pub use corner_down_left::*;
+#[cfg(feature = "corner-down-right")]
+pub use corner_down_right::*;
+#[cfg(feature = "corner-left-down")]
+pub use corner_left_down::*;
+#[cfg(feature = "corner-left-up")]
+pub use corner_left_up::*;
+#[cfg(feature = "corner-right-down")]
+pub use corner_right_down::*;
+#[cfg(feature = "corner-right-up")]
+pub use corner_right_up::*;
+#[cfg(feature = "corner-up-left")]
+pub use corner_up_left::*;
+#[cfg(feature = "corner-up-right")]
+pub use corner_up_right::*;
+#[cfg(feature = "cpu")]
+pub use cpu::*;
+#[cfg(feature = "creative-commons")]
+pub use creative_commons::*;
+#[cfg(feature = "credit-card")]
+pub use credit_card::*;
+#[cfg(feature = "croissant")]
+pub use croissant::*;
+#[cfg(feature = "crop")]
+pub use crop::*;
+#[cfg(feature = "cross")]
+pub use cross::*;
+#[cfg(feature = "crosshair")]
+pub use crosshair::*;
+#[cfg(feature = "crown")]
+pub use crown::*;
+#[cfg(feature = "cuboid")]
+pub use cuboid::*;
+#[cfg(feature = "cup-soda")]
+pub use cup_soda::*;
+#[cfg(feature = "currency")]
+pub use currency::*;
+#[cfg(feature = "cylinder")]
+pub use cylinder::*;
+#[cfg(feature = "dam")]
+pub use dam::*;
+#[cfg(feature = "database")]
+pub use database::*;
+#[cfg(feature = "database-backup")]
+pub use database_backup::*;
+#[cfg(feature = "database-zap")]
+pub use database_zap::*;
+#[cfg(feature = "delete")]
+pub use delete::*;
+#[cfg(feature = "dessert")]
+pub use dessert::*;
+#[cfg(feature = "diameter")]
+pub use diameter::*;
+#[cfg(feature = "diamond")]
+pub use diamond::*;
+#[cfg(feature = "diamond-minus")]
+pub use diamond_minus::*;
+#[cfg(feature = "diamond-percent")]
+pub use diamond_percent::*;
+#[cfg(feature = "diamond-plus")]
+pub use diamond_plus::*;
+#[cfg(feature = "dice-1")]
+pub use dice_1::*;
+#[cfg(feature = "dice-2")]
+pub use dice_2::*;
+#[cfg(feature = "dice-3")]
+pub use dice_3::*;
+#[cfg(feature = "dice-4")]
+pub use dice_4::*;
+#[cfg(feature = "dice-5")]
+pub use dice_5::*;
+#[cfg(feature = "dice-6")]
+pub use dice_6::*;
+#[cfg(feature = "dices")]
+pub use dices::*;
+#[cfg(feature = "diff")]
+pub use diff::*;
+#[cfg(feature = "disc")]
+pub use disc::*;
+#[cfg(feature = "disc-2")]
+pub use disc_2::*;
+#[cfg(feature = "disc-3")]
+pub use disc_3::*;
+#[cfg(feature = "disc-album")]
+pub use disc_album::*;
+#[cfg(feature = "divide")]
+pub use divide::*;
+#[cfg(feature = "dna")]
+pub use dna::*;
+#[cfg(feature = "dna-off")]
+pub use dna_off::*;
+#[cfg(feature = "dock")]
+pub use dock::*;
+#[cfg(feature = "dog")]
+pub use dog::*;
+#[cfg(feature = "dollar-sign")]
+pub use dollar_sign::*;
+#[cfg(feature = "donut")]
+pub use donut::*;
+#[cfg(feature = "door-closed")]
+pub use door_closed::*;
+#[cfg(feature = "door-open")]
+pub use door_open::*;
+#[cfg(feature = "dot")]
+pub use dot::*;
+#[cfg(feature = "download")]
+pub use download::*;
+#[cfg(feature = "drafting-compass")]
+pub use drafting_compass::*;
+#[cfg(feature = "drama")]
+pub use drama::*;
+#[cfg(feature = "dribbble")]
+pub use dribbble::*;
+#[cfg(feature = "drill")]
+pub use drill::*;
+#[cfg(feature = "droplet")]
+pub use droplet::*;
+#[cfg(feature = "droplets")]
+pub use droplets::*;
+#[cfg(feature = "drum")]
+pub use drum::*;
+#[cfg(feature = "drumstick")]
+pub use drumstick::*;
+#[cfg(feature = "dumbbell")]
+pub use dumbbell::*;
+#[cfg(feature = "ear")]
+pub use ear::*;
+#[cfg(feature = "ear-off")]
+pub use ear_off::*;
+#[cfg(feature = "earth")]
+pub use earth::*;
+#[cfg(feature = "earth-lock")]
+pub use earth_lock::*;
+#[cfg(feature = "eclipse")]
+pub use eclipse::*;
+#[cfg(feature = "egg")]
+pub use egg::*;
+#[cfg(feature = "egg-fried")]
+pub use egg_fried::*;
+#[cfg(feature = "egg-off")]
+pub use egg_off::*;
+#[cfg(feature = "ellipsis")]
+pub use ellipsis::*;
+#[cfg(feature = "ellipsis-vertical")]
+pub use ellipsis_vertical::*;
+#[cfg(feature = "equal")]
+pub use equal::*;
+#[cfg(feature = "equal-approximately")]
+pub use equal_approximately::*;
+#[cfg(feature = "equal-not")]
+pub use equal_not::*;
+#[cfg(feature = "eraser")]
+pub use eraser::*;
+#[cfg(feature = "ethernet-port")]
+pub use ethernet_port::*;
+#[cfg(feature = "euro")]
+pub use euro::*;
+#[cfg(feature = "expand")]
+pub use expand::*;
+#[cfg(feature = "external-link")]
+pub use external_link::*;
+#[cfg(feature = "eye")]
+pub use eye::*;
+#[cfg(feature = "eye-closed")]
+pub use eye_closed::*;
+#[cfg(feature = "eye-off")]
+pub use eye_off::*;
+#[cfg(feature = "facebook")]
+pub use facebook::*;
+#[cfg(feature = "factory")]
+pub use factory::*;
+#[cfg(feature = "fan")]
+pub use fan::*;
+#[cfg(feature = "fast-forward")]
+pub use fast_forward::*;
+#[cfg(feature = "feather")]
+pub use feather::*;
+#[cfg(feature = "fence")]
+pub use fence::*;
+#[cfg(feature = "ferris-wheel")]
+pub use ferris_wheel::*;
+#[cfg(feature = "figma")]
+pub use figma::*;
+#[cfg(feature = "file")]
+pub use file::*;
+#[cfg(feature = "file-archive")]
+pub use file_archive::*;
+#[cfg(feature = "file-audio")]
+pub use file_audio::*;
+#[cfg(feature = "file-audio-2")]
+pub use file_audio_2::*;
+#[cfg(feature = "file-axis-3-d")]
+pub use file_axis_3_d::*;
+#[cfg(feature = "file-badge")]
+pub use file_badge::*;
+#[cfg(feature = "file-badge-2")]
+pub use file_badge_2::*;
+#[cfg(feature = "file-box")]
+pub use file_box::*;
+#[cfg(feature = "file-chart-column")]
+pub use file_chart_column::*;
+#[cfg(feature = "file-chart-column-increasing")]
+pub use file_chart_column_increasing::*;
+#[cfg(feature = "file-chart-line")]
+pub use file_chart_line::*;
+#[cfg(feature = "file-chart-pie")]
+pub use file_chart_pie::*;
+#[cfg(feature = "file-check")]
+pub use file_check::*;
+#[cfg(feature = "file-check-2")]
+pub use file_check_2::*;
+#[cfg(feature = "file-clock")]
+pub use file_clock::*;
+#[cfg(feature = "file-code")]
+pub use file_code::*;
+#[cfg(feature = "file-code-2")]
+pub use file_code_2::*;
+#[cfg(feature = "file-cog")]
+pub use file_cog::*;
+#[cfg(feature = "file-diff")]
+pub use file_diff::*;
+#[cfg(feature = "file-digit")]
+pub use file_digit::*;
+#[cfg(feature = "file-down")]
+pub use file_down::*;
+#[cfg(feature = "file-heart")]
+pub use file_heart::*;
+#[cfg(feature = "file-image")]
+pub use file_image::*;
+#[cfg(feature = "file-input")]
+pub use file_input::*;
+#[cfg(feature = "file-json")]
+pub use file_json::*;
+#[cfg(feature = "file-json-2")]
+pub use file_json_2::*;
+#[cfg(feature = "file-key")]
+pub use file_key::*;
+#[cfg(feature = "file-key-2")]
+pub use file_key_2::*;
+#[cfg(feature = "file-lock")]
+pub use file_lock::*;
+#[cfg(feature = "file-lock-2")]
+pub use file_lock_2::*;
+#[cfg(feature = "file-minus")]
+pub use file_minus::*;
+#[cfg(feature = "file-minus-2")]
+pub use file_minus_2::*;
+#[cfg(feature = "file-music")]
+pub use file_music::*;
+#[cfg(feature = "file-output")]
+pub use file_output::*;
+#[cfg(feature = "file-pen")]
+pub use file_pen::*;
+#[cfg(feature = "file-pen-line")]
+pub use file_pen_line::*;
+#[cfg(feature = "file-plus")]
+pub use file_plus::*;
+#[cfg(feature = "file-plus-2")]
+pub use file_plus_2::*;
+#[cfg(feature = "file-question")]
+pub use file_question::*;
+#[cfg(feature = "file-scan")]
+pub use file_scan::*;
+#[cfg(feature = "file-search")]
+pub use file_search::*;
+#[cfg(feature = "file-search-2")]
+pub use file_search_2::*;
+#[cfg(feature = "file-sliders")]
+pub use file_sliders::*;
+#[cfg(feature = "file-spreadsheet")]
+pub use file_spreadsheet::*;
+#[cfg(feature = "file-stack")]
+pub use file_stack::*;
+#[cfg(feature = "file-symlink")]
+pub use file_symlink::*;
+#[cfg(feature = "file-terminal")]
+pub use file_terminal::*;
+#[cfg(feature = "file-text")]
+pub use file_text::*;
+#[cfg(feature = "file-type")]
+pub use file_type::*;
+#[cfg(feature = "file-type-2")]
+pub use file_type_2::*;
+#[cfg(feature = "file-up")]
+pub use file_up::*;
+#[cfg(feature = "file-user")]
+pub use file_user::*;
+#[cfg(feature = "file-video")]
+pub use file_video::*;
+#[cfg(feature = "file-video-2")]
+pub use file_video_2::*;
+#[cfg(feature = "file-volume")]
+pub use file_volume::*;
+#[cfg(feature = "file-volume-2")]
+pub use file_volume_2::*;
+#[cfg(feature = "file-warning")]
+pub use file_warning::*;
+#[cfg(feature = "file-x")]
+pub use file_x::*;
+#[cfg(feature = "file-x-2")]
+pub use file_x_2::*;
+#[cfg(feature = "files")]
+pub use files::*;
+#[cfg(feature = "film")]
+pub use film::*;
+#[cfg(feature = "filter")]
+pub use filter::*;
+#[cfg(feature = "filter-x")]
+pub use filter_x::*;
+#[cfg(feature = "fingerprint")]
+pub use fingerprint::*;
+#[cfg(feature = "fire-extinguisher")]
+pub use fire_extinguisher::*;
+#[cfg(feature = "fish")]
+pub use fish::*;
+#[cfg(feature = "fish-off")]
+pub use fish_off::*;
+#[cfg(feature = "fish-symbol")]
+pub use fish_symbol::*;
+#[cfg(feature = "flag")]
+pub use flag::*;
+#[cfg(feature = "flag-off")]
+pub use flag_off::*;
+#[cfg(feature = "flag-triangle-left")]
+pub use flag_triangle_left::*;
+#[cfg(feature = "flag-triangle-right")]
+pub use flag_triangle_right::*;
+#[cfg(feature = "flame")]
+pub use flame::*;
+#[cfg(feature = "flame-kindling")]
+pub use flame_kindling::*;
+#[cfg(feature = "flashlight")]
+pub use flashlight::*;
+#[cfg(feature = "flashlight-off")]
+pub use flashlight_off::*;
+#[cfg(feature = "flask-conical")]
+pub use flask_conical::*;
+#[cfg(feature = "flask-conical-off")]
+pub use flask_conical_off::*;
+#[cfg(feature = "flask-round")]
+pub use flask_round::*;
+#[cfg(feature = "flip-horizontal")]
+pub use flip_horizontal::*;
+#[cfg(feature = "flip-horizontal-2")]
+pub use flip_horizontal_2::*;
+#[cfg(feature = "flip-vertical")]
+pub use flip_vertical::*;
+#[cfg(feature = "flip-vertical-2")]
+pub use flip_vertical_2::*;
+#[cfg(feature = "flower")]
+pub use flower::*;
+#[cfg(feature = "flower-2")]
+pub use flower_2::*;
+#[cfg(feature = "focus")]
+pub use focus::*;
+#[cfg(feature = "fold-horizontal")]
+pub use fold_horizontal::*;
+#[cfg(feature = "fold-vertical")]
+pub use fold_vertical::*;
+#[cfg(feature = "folder")]
+pub use folder::*;
+#[cfg(feature = "folder-archive")]
+pub use folder_archive::*;
+#[cfg(feature = "folder-check")]
+pub use folder_check::*;
+#[cfg(feature = "folder-clock")]
+pub use folder_clock::*;
+#[cfg(feature = "folder-closed")]
+pub use folder_closed::*;
+#[cfg(feature = "folder-code")]
+pub use folder_code::*;
+#[cfg(feature = "folder-cog")]
+pub use folder_cog::*;
+#[cfg(feature = "folder-dot")]
+pub use folder_dot::*;
+#[cfg(feature = "folder-down")]
+pub use folder_down::*;
+#[cfg(feature = "folder-git")]
+pub use folder_git::*;
+#[cfg(feature = "folder-git-2")]
+pub use folder_git_2::*;
+#[cfg(feature = "folder-heart")]
+pub use folder_heart::*;
+#[cfg(feature = "folder-input")]
+pub use folder_input::*;
+#[cfg(feature = "folder-kanban")]
+pub use folder_kanban::*;
+#[cfg(feature = "folder-key")]
+pub use folder_key::*;
+#[cfg(feature = "folder-lock")]
+pub use folder_lock::*;
+#[cfg(feature = "folder-minus")]
+pub use folder_minus::*;
+#[cfg(feature = "folder-open")]
+pub use folder_open::*;
+#[cfg(feature = "folder-open-dot")]
+pub use folder_open_dot::*;
+#[cfg(feature = "folder-output")]
+pub use folder_output::*;
+#[cfg(feature = "folder-pen")]
+pub use folder_pen::*;
+#[cfg(feature = "folder-plus")]
+pub use folder_plus::*;
+#[cfg(feature = "folder-root")]
+pub use folder_root::*;
+#[cfg(feature = "folder-search")]
+pub use folder_search::*;
+#[cfg(feature = "folder-search-2")]
+pub use folder_search_2::*;
+#[cfg(feature = "folder-symlink")]
+pub use folder_symlink::*;
+#[cfg(feature = "folder-sync")]
+pub use folder_sync::*;
+#[cfg(feature = "folder-tree")]
+pub use folder_tree::*;
+#[cfg(feature = "folder-up")]
+pub use folder_up::*;
+#[cfg(feature = "folder-x")]
+pub use folder_x::*;
+#[cfg(feature = "folders")]
+pub use folders::*;
+#[cfg(feature = "footprints")]
+pub use footprints::*;
+#[cfg(feature = "forklift")]
+pub use forklift::*;
+#[cfg(feature = "forward")]
+pub use forward::*;
+#[cfg(feature = "frame")]
+pub use frame::*;
+#[cfg(feature = "framer")]
+pub use framer::*;
+#[cfg(feature = "frown")]
+pub use frown::*;
+#[cfg(feature = "fuel")]
+pub use fuel::*;
+#[cfg(feature = "fullscreen")]
+pub use fullscreen::*;
+#[cfg(feature = "gallery-horizontal")]
+pub use gallery_horizontal::*;
+#[cfg(feature = "gallery-horizontal-end")]
+pub use gallery_horizontal_end::*;
+#[cfg(feature = "gallery-thumbnails")]
+pub use gallery_thumbnails::*;
+#[cfg(feature = "gallery-vertical")]
+pub use gallery_vertical::*;
+#[cfg(feature = "gallery-vertical-end")]
+pub use gallery_vertical_end::*;
+#[cfg(feature = "gamepad")]
+pub use gamepad::*;
+#[cfg(feature = "gamepad-2")]
+pub use gamepad_2::*;
+#[cfg(feature = "gauge")]
+pub use gauge::*;
+#[cfg(feature = "gavel")]
+pub use gavel::*;
+#[cfg(feature = "gem")]
+pub use gem::*;
+#[cfg(feature = "ghost")]
+pub use ghost::*;
+#[cfg(feature = "gift")]
+pub use gift::*;
+#[cfg(feature = "git-branch")]
+pub use git_branch::*;
+#[cfg(feature = "git-branch-plus")]
+pub use git_branch_plus::*;
+#[cfg(feature = "git-commit-horizontal")]
+pub use git_commit_horizontal::*;
+#[cfg(feature = "git-commit-vertical")]
+pub use git_commit_vertical::*;
+#[cfg(feature = "git-compare")]
+pub use git_compare::*;
+#[cfg(feature = "git-compare-arrows")]
+pub use git_compare_arrows::*;
+#[cfg(feature = "git-fork")]
+pub use git_fork::*;
+#[cfg(feature = "git-graph")]
+pub use git_graph::*;
+#[cfg(feature = "git-merge")]
+pub use git_merge::*;
+#[cfg(feature = "git-pull-request")]
+pub use git_pull_request::*;
+#[cfg(feature = "git-pull-request-arrow")]
+pub use git_pull_request_arrow::*;
+#[cfg(feature = "git-pull-request-closed")]
+pub use git_pull_request_closed::*;
+#[cfg(feature = "git-pull-request-create")]
+pub use git_pull_request_create::*;
+#[cfg(feature = "git-pull-request-create-arrow")]
+pub use git_pull_request_create_arrow::*;
+#[cfg(feature = "git-pull-request-draft")]
+pub use git_pull_request_draft::*;
+#[cfg(feature = "github")]
+pub use github::*;
+#[cfg(feature = "gitlab")]
+pub use gitlab::*;
+#[cfg(feature = "glass-water")]
+pub use glass_water::*;
+#[cfg(feature = "glasses")]
+pub use glasses::*;
+#[cfg(feature = "globe")]
+pub use globe::*;
+#[cfg(feature = "globe-lock")]
+pub use globe_lock::*;
+#[cfg(feature = "goal")]
+pub use goal::*;
+#[cfg(feature = "grab")]
+pub use grab::*;
+#[cfg(feature = "graduation-cap")]
+pub use graduation_cap::*;
+#[cfg(feature = "grape")]
+pub use grape::*;
+#[cfg(feature = "grid-2-x-2")]
+pub use grid_2_x_2::*;
+#[cfg(feature = "grid-2-x-2-check")]
+pub use grid_2_x_2_check::*;
+#[cfg(feature = "grid-2-x-2-plus")]
+pub use grid_2_x_2_plus::*;
+#[cfg(feature = "grid-2-x-2-x")]
+pub use grid_2_x_2_x::*;
+#[cfg(feature = "grid-3-x-3")]
+pub use grid_3_x_3::*;
+#[cfg(feature = "grip")]
+pub use grip::*;
+#[cfg(feature = "grip-horizontal")]
+pub use grip_horizontal::*;
+#[cfg(feature = "grip-vertical")]
+pub use grip_vertical::*;
+#[cfg(feature = "group")]
+pub use group::*;
+#[cfg(feature = "guitar")]
+pub use guitar::*;
+#[cfg(feature = "ham")]
+pub use ham::*;
+#[cfg(feature = "hammer")]
+pub use hammer::*;
+#[cfg(feature = "hand")]
+pub use hand::*;
+#[cfg(feature = "hand-coins")]
+pub use hand_coins::*;
+#[cfg(feature = "hand-heart")]
+pub use hand_heart::*;
+#[cfg(feature = "hand-helping")]
+pub use hand_helping::*;
+#[cfg(feature = "hand-metal")]
+pub use hand_metal::*;
+#[cfg(feature = "hand-platter")]
+pub use hand_platter::*;
+#[cfg(feature = "handshake")]
+pub use handshake::*;
+#[cfg(feature = "hard-drive")]
+pub use hard_drive::*;
+#[cfg(feature = "hard-drive-download")]
+pub use hard_drive_download::*;
+#[cfg(feature = "hard-drive-upload")]
+pub use hard_drive_upload::*;
+#[cfg(feature = "hard-hat")]
+pub use hard_hat::*;
+#[cfg(feature = "hash")]
+pub use hash::*;
+#[cfg(feature = "haze")]
+pub use haze::*;
+#[cfg(feature = "hdmi-port")]
+pub use hdmi_port::*;
+#[cfg(feature = "heading")]
+pub use heading::*;
+#[cfg(feature = "heading-1")]
+pub use heading_1::*;
+#[cfg(feature = "heading-2")]
+pub use heading_2::*;
+#[cfg(feature = "heading-3")]
+pub use heading_3::*;
+#[cfg(feature = "heading-4")]
+pub use heading_4::*;
+#[cfg(feature = "heading-5")]
+pub use heading_5::*;
+#[cfg(feature = "heading-6")]
+pub use heading_6::*;
+#[cfg(feature = "headphone-off")]
+pub use headphone_off::*;
+#[cfg(feature = "headphones")]
+pub use headphones::*;
+#[cfg(feature = "headset")]
+pub use headset::*;
+#[cfg(feature = "heart")]
+pub use heart::*;
+#[cfg(feature = "heart-crack")]
+pub use heart_crack::*;
+#[cfg(feature = "heart-handshake")]
+pub use heart_handshake::*;
+#[cfg(feature = "heart-off")]
+pub use heart_off::*;
+#[cfg(feature = "heart-pulse")]
+pub use heart_pulse::*;
+#[cfg(feature = "heater")]
+pub use heater::*;
+#[cfg(feature = "hexagon")]
+pub use hexagon::*;
+#[cfg(feature = "highlighter")]
+pub use highlighter::*;
+#[cfg(feature = "history")]
+pub use history::*;
+#[cfg(feature = "hop")]
+pub use hop::*;
+#[cfg(feature = "hop-off")]
+pub use hop_off::*;
+#[cfg(feature = "hospital")]
+pub use hospital::*;
+#[cfg(feature = "hotel")]
+pub use hotel::*;
+#[cfg(feature = "hourglass")]
+pub use hourglass::*;
+#[cfg(feature = "house")]
+pub use house::*;
+#[cfg(feature = "house-plug")]
+pub use house_plug::*;
+#[cfg(feature = "house-plus")]
+pub use house_plus::*;
+#[cfg(feature = "ice-cream-bowl")]
+pub use ice_cream_bowl::*;
+#[cfg(feature = "ice-cream-cone")]
+pub use ice_cream_cone::*;
+#[cfg(feature = "id-card")]
+pub use id_card::*;
+#[cfg(feature = "image")]
+pub use image::*;
+#[cfg(feature = "image-down")]
+pub use image_down::*;
+#[cfg(feature = "image-minus")]
+pub use image_minus::*;
+#[cfg(feature = "image-off")]
+pub use image_off::*;
+#[cfg(feature = "image-play")]
+pub use image_play::*;
+#[cfg(feature = "image-plus")]
+pub use image_plus::*;
+#[cfg(feature = "image-up")]
+pub use image_up::*;
+#[cfg(feature = "images")]
+pub use images::*;
+#[cfg(feature = "import")]
+pub use import::*;
+#[cfg(feature = "inbox")]
+pub use inbox::*;
+#[cfg(feature = "indent-decrease")]
+pub use indent_decrease::*;
+#[cfg(feature = "indent-increase")]
+pub use indent_increase::*;
+#[cfg(feature = "indian-rupee")]
+pub use indian_rupee::*;
+#[cfg(feature = "infinity")]
+pub use infinity::*;
+#[cfg(feature = "info")]
+pub use info::*;
+#[cfg(feature = "inspection-panel")]
+pub use inspection_panel::*;
+#[cfg(feature = "instagram")]
+pub use instagram::*;
+#[cfg(feature = "italic")]
+pub use italic::*;
+#[cfg(feature = "iteration-ccw")]
+pub use iteration_ccw::*;
+#[cfg(feature = "iteration-cw")]
+pub use iteration_cw::*;
+#[cfg(feature = "japanese-yen")]
+pub use japanese_yen::*;
+#[cfg(feature = "joystick")]
+pub use joystick::*;
+#[cfg(feature = "kanban")]
+pub use kanban::*;
+#[cfg(feature = "key")]
+pub use key::*;
+#[cfg(feature = "key-round")]
+pub use key_round::*;
+#[cfg(feature = "key-square")]
+pub use key_square::*;
+#[cfg(feature = "keyboard")]
+pub use keyboard::*;
+#[cfg(feature = "keyboard-music")]
+pub use keyboard_music::*;
+#[cfg(feature = "keyboard-off")]
+pub use keyboard_off::*;
+#[cfg(feature = "lamp")]
+pub use lamp::*;
+#[cfg(feature = "lamp-ceiling")]
+pub use lamp_ceiling::*;
+#[cfg(feature = "lamp-desk")]
+pub use lamp_desk::*;
+#[cfg(feature = "lamp-floor")]
+pub use lamp_floor::*;
+#[cfg(feature = "lamp-wall-down")]
+pub use lamp_wall_down::*;
+#[cfg(feature = "lamp-wall-up")]
+pub use lamp_wall_up::*;
+#[cfg(feature = "land-plot")]
+pub use land_plot::*;
+#[cfg(feature = "landmark")]
+pub use landmark::*;
+#[cfg(feature = "languages")]
+pub use languages::*;
+#[cfg(feature = "laptop")]
+pub use laptop::*;
+#[cfg(feature = "laptop-minimal")]
+pub use laptop_minimal::*;
+#[cfg(feature = "laptop-minimal-check")]
+pub use laptop_minimal_check::*;
+#[cfg(feature = "lasso")]
+pub use lasso::*;
+#[cfg(feature = "lasso-select")]
+pub use lasso_select::*;
+#[cfg(feature = "laugh")]
+pub use laugh::*;
+#[cfg(feature = "layers")]
+pub use layers::*;
+#[cfg(feature = "layers-2")]
+pub use layers_2::*;
+#[cfg(feature = "layers-3")]
+pub use layers_3::*;
+#[cfg(feature = "layout-dashboard")]
+pub use layout_dashboard::*;
+#[cfg(feature = "layout-grid")]
+pub use layout_grid::*;
+#[cfg(feature = "layout-list")]
+pub use layout_list::*;
+#[cfg(feature = "layout-panel-left")]
+pub use layout_panel_left::*;
+#[cfg(feature = "layout-panel-top")]
+pub use layout_panel_top::*;
+#[cfg(feature = "layout-template")]
+pub use layout_template::*;
+#[cfg(feature = "leaf")]
+pub use leaf::*;
+#[cfg(feature = "leafy-green")]
+pub use leafy_green::*;
+#[cfg(feature = "lectern")]
+pub use lectern::*;
+#[cfg(feature = "letter-text")]
+pub use letter_text::*;
+#[cfg(feature = "library")]
+pub use library::*;
+#[cfg(feature = "library-big")]
+pub use library_big::*;
+#[cfg(feature = "life-buoy")]
+pub use life_buoy::*;
+#[cfg(feature = "ligature")]
+pub use ligature::*;
+#[cfg(feature = "lightbulb")]
+pub use lightbulb::*;
+#[cfg(feature = "lightbulb-off")]
+pub use lightbulb_off::*;
+#[cfg(feature = "link")]
+pub use link::*;
+#[cfg(feature = "link-2")]
+pub use link_2::*;
+#[cfg(feature = "link-2-off")]
+pub use link_2_off::*;
+#[cfg(feature = "linkedin")]
+pub use linkedin::*;
+#[cfg(feature = "list")]
+pub use list::*;
+#[cfg(feature = "list-check")]
+pub use list_check::*;
+#[cfg(feature = "list-checks")]
+pub use list_checks::*;
+#[cfg(feature = "list-collapse")]
+pub use list_collapse::*;
+#[cfg(feature = "list-end")]
+pub use list_end::*;
+#[cfg(feature = "list-filter")]
+pub use list_filter::*;
+#[cfg(feature = "list-minus")]
+pub use list_minus::*;
+#[cfg(feature = "list-music")]
+pub use list_music::*;
+#[cfg(feature = "list-ordered")]
+pub use list_ordered::*;
+#[cfg(feature = "list-plus")]
+pub use list_plus::*;
+#[cfg(feature = "list-restart")]
+pub use list_restart::*;
+#[cfg(feature = "list-start")]
+pub use list_start::*;
+#[cfg(feature = "list-todo")]
+pub use list_todo::*;
+#[cfg(feature = "list-tree")]
+pub use list_tree::*;
+#[cfg(feature = "list-video")]
+pub use list_video::*;
+#[cfg(feature = "list-x")]
+pub use list_x::*;
+#[cfg(feature = "loader")]
+pub use loader::*;
+#[cfg(feature = "loader-circle")]
+pub use loader_circle::*;
+#[cfg(feature = "loader-pinwheel")]
+pub use loader_pinwheel::*;
+#[cfg(feature = "locate")]
+pub use locate::*;
+#[cfg(feature = "locate-fixed")]
+pub use locate_fixed::*;
+#[cfg(feature = "locate-off")]
+pub use locate_off::*;
+#[cfg(feature = "lock")]
+pub use lock::*;
+#[cfg(feature = "lock-keyhole")]
+pub use lock_keyhole::*;
+#[cfg(feature = "lock-keyhole-open")]
+pub use lock_keyhole_open::*;
+#[cfg(feature = "lock-open")]
+pub use lock_open::*;
+#[cfg(feature = "log-in")]
+pub use log_in::*;
+#[cfg(feature = "log-out")]
+pub use log_out::*;
+#[cfg(feature = "logs")]
+pub use logs::*;
+#[cfg(feature = "lollipop")]
+pub use lollipop::*;
+#[cfg(feature = "luggage")]
+pub use luggage::*;
+#[cfg(feature = "magnet")]
+pub use magnet::*;
+#[cfg(feature = "mail")]
+pub use mail::*;
+#[cfg(feature = "mail-check")]
+pub use mail_check::*;
+#[cfg(feature = "mail-minus")]
+pub use mail_minus::*;
+#[cfg(feature = "mail-open")]
+pub use mail_open::*;
+#[cfg(feature = "mail-plus")]
+pub use mail_plus::*;
+#[cfg(feature = "mail-question")]
+pub use mail_question::*;
+#[cfg(feature = "mail-search")]
+pub use mail_search::*;
+#[cfg(feature = "mail-warning")]
+pub use mail_warning::*;
+#[cfg(feature = "mail-x")]
+pub use mail_x::*;
+#[cfg(feature = "mailbox")]
+pub use mailbox::*;
+#[cfg(feature = "mails")]
+pub use mails::*;
+#[cfg(feature = "map")]
+pub use map::*;
+#[cfg(feature = "map-pin")]
+pub use map_pin::*;
+#[cfg(feature = "map-pin-check")]
+pub use map_pin_check::*;
+#[cfg(feature = "map-pin-check-inside")]
+pub use map_pin_check_inside::*;
+#[cfg(feature = "map-pin-house")]
+pub use map_pin_house::*;
+#[cfg(feature = "map-pin-minus")]
+pub use map_pin_minus::*;
+#[cfg(feature = "map-pin-minus-inside")]
+pub use map_pin_minus_inside::*;
+#[cfg(feature = "map-pin-off")]
+pub use map_pin_off::*;
+#[cfg(feature = "map-pin-plus")]
+pub use map_pin_plus::*;
+#[cfg(feature = "map-pin-plus-inside")]
+pub use map_pin_plus_inside::*;
+#[cfg(feature = "map-pin-x")]
+pub use map_pin_x::*;
+#[cfg(feature = "map-pin-x-inside")]
+pub use map_pin_x_inside::*;
+#[cfg(feature = "map-pinned")]
+pub use map_pinned::*;
+#[cfg(feature = "martini")]
+pub use martini::*;
+#[cfg(feature = "maximize")]
+pub use maximize::*;
+#[cfg(feature = "maximize-2")]
+pub use maximize_2::*;
+#[cfg(feature = "medal")]
+pub use medal::*;
+#[cfg(feature = "megaphone")]
+pub use megaphone::*;
+#[cfg(feature = "megaphone-off")]
+pub use megaphone_off::*;
+#[cfg(feature = "meh")]
+pub use meh::*;
+#[cfg(feature = "memory-stick")]
+pub use memory_stick::*;
+#[cfg(feature = "menu")]
+pub use menu::*;
+#[cfg(feature = "merge")]
+pub use merge::*;
+#[cfg(feature = "message-circle")]
+pub use message_circle::*;
+#[cfg(feature = "message-circle-code")]
+pub use message_circle_code::*;
+#[cfg(feature = "message-circle-dashed")]
+pub use message_circle_dashed::*;
+#[cfg(feature = "message-circle-heart")]
+pub use message_circle_heart::*;
+#[cfg(feature = "message-circle-more")]
+pub use message_circle_more::*;
+#[cfg(feature = "message-circle-off")]
+pub use message_circle_off::*;
+#[cfg(feature = "message-circle-plus")]
+pub use message_circle_plus::*;
+#[cfg(feature = "message-circle-question")]
+pub use message_circle_question::*;
+#[cfg(feature = "message-circle-reply")]
+pub use message_circle_reply::*;
+#[cfg(feature = "message-circle-warning")]
+pub use message_circle_warning::*;
+#[cfg(feature = "message-circle-x")]
+pub use message_circle_x::*;
+#[cfg(feature = "message-square")]
+pub use message_square::*;
+#[cfg(feature = "message-square-code")]
+pub use message_square_code::*;
+#[cfg(feature = "message-square-dashed")]
+pub use message_square_dashed::*;
+#[cfg(feature = "message-square-diff")]
+pub use message_square_diff::*;
+#[cfg(feature = "message-square-dot")]
+pub use message_square_dot::*;
+#[cfg(feature = "message-square-heart")]
+pub use message_square_heart::*;
+#[cfg(feature = "message-square-lock")]
+pub use message_square_lock::*;
+#[cfg(feature = "message-square-more")]
+pub use message_square_more::*;
+#[cfg(feature = "message-square-off")]
+pub use message_square_off::*;
+#[cfg(feature = "message-square-plus")]
+pub use message_square_plus::*;
+#[cfg(feature = "message-square-quote")]
+pub use message_square_quote::*;
+#[cfg(feature = "message-square-reply")]
+pub use message_square_reply::*;
+#[cfg(feature = "message-square-share")]
+pub use message_square_share::*;
+#[cfg(feature = "message-square-text")]
+pub use message_square_text::*;
+#[cfg(feature = "message-square-warning")]
+pub use message_square_warning::*;
+#[cfg(feature = "message-square-x")]
+pub use message_square_x::*;
+#[cfg(feature = "messages-square")]
+pub use messages_square::*;
+#[cfg(feature = "mic")]
+pub use mic::*;
+#[cfg(feature = "mic-off")]
+pub use mic_off::*;
+#[cfg(feature = "mic-vocal")]
+pub use mic_vocal::*;
+#[cfg(feature = "microchip")]
+pub use microchip::*;
+#[cfg(feature = "microscope")]
+pub use microscope::*;
+#[cfg(feature = "microwave")]
+pub use microwave::*;
+#[cfg(feature = "milestone")]
+pub use milestone::*;
+#[cfg(feature = "milk")]
+pub use milk::*;
+#[cfg(feature = "milk-off")]
+pub use milk_off::*;
+#[cfg(feature = "minimize")]
+pub use minimize::*;
+#[cfg(feature = "minimize-2")]
+pub use minimize_2::*;
+#[cfg(feature = "minus")]
+pub use minus::*;
+#[cfg(feature = "monitor")]
+pub use monitor::*;
+#[cfg(feature = "monitor-check")]
+pub use monitor_check::*;
+#[cfg(feature = "monitor-cog")]
+pub use monitor_cog::*;
+#[cfg(feature = "monitor-dot")]
+pub use monitor_dot::*;
+#[cfg(feature = "monitor-down")]
+pub use monitor_down::*;
+#[cfg(feature = "monitor-off")]
+pub use monitor_off::*;
+#[cfg(feature = "monitor-pause")]
+pub use monitor_pause::*;
+#[cfg(feature = "monitor-play")]
+pub use monitor_play::*;
+#[cfg(feature = "monitor-smartphone")]
+pub use monitor_smartphone::*;
+#[cfg(feature = "monitor-speaker")]
+pub use monitor_speaker::*;
+#[cfg(feature = "monitor-stop")]
+pub use monitor_stop::*;
+#[cfg(feature = "monitor-up")]
+pub use monitor_up::*;
+#[cfg(feature = "monitor-x")]
+pub use monitor_x::*;
+#[cfg(feature = "moon")]
+pub use moon::*;
+#[cfg(feature = "moon-star")]
+pub use moon_star::*;
+#[cfg(feature = "mountain")]
+pub use mountain::*;
+#[cfg(feature = "mountain-snow")]
+pub use mountain_snow::*;
+#[cfg(feature = "mouse")]
+pub use mouse::*;
+#[cfg(feature = "mouse-off")]
+pub use mouse_off::*;
+#[cfg(feature = "mouse-pointer")]
+pub use mouse_pointer::*;
+#[cfg(feature = "mouse-pointer-2")]
+pub use mouse_pointer_2::*;
+#[cfg(feature = "mouse-pointer-ban")]
+pub use mouse_pointer_ban::*;
+#[cfg(feature = "mouse-pointer-click")]
+pub use mouse_pointer_click::*;
+#[cfg(feature = "move-3-d")]
+pub use move_3_d::*;
+#[cfg(feature = "move-diagonal")]
+pub use move_diagonal::*;
+#[cfg(feature = "move-diagonal-2")]
+pub use move_diagonal_2::*;
+#[cfg(feature = "move-down")]
+pub use move_down::*;
+#[cfg(feature = "move-down-left")]
+pub use move_down_left::*;
+#[cfg(feature = "move-down-right")]
+pub use move_down_right::*;
+#[cfg(feature = "move-horizontal")]
+pub use move_horizontal::*;
+#[cfg(feature = "move-left")]
+pub use move_left::*;
+#[cfg(feature = "move-right")]
+pub use move_right::*;
+#[cfg(feature = "move-up")]
+pub use move_up::*;
+#[cfg(feature = "move-up-left")]
+pub use move_up_left::*;
+#[cfg(feature = "move-up-right")]
+pub use move_up_right::*;
+#[cfg(feature = "move-vertical")]
+pub use move_vertical::*;
+#[cfg(feature = "music")]
+pub use music::*;
+#[cfg(feature = "music-2")]
+pub use music_2::*;
+#[cfg(feature = "music-3")]
+pub use music_3::*;
+#[cfg(feature = "music-4")]
+pub use music_4::*;
+#[cfg(feature = "navigation")]
+pub use navigation::*;
+#[cfg(feature = "navigation-2")]
+pub use navigation_2::*;
+#[cfg(feature = "navigation-2-off")]
+pub use navigation_2_off::*;
+#[cfg(feature = "navigation-off")]
+pub use navigation_off::*;
+#[cfg(feature = "network")]
+pub use network::*;
+#[cfg(feature = "newspaper")]
+pub use newspaper::*;
+#[cfg(feature = "nfc")]
+pub use nfc::*;
+#[cfg(feature = "notebook")]
+pub use notebook::*;
+#[cfg(feature = "notebook-pen")]
+pub use notebook_pen::*;
+#[cfg(feature = "notebook-tabs")]
+pub use notebook_tabs::*;
+#[cfg(feature = "notebook-text")]
+pub use notebook_text::*;
+#[cfg(feature = "notepad-text")]
+pub use notepad_text::*;
+#[cfg(feature = "notepad-text-dashed")]
+pub use notepad_text_dashed::*;
+#[cfg(feature = "nut")]
+pub use nut::*;
+#[cfg(feature = "nut-off")]
+pub use nut_off::*;
+#[cfg(feature = "octagon")]
+pub use octagon::*;
+#[cfg(feature = "octagon-alert")]
+pub use octagon_alert::*;
+#[cfg(feature = "octagon-minus")]
+pub use octagon_minus::*;
+#[cfg(feature = "octagon-pause")]
+pub use octagon_pause::*;
+#[cfg(feature = "octagon-x")]
+pub use octagon_x::*;
+#[cfg(feature = "omega")]
+pub use omega::*;
+#[cfg(feature = "option")]
+pub use option::*;
+#[cfg(feature = "orbit")]
+pub use orbit::*;
+#[cfg(feature = "origami")]
+pub use origami::*;
+#[cfg(feature = "package")]
+pub use package::*;
+#[cfg(feature = "package-2")]
+pub use package_2::*;
+#[cfg(feature = "package-check")]
+pub use package_check::*;
+#[cfg(feature = "package-minus")]
+pub use package_minus::*;
+#[cfg(feature = "package-open")]
+pub use package_open::*;
+#[cfg(feature = "package-plus")]
+pub use package_plus::*;
+#[cfg(feature = "package-search")]
+pub use package_search::*;
+#[cfg(feature = "package-x")]
+pub use package_x::*;
+#[cfg(feature = "paint-bucket")]
+pub use paint_bucket::*;
+#[cfg(feature = "paint-roller")]
+pub use paint_roller::*;
+#[cfg(feature = "paintbrush")]
+pub use paintbrush::*;
+#[cfg(feature = "paintbrush-vertical")]
+pub use paintbrush_vertical::*;
+#[cfg(feature = "palette")]
+pub use palette::*;
+#[cfg(feature = "panel-bottom")]
+pub use panel_bottom::*;
+#[cfg(feature = "panel-bottom-close")]
+pub use panel_bottom_close::*;
+#[cfg(feature = "panel-bottom-dashed")]
+pub use panel_bottom_dashed::*;
+#[cfg(feature = "panel-bottom-open")]
+pub use panel_bottom_open::*;
+#[cfg(feature = "panel-left")]
+pub use panel_left::*;
+#[cfg(feature = "panel-left-close")]
+pub use panel_left_close::*;
+#[cfg(feature = "panel-left-dashed")]
+pub use panel_left_dashed::*;
+#[cfg(feature = "panel-left-open")]
+pub use panel_left_open::*;
+#[cfg(feature = "panel-right")]
+pub use panel_right::*;
+#[cfg(feature = "panel-right-close")]
+pub use panel_right_close::*;
+#[cfg(feature = "panel-right-dashed")]
+pub use panel_right_dashed::*;
+#[cfg(feature = "panel-right-open")]
+pub use panel_right_open::*;
+#[cfg(feature = "panel-top")]
+pub use panel_top::*;
+#[cfg(feature = "panel-top-close")]
+pub use panel_top_close::*;
+#[cfg(feature = "panel-top-dashed")]
+pub use panel_top_dashed::*;
+#[cfg(feature = "panel-top-open")]
+pub use panel_top_open::*;
+#[cfg(feature = "panels-left-bottom")]
+pub use panels_left_bottom::*;
+#[cfg(feature = "panels-right-bottom")]
+pub use panels_right_bottom::*;
+#[cfg(feature = "panels-top-left")]
+pub use panels_top_left::*;
+#[cfg(feature = "paperclip")]
+pub use paperclip::*;
+#[cfg(feature = "parentheses")]
+pub use parentheses::*;
+#[cfg(feature = "parking-meter")]
+pub use parking_meter::*;
+#[cfg(feature = "party-popper")]
+pub use party_popper::*;
+#[cfg(feature = "pause")]
+pub use pause::*;
+#[cfg(feature = "paw-print")]
+pub use paw_print::*;
+#[cfg(feature = "pc-case")]
+pub use pc_case::*;
+#[cfg(feature = "pen")]
+pub use pen::*;
+#[cfg(feature = "pen-line")]
+pub use pen_line::*;
+#[cfg(feature = "pen-off")]
+pub use pen_off::*;
+#[cfg(feature = "pen-tool")]
+pub use pen_tool::*;
+#[cfg(feature = "pencil")]
+pub use pencil::*;
+#[cfg(feature = "pencil-line")]
+pub use pencil_line::*;
+#[cfg(feature = "pencil-off")]
+pub use pencil_off::*;
+#[cfg(feature = "pencil-ruler")]
+pub use pencil_ruler::*;
+#[cfg(feature = "pentagon")]
+pub use pentagon::*;
+#[cfg(feature = "percent")]
+pub use percent::*;
+#[cfg(feature = "person-standing")]
+pub use person_standing::*;
+#[cfg(feature = "philippine-peso")]
+pub use philippine_peso::*;
+#[cfg(feature = "phone")]
+pub use phone::*;
+#[cfg(feature = "phone-call")]
+pub use phone_call::*;
+#[cfg(feature = "phone-forwarded")]
+pub use phone_forwarded::*;
+#[cfg(feature = "phone-incoming")]
+pub use phone_incoming::*;
+#[cfg(feature = "phone-missed")]
+pub use phone_missed::*;
+#[cfg(feature = "phone-off")]
+pub use phone_off::*;
+#[cfg(feature = "phone-outgoing")]
+pub use phone_outgoing::*;
+#[cfg(feature = "pi")]
+pub use pi::*;
+#[cfg(feature = "piano")]
+pub use piano::*;
+#[cfg(feature = "pickaxe")]
+pub use pickaxe::*;
+#[cfg(feature = "picture-in-picture")]
+pub use picture_in_picture::*;
+#[cfg(feature = "picture-in-picture-2")]
+pub use picture_in_picture_2::*;
+#[cfg(feature = "piggy-bank")]
+pub use piggy_bank::*;
+#[cfg(feature = "pilcrow")]
+pub use pilcrow::*;
+#[cfg(feature = "pilcrow-left")]
+pub use pilcrow_left::*;
+#[cfg(feature = "pilcrow-right")]
+pub use pilcrow_right::*;
+#[cfg(feature = "pill")]
+pub use pill::*;
+#[cfg(feature = "pill-bottle")]
+pub use pill_bottle::*;
+#[cfg(feature = "pin")]
+pub use pin::*;
+#[cfg(feature = "pin-off")]
+pub use pin_off::*;
+#[cfg(feature = "pipette")]
+pub use pipette::*;
+#[cfg(feature = "pizza")]
+pub use pizza::*;
+#[cfg(feature = "plane")]
+pub use plane::*;
+#[cfg(feature = "plane-landing")]
+pub use plane_landing::*;
+#[cfg(feature = "plane-takeoff")]
+pub use plane_takeoff::*;
+#[cfg(feature = "play")]
+pub use play::*;
+#[cfg(feature = "plug")]
+pub use plug::*;
+#[cfg(feature = "plug-2")]
+pub use plug_2::*;
+#[cfg(feature = "plug-zap")]
+pub use plug_zap::*;
+#[cfg(feature = "plus")]
+pub use plus::*;
+#[cfg(feature = "pocket")]
+pub use pocket::*;
+#[cfg(feature = "pocket-knife")]
+pub use pocket_knife::*;
+#[cfg(feature = "podcast")]
+pub use podcast::*;
+#[cfg(feature = "pointer")]
+pub use pointer::*;
+#[cfg(feature = "pointer-off")]
+pub use pointer_off::*;
+#[cfg(feature = "popcorn")]
+pub use popcorn::*;
+#[cfg(feature = "popsicle")]
+pub use popsicle::*;
+#[cfg(feature = "pound-sterling")]
+pub use pound_sterling::*;
+#[cfg(feature = "power")]
+pub use power::*;
+#[cfg(feature = "power-off")]
+pub use power_off::*;
+#[cfg(feature = "presentation")]
+pub use presentation::*;
+#[cfg(feature = "printer")]
+pub use printer::*;
+#[cfg(feature = "printer-check")]
+pub use printer_check::*;
+#[cfg(feature = "projector")]
+pub use projector::*;
+#[cfg(feature = "proportions")]
+pub use proportions::*;
+#[cfg(feature = "puzzle")]
+pub use puzzle::*;
+#[cfg(feature = "pyramid")]
+pub use pyramid::*;
+#[cfg(feature = "qr-code")]
+pub use qr_code::*;
+#[cfg(feature = "quote")]
+pub use quote::*;
+#[cfg(feature = "box")]
+pub use r#box::*;
+#[cfg(feature = "move")]
+pub use r#move::*;
+#[cfg(feature = "type")]
+pub use r#type::*;
+#[cfg(feature = "rabbit")]
+pub use rabbit::*;
+#[cfg(feature = "radar")]
+pub use radar::*;
+#[cfg(feature = "radiation")]
+pub use radiation::*;
+#[cfg(feature = "radical")]
+pub use radical::*;
+#[cfg(feature = "radio")]
+pub use radio::*;
+#[cfg(feature = "radio-receiver")]
+pub use radio_receiver::*;
+#[cfg(feature = "radio-tower")]
+pub use radio_tower::*;
+#[cfg(feature = "radius")]
+pub use radius::*;
+#[cfg(feature = "rail-symbol")]
+pub use rail_symbol::*;
+#[cfg(feature = "rainbow")]
+pub use rainbow::*;
+#[cfg(feature = "rat")]
+pub use rat::*;
+#[cfg(feature = "ratio")]
+pub use ratio::*;
+#[cfg(feature = "receipt")]
+pub use receipt::*;
+#[cfg(feature = "receipt-cent")]
+pub use receipt_cent::*;
+#[cfg(feature = "receipt-euro")]
+pub use receipt_euro::*;
+#[cfg(feature = "receipt-indian-rupee")]
+pub use receipt_indian_rupee::*;
+#[cfg(feature = "receipt-japanese-yen")]
+pub use receipt_japanese_yen::*;
+#[cfg(feature = "receipt-pound-sterling")]
+pub use receipt_pound_sterling::*;
+#[cfg(feature = "receipt-russian-ruble")]
+pub use receipt_russian_ruble::*;
+#[cfg(feature = "receipt-swiss-franc")]
+pub use receipt_swiss_franc::*;
+#[cfg(feature = "receipt-text")]
+pub use receipt_text::*;
+#[cfg(feature = "rectangle-ellipsis")]
+pub use rectangle_ellipsis::*;
+#[cfg(feature = "rectangle-horizontal")]
+pub use rectangle_horizontal::*;
+#[cfg(feature = "rectangle-vertical")]
+pub use rectangle_vertical::*;
+#[cfg(feature = "recycle")]
+pub use recycle::*;
+#[cfg(feature = "redo")]
+pub use redo::*;
+#[cfg(feature = "redo-2")]
+pub use redo_2::*;
+#[cfg(feature = "redo-dot")]
+pub use redo_dot::*;
+#[cfg(feature = "refresh-ccw")]
+pub use refresh_ccw::*;
+#[cfg(feature = "refresh-ccw-dot")]
+pub use refresh_ccw_dot::*;
+#[cfg(feature = "refresh-cw")]
+pub use refresh_cw::*;
+#[cfg(feature = "refresh-cw-off")]
+pub use refresh_cw_off::*;
+#[cfg(feature = "refrigerator")]
+pub use refrigerator::*;
+#[cfg(feature = "regex")]
+pub use regex::*;
+#[cfg(feature = "remove-formatting")]
+pub use remove_formatting::*;
+#[cfg(feature = "repeat")]
+pub use repeat::*;
+#[cfg(feature = "repeat-1")]
+pub use repeat_1::*;
+#[cfg(feature = "repeat-2")]
+pub use repeat_2::*;
+#[cfg(feature = "replace")]
+pub use replace::*;
+#[cfg(feature = "replace-all")]
+pub use replace_all::*;
+#[cfg(feature = "reply")]
+pub use reply::*;
+#[cfg(feature = "reply-all")]
+pub use reply_all::*;
+#[cfg(feature = "rewind")]
+pub use rewind::*;
+#[cfg(feature = "ribbon")]
+pub use ribbon::*;
+#[cfg(feature = "rocket")]
+pub use rocket::*;
+#[cfg(feature = "rocking-chair")]
+pub use rocking_chair::*;
+#[cfg(feature = "roller-coaster")]
+pub use roller_coaster::*;
+#[cfg(feature = "rotate-3-d")]
+pub use rotate_3_d::*;
+#[cfg(feature = "rotate-ccw")]
+pub use rotate_ccw::*;
+#[cfg(feature = "rotate-ccw-square")]
+pub use rotate_ccw_square::*;
+#[cfg(feature = "rotate-cw")]
+pub use rotate_cw::*;
+#[cfg(feature = "rotate-cw-square")]
+pub use rotate_cw_square::*;
+#[cfg(feature = "route")]
+pub use route::*;
+#[cfg(feature = "route-off")]
+pub use route_off::*;
+#[cfg(feature = "router")]
+pub use router::*;
+#[cfg(feature = "rows-2")]
+pub use rows_2::*;
+#[cfg(feature = "rows-3")]
+pub use rows_3::*;
+#[cfg(feature = "rows-4")]
+pub use rows_4::*;
+#[cfg(feature = "rss")]
+pub use rss::*;
+#[cfg(feature = "ruler")]
+pub use ruler::*;
+#[cfg(feature = "russian-ruble")]
+pub use russian_ruble::*;
+#[cfg(feature = "sailboat")]
+pub use sailboat::*;
+#[cfg(feature = "salad")]
+pub use salad::*;
+#[cfg(feature = "sandwich")]
+pub use sandwich::*;
+#[cfg(feature = "satellite")]
+pub use satellite::*;
+#[cfg(feature = "satellite-dish")]
+pub use satellite_dish::*;
+#[cfg(feature = "save")]
+pub use save::*;
+#[cfg(feature = "save-all")]
+pub use save_all::*;
+#[cfg(feature = "save-off")]
+pub use save_off::*;
+#[cfg(feature = "scale")]
+pub use scale::*;
+#[cfg(feature = "scale-3-d")]
+pub use scale_3_d::*;
+#[cfg(feature = "scaling")]
+pub use scaling::*;
+#[cfg(feature = "scan")]
+pub use scan::*;
+#[cfg(feature = "scan-barcode")]
+pub use scan_barcode::*;
+#[cfg(feature = "scan-eye")]
+pub use scan_eye::*;
+#[cfg(feature = "scan-face")]
+pub use scan_face::*;
+#[cfg(feature = "scan-line")]
+pub use scan_line::*;
+#[cfg(feature = "scan-qr-code")]
+pub use scan_qr_code::*;
+#[cfg(feature = "scan-search")]
+pub use scan_search::*;
+#[cfg(feature = "scan-text")]
+pub use scan_text::*;
+#[cfg(feature = "school")]
+pub use school::*;
+#[cfg(feature = "scissors")]
+pub use scissors::*;
+#[cfg(feature = "scissors-line-dashed")]
+pub use scissors_line_dashed::*;
+#[cfg(feature = "screen-share")]
+pub use screen_share::*;
+#[cfg(feature = "screen-share-off")]
+pub use screen_share_off::*;
+#[cfg(feature = "scroll")]
+pub use scroll::*;
+#[cfg(feature = "scroll-text")]
+pub use scroll_text::*;
+#[cfg(feature = "search")]
+pub use search::*;
+#[cfg(feature = "search-check")]
+pub use search_check::*;
+#[cfg(feature = "search-code")]
+pub use search_code::*;
+#[cfg(feature = "search-slash")]
+pub use search_slash::*;
+#[cfg(feature = "search-x")]
+pub use search_x::*;
+#[cfg(feature = "section")]
+pub use section::*;
+#[cfg(feature = "send")]
+pub use send::*;
+#[cfg(feature = "send-horizontal")]
+pub use send_horizontal::*;
+#[cfg(feature = "send-to-back")]
+pub use send_to_back::*;
+#[cfg(feature = "separator-horizontal")]
+pub use separator_horizontal::*;
+#[cfg(feature = "separator-vertical")]
+pub use separator_vertical::*;
+#[cfg(feature = "server")]
+pub use server::*;
+#[cfg(feature = "server-cog")]
+pub use server_cog::*;
+#[cfg(feature = "server-crash")]
+pub use server_crash::*;
+#[cfg(feature = "server-off")]
+pub use server_off::*;
+#[cfg(feature = "settings")]
+pub use settings::*;
+#[cfg(feature = "settings-2")]
+pub use settings_2::*;
+#[cfg(feature = "shapes")]
+pub use shapes::*;
+#[cfg(feature = "share")]
+pub use share::*;
+#[cfg(feature = "share-2")]
+pub use share_2::*;
+#[cfg(feature = "sheet")]
+pub use sheet::*;
+#[cfg(feature = "shell")]
+pub use shell::*;
+#[cfg(feature = "shield")]
+pub use shield::*;
+#[cfg(feature = "shield-alert")]
+pub use shield_alert::*;
+#[cfg(feature = "shield-ban")]
+pub use shield_ban::*;
+#[cfg(feature = "shield-check")]
+pub use shield_check::*;
+#[cfg(feature = "shield-ellipsis")]
+pub use shield_ellipsis::*;
+#[cfg(feature = "shield-half")]
+pub use shield_half::*;
+#[cfg(feature = "shield-minus")]
+pub use shield_minus::*;
+#[cfg(feature = "shield-off")]
+pub use shield_off::*;
+#[cfg(feature = "shield-plus")]
+pub use shield_plus::*;
+#[cfg(feature = "shield-question")]
+pub use shield_question::*;
+#[cfg(feature = "shield-x")]
+pub use shield_x::*;
+#[cfg(feature = "ship")]
+pub use ship::*;
+#[cfg(feature = "ship-wheel")]
+pub use ship_wheel::*;
+#[cfg(feature = "shirt")]
+pub use shirt::*;
+#[cfg(feature = "shopping-bag")]
+pub use shopping_bag::*;
+#[cfg(feature = "shopping-basket")]
+pub use shopping_basket::*;
+#[cfg(feature = "shopping-cart")]
+pub use shopping_cart::*;
+#[cfg(feature = "shovel")]
+pub use shovel::*;
+#[cfg(feature = "shower-head")]
+pub use shower_head::*;
+#[cfg(feature = "shrink")]
+pub use shrink::*;
+#[cfg(feature = "shrub")]
+pub use shrub::*;
+#[cfg(feature = "shuffle")]
+pub use shuffle::*;
+#[cfg(feature = "sigma")]
+pub use sigma::*;
+#[cfg(feature = "signal")]
+pub use signal::*;
+#[cfg(feature = "signal-high")]
+pub use signal_high::*;
+#[cfg(feature = "signal-low")]
+pub use signal_low::*;
+#[cfg(feature = "signal-medium")]
+pub use signal_medium::*;
+#[cfg(feature = "signal-zero")]
+pub use signal_zero::*;
+#[cfg(feature = "signature")]
+pub use signature::*;
+#[cfg(feature = "signpost")]
+pub use signpost::*;
+#[cfg(feature = "signpost-big")]
+pub use signpost_big::*;
+#[cfg(feature = "siren")]
+pub use siren::*;
+#[cfg(feature = "skip-back")]
+pub use skip_back::*;
+#[cfg(feature = "skip-forward")]
+pub use skip_forward::*;
+#[cfg(feature = "skull")]
+pub use skull::*;
+#[cfg(feature = "slack")]
+pub use slack::*;
+#[cfg(feature = "slash")]
+pub use slash::*;
+#[cfg(feature = "slice")]
+pub use slice::*;
+#[cfg(feature = "sliders-horizontal")]
+pub use sliders_horizontal::*;
+#[cfg(feature = "sliders-vertical")]
+pub use sliders_vertical::*;
+#[cfg(feature = "smartphone")]
+pub use smartphone::*;
+#[cfg(feature = "smartphone-charging")]
+pub use smartphone_charging::*;
+#[cfg(feature = "smartphone-nfc")]
+pub use smartphone_nfc::*;
+#[cfg(feature = "smile")]
+pub use smile::*;
+#[cfg(feature = "smile-plus")]
+pub use smile_plus::*;
+#[cfg(feature = "snail")]
+pub use snail::*;
+#[cfg(feature = "snowflake")]
+pub use snowflake::*;
+#[cfg(feature = "sofa")]
+pub use sofa::*;
+#[cfg(feature = "soup")]
+pub use soup::*;
+#[cfg(feature = "space")]
+pub use space::*;
+#[cfg(feature = "spade")]
+pub use spade::*;
+#[cfg(feature = "sparkle")]
+pub use sparkle::*;
+#[cfg(feature = "sparkles")]
+pub use sparkles::*;
+#[cfg(feature = "speaker")]
+pub use speaker::*;
+#[cfg(feature = "speech")]
+pub use speech::*;
+#[cfg(feature = "spell-check")]
+pub use spell_check::*;
+#[cfg(feature = "spell-check-2")]
+pub use spell_check_2::*;
+#[cfg(feature = "spline")]
+pub use spline::*;
+#[cfg(feature = "split")]
+pub use split::*;
+#[cfg(feature = "spray-can")]
+pub use spray_can::*;
+#[cfg(feature = "sprout")]
+pub use sprout::*;
+#[cfg(feature = "square")]
+pub use square::*;
+#[cfg(feature = "square-activity")]
+pub use square_activity::*;
+#[cfg(feature = "square-arrow-down")]
+pub use square_arrow_down::*;
+#[cfg(feature = "square-arrow-down-left")]
+pub use square_arrow_down_left::*;
+#[cfg(feature = "square-arrow-down-right")]
+pub use square_arrow_down_right::*;
+#[cfg(feature = "square-arrow-left")]
+pub use square_arrow_left::*;
+#[cfg(feature = "square-arrow-out-down-left")]
+pub use square_arrow_out_down_left::*;
+#[cfg(feature = "square-arrow-out-down-right")]
+pub use square_arrow_out_down_right::*;
+#[cfg(feature = "square-arrow-out-up-left")]
+pub use square_arrow_out_up_left::*;
+#[cfg(feature = "square-arrow-out-up-right")]
+pub use square_arrow_out_up_right::*;
+#[cfg(feature = "square-arrow-right")]
+pub use square_arrow_right::*;
+#[cfg(feature = "square-arrow-up")]
+pub use square_arrow_up::*;
+#[cfg(feature = "square-arrow-up-left")]
+pub use square_arrow_up_left::*;
+#[cfg(feature = "square-arrow-up-right")]
+pub use square_arrow_up_right::*;
+#[cfg(feature = "square-asterisk")]
+pub use square_asterisk::*;
+#[cfg(feature = "square-bottom-dashed-scissors")]
+pub use square_bottom_dashed_scissors::*;
+#[cfg(feature = "square-chart-gantt")]
+pub use square_chart_gantt::*;
+#[cfg(feature = "square-check")]
+pub use square_check::*;
+#[cfg(feature = "square-check-big")]
+pub use square_check_big::*;
+#[cfg(feature = "square-chevron-down")]
+pub use square_chevron_down::*;
+#[cfg(feature = "square-chevron-left")]
+pub use square_chevron_left::*;
+#[cfg(feature = "square-chevron-right")]
+pub use square_chevron_right::*;
+#[cfg(feature = "square-chevron-up")]
+pub use square_chevron_up::*;
+#[cfg(feature = "square-code")]
+pub use square_code::*;
+#[cfg(feature = "square-dashed")]
+pub use square_dashed::*;
+#[cfg(feature = "square-dashed-bottom")]
+pub use square_dashed_bottom::*;
+#[cfg(feature = "square-dashed-bottom-code")]
+pub use square_dashed_bottom_code::*;
+#[cfg(feature = "square-dashed-kanban")]
+pub use square_dashed_kanban::*;
+#[cfg(feature = "square-dashed-mouse-pointer")]
+pub use square_dashed_mouse_pointer::*;
+#[cfg(feature = "square-divide")]
+pub use square_divide::*;
+#[cfg(feature = "square-dot")]
+pub use square_dot::*;
+#[cfg(feature = "square-equal")]
+pub use square_equal::*;
+#[cfg(feature = "square-function")]
+pub use square_function::*;
+#[cfg(feature = "square-kanban")]
+pub use square_kanban::*;
+#[cfg(feature = "square-library")]
+pub use square_library::*;
+#[cfg(feature = "square-m")]
+pub use square_m::*;
+#[cfg(feature = "square-menu")]
+pub use square_menu::*;
+#[cfg(feature = "square-minus")]
+pub use square_minus::*;
+#[cfg(feature = "square-mouse-pointer")]
+pub use square_mouse_pointer::*;
+#[cfg(feature = "square-parking")]
+pub use square_parking::*;
+#[cfg(feature = "square-parking-off")]
+pub use square_parking_off::*;
+#[cfg(feature = "square-pen")]
+pub use square_pen::*;
+#[cfg(feature = "square-percent")]
+pub use square_percent::*;
+#[cfg(feature = "square-pi")]
+pub use square_pi::*;
+#[cfg(feature = "square-pilcrow")]
+pub use square_pilcrow::*;
+#[cfg(feature = "square-play")]
+pub use square_play::*;
+#[cfg(feature = "square-plus")]
+pub use square_plus::*;
+#[cfg(feature = "square-power")]
+pub use square_power::*;
+#[cfg(feature = "square-radical")]
+pub use square_radical::*;
+#[cfg(feature = "square-scissors")]
+pub use square_scissors::*;
+#[cfg(feature = "square-sigma")]
+pub use square_sigma::*;
+#[cfg(feature = "square-slash")]
+pub use square_slash::*;
+#[cfg(feature = "square-split-horizontal")]
+pub use square_split_horizontal::*;
+#[cfg(feature = "square-split-vertical")]
+pub use square_split_vertical::*;
+#[cfg(feature = "square-square")]
+pub use square_square::*;
+#[cfg(feature = "square-stack")]
+pub use square_stack::*;
+#[cfg(feature = "square-terminal")]
+pub use square_terminal::*;
+#[cfg(feature = "square-user")]
+pub use square_user::*;
+#[cfg(feature = "square-user-round")]
+pub use square_user_round::*;
+#[cfg(feature = "square-x")]
+pub use square_x::*;
+#[cfg(feature = "squircle")]
+pub use squircle::*;
+#[cfg(feature = "squirrel")]
+pub use squirrel::*;
+#[cfg(feature = "stamp")]
+pub use stamp::*;
+#[cfg(feature = "star")]
+pub use star::*;
+#[cfg(feature = "star-half")]
+pub use star_half::*;
+#[cfg(feature = "star-off")]
+pub use star_off::*;
+#[cfg(feature = "step-back")]
+pub use step_back::*;
+#[cfg(feature = "step-forward")]
+pub use step_forward::*;
+#[cfg(feature = "stethoscope")]
+pub use stethoscope::*;
+#[cfg(feature = "sticker")]
+pub use sticker::*;
+#[cfg(feature = "sticky-note")]
+pub use sticky_note::*;
+#[cfg(feature = "store")]
+pub use store::*;
+#[cfg(feature = "stretch-horizontal")]
+pub use stretch_horizontal::*;
+#[cfg(feature = "stretch-vertical")]
+pub use stretch_vertical::*;
+#[cfg(feature = "strikethrough")]
+pub use strikethrough::*;
+#[cfg(feature = "subscript")]
+pub use subscript::*;
+#[cfg(feature = "sun")]
+pub use sun::*;
+#[cfg(feature = "sun-dim")]
+pub use sun_dim::*;
+#[cfg(feature = "sun-medium")]
+pub use sun_medium::*;
+#[cfg(feature = "sun-moon")]
+pub use sun_moon::*;
+#[cfg(feature = "sun-snow")]
+pub use sun_snow::*;
+#[cfg(feature = "sunrise")]
+pub use sunrise::*;
+#[cfg(feature = "sunset")]
+pub use sunset::*;
+#[cfg(feature = "superscript")]
+pub use superscript::*;
+#[cfg(feature = "swatch-book")]
+pub use swatch_book::*;
+#[cfg(feature = "swiss-franc")]
+pub use swiss_franc::*;
+#[cfg(feature = "switch-camera")]
+pub use switch_camera::*;
+#[cfg(feature = "sword")]
+pub use sword::*;
+#[cfg(feature = "swords")]
+pub use swords::*;
+#[cfg(feature = "syringe")]
+pub use syringe::*;
+#[cfg(feature = "table")]
+pub use table::*;
+#[cfg(feature = "table-2")]
+pub use table_2::*;
+#[cfg(feature = "table-cells-merge")]
+pub use table_cells_merge::*;
+#[cfg(feature = "table-cells-split")]
+pub use table_cells_split::*;
+#[cfg(feature = "table-columns-split")]
+pub use table_columns_split::*;
+#[cfg(feature = "table-of-contents")]
+pub use table_of_contents::*;
+#[cfg(feature = "table-properties")]
+pub use table_properties::*;
+#[cfg(feature = "table-rows-split")]
+pub use table_rows_split::*;
+#[cfg(feature = "tablet")]
+pub use tablet::*;
+#[cfg(feature = "tablet-smartphone")]
+pub use tablet_smartphone::*;
+#[cfg(feature = "tablets")]
+pub use tablets::*;
+#[cfg(feature = "tag")]
+pub use tag::*;
+#[cfg(feature = "tags")]
+pub use tags::*;
+#[cfg(feature = "tally-1")]
+pub use tally_1::*;
+#[cfg(feature = "tally-2")]
+pub use tally_2::*;
+#[cfg(feature = "tally-3")]
+pub use tally_3::*;
+#[cfg(feature = "tally-4")]
+pub use tally_4::*;
+#[cfg(feature = "tally-5")]
+pub use tally_5::*;
+#[cfg(feature = "tangent")]
+pub use tangent::*;
+#[cfg(feature = "target")]
+pub use target::*;
+#[cfg(feature = "telescope")]
+pub use telescope::*;
+#[cfg(feature = "tent")]
+pub use tent::*;
+#[cfg(feature = "tent-tree")]
+pub use tent_tree::*;
+#[cfg(feature = "terminal")]
+pub use terminal::*;
+#[cfg(feature = "test-tube")]
+pub use test_tube::*;
+#[cfg(feature = "test-tube-diagonal")]
+pub use test_tube_diagonal::*;
+#[cfg(feature = "test-tubes")]
+pub use test_tubes::*;
+#[cfg(feature = "text")]
+pub use text::*;
+#[cfg(feature = "text-cursor")]
+pub use text_cursor::*;
+#[cfg(feature = "text-cursor-input")]
+pub use text_cursor_input::*;
+#[cfg(feature = "text-quote")]
+pub use text_quote::*;
+#[cfg(feature = "text-search")]
+pub use text_search::*;
+#[cfg(feature = "text-select")]
+pub use text_select::*;
+#[cfg(feature = "theater")]
+pub use theater::*;
+#[cfg(feature = "thermometer")]
+pub use thermometer::*;
+#[cfg(feature = "thermometer-snowflake")]
+pub use thermometer_snowflake::*;
+#[cfg(feature = "thermometer-sun")]
+pub use thermometer_sun::*;
+#[cfg(feature = "thumbs-down")]
+pub use thumbs_down::*;
+#[cfg(feature = "thumbs-up")]
+pub use thumbs_up::*;
+#[cfg(feature = "ticket")]
+pub use ticket::*;
+#[cfg(feature = "ticket-check")]
+pub use ticket_check::*;
+#[cfg(feature = "ticket-minus")]
+pub use ticket_minus::*;
+#[cfg(feature = "ticket-percent")]
+pub use ticket_percent::*;
+#[cfg(feature = "ticket-plus")]
+pub use ticket_plus::*;
+#[cfg(feature = "ticket-slash")]
+pub use ticket_slash::*;
+#[cfg(feature = "ticket-x")]
+pub use ticket_x::*;
+#[cfg(feature = "tickets")]
+pub use tickets::*;
+#[cfg(feature = "tickets-plane")]
+pub use tickets_plane::*;
+#[cfg(feature = "timer")]
+pub use timer::*;
+#[cfg(feature = "timer-off")]
+pub use timer_off::*;
+#[cfg(feature = "timer-reset")]
+pub use timer_reset::*;
+#[cfg(feature = "toggle-left")]
+pub use toggle_left::*;
+#[cfg(feature = "toggle-right")]
+pub use toggle_right::*;
+#[cfg(feature = "toilet")]
+pub use toilet::*;
+#[cfg(feature = "tornado")]
+pub use tornado::*;
+#[cfg(feature = "torus")]
+pub use torus::*;
+#[cfg(feature = "touchpad")]
+pub use touchpad::*;
+#[cfg(feature = "touchpad-off")]
+pub use touchpad_off::*;
+#[cfg(feature = "tower-control")]
+pub use tower_control::*;
+#[cfg(feature = "toy-brick")]
+pub use toy_brick::*;
+#[cfg(feature = "tractor")]
+pub use tractor::*;
+#[cfg(feature = "traffic-cone")]
+pub use traffic_cone::*;
+#[cfg(feature = "train-front")]
+pub use train_front::*;
+#[cfg(feature = "train-front-tunnel")]
+pub use train_front_tunnel::*;
+#[cfg(feature = "train-track")]
+pub use train_track::*;
+#[cfg(feature = "tram-front")]
+pub use tram_front::*;
+#[cfg(feature = "trash")]
+pub use trash::*;
+#[cfg(feature = "trash-2")]
+pub use trash_2::*;
+#[cfg(feature = "tree-deciduous")]
+pub use tree_deciduous::*;
+#[cfg(feature = "tree-palm")]
+pub use tree_palm::*;
+#[cfg(feature = "tree-pine")]
+pub use tree_pine::*;
+#[cfg(feature = "trees")]
+pub use trees::*;
+#[cfg(feature = "trello")]
+pub use trello::*;
+#[cfg(feature = "trending-down")]
+pub use trending_down::*;
+#[cfg(feature = "trending-up")]
+pub use trending_up::*;
+#[cfg(feature = "trending-up-down")]
+pub use trending_up_down::*;
+#[cfg(feature = "triangle")]
+pub use triangle::*;
+#[cfg(feature = "triangle-alert")]
+pub use triangle_alert::*;
+#[cfg(feature = "triangle-right")]
+pub use triangle_right::*;
+#[cfg(feature = "trophy")]
+pub use trophy::*;
+#[cfg(feature = "truck")]
+pub use truck::*;
+#[cfg(feature = "turtle")]
+pub use turtle::*;
+#[cfg(feature = "tv")]
+pub use tv::*;
+#[cfg(feature = "tv-minimal")]
+pub use tv_minimal::*;
+#[cfg(feature = "tv-minimal-play")]
+pub use tv_minimal_play::*;
+#[cfg(feature = "twitch")]
+pub use twitch::*;
+#[cfg(feature = "twitter")]
+pub use twitter::*;
+#[cfg(feature = "type-outline")]
+pub use type_outline::*;
+#[cfg(feature = "umbrella")]
+pub use umbrella::*;
+#[cfg(feature = "umbrella-off")]
+pub use umbrella_off::*;
+#[cfg(feature = "underline")]
+pub use underline::*;
+#[cfg(feature = "undo")]
+pub use undo::*;
+#[cfg(feature = "undo-2")]
+pub use undo_2::*;
+#[cfg(feature = "undo-dot")]
+pub use undo_dot::*;
+#[cfg(feature = "unfold-horizontal")]
+pub use unfold_horizontal::*;
+#[cfg(feature = "unfold-vertical")]
+pub use unfold_vertical::*;
+#[cfg(feature = "ungroup")]
+pub use ungroup::*;
+#[cfg(feature = "university")]
+pub use university::*;
+#[cfg(feature = "unlink")]
+pub use unlink::*;
+#[cfg(feature = "unlink-2")]
+pub use unlink_2::*;
+#[cfg(feature = "unplug")]
+pub use unplug::*;
+#[cfg(feature = "upload")]
+pub use upload::*;
+#[cfg(feature = "usb")]
+pub use usb::*;
+#[cfg(feature = "user")]
+pub use user::*;
+#[cfg(feature = "user-check")]
+pub use user_check::*;
+#[cfg(feature = "user-cog")]
+pub use user_cog::*;
+#[cfg(feature = "user-minus")]
+pub use user_minus::*;
+#[cfg(feature = "user-pen")]
+pub use user_pen::*;
+#[cfg(feature = "user-plus")]
+pub use user_plus::*;
+#[cfg(feature = "user-round")]
+pub use user_round::*;
+#[cfg(feature = "user-round-check")]
+pub use user_round_check::*;
+#[cfg(feature = "user-round-cog")]
+pub use user_round_cog::*;
+#[cfg(feature = "user-round-minus")]
+pub use user_round_minus::*;
+#[cfg(feature = "user-round-pen")]
+pub use user_round_pen::*;
+#[cfg(feature = "user-round-plus")]
+pub use user_round_plus::*;
+#[cfg(feature = "user-round-search")]
+pub use user_round_search::*;
+#[cfg(feature = "user-round-x")]
+pub use user_round_x::*;
+#[cfg(feature = "user-search")]
+pub use user_search::*;
+#[cfg(feature = "user-x")]
+pub use user_x::*;
+#[cfg(feature = "users")]
+pub use users::*;
+#[cfg(feature = "users-round")]
+pub use users_round::*;
+#[cfg(feature = "utensils")]
+pub use utensils::*;
+#[cfg(feature = "utensils-crossed")]
+pub use utensils_crossed::*;
+#[cfg(feature = "utility-pole")]
+pub use utility_pole::*;
+#[cfg(feature = "variable")]
+pub use variable::*;
+#[cfg(feature = "vault")]
+pub use vault::*;
+#[cfg(feature = "vegan")]
+pub use vegan::*;
+#[cfg(feature = "venetian-mask")]
+pub use venetian_mask::*;
+#[cfg(feature = "vibrate")]
+pub use vibrate::*;
+#[cfg(feature = "vibrate-off")]
+pub use vibrate_off::*;
+#[cfg(feature = "video")]
+pub use video::*;
+#[cfg(feature = "video-off")]
+pub use video_off::*;
+#[cfg(feature = "videotape")]
+pub use videotape::*;
+#[cfg(feature = "view")]
+pub use view::*;
+#[cfg(feature = "voicemail")]
+pub use voicemail::*;
+#[cfg(feature = "volleyball")]
+pub use volleyball::*;
+#[cfg(feature = "volume")]
+pub use volume::*;
+#[cfg(feature = "volume-1")]
+pub use volume_1::*;
+#[cfg(feature = "volume-2")]
+pub use volume_2::*;
+#[cfg(feature = "volume-off")]
+pub use volume_off::*;
+#[cfg(feature = "volume-x")]
+pub use volume_x::*;
+#[cfg(feature = "vote")]
+pub use vote::*;
+#[cfg(feature = "wallet")]
+pub use wallet::*;
+#[cfg(feature = "wallet-cards")]
+pub use wallet_cards::*;
+#[cfg(feature = "wallet-minimal")]
+pub use wallet_minimal::*;
+#[cfg(feature = "wallpaper")]
+pub use wallpaper::*;
+#[cfg(feature = "wand")]
+pub use wand::*;
+#[cfg(feature = "wand-sparkles")]
+pub use wand_sparkles::*;
+#[cfg(feature = "warehouse")]
+pub use warehouse::*;
+#[cfg(feature = "washing-machine")]
+pub use washing_machine::*;
+#[cfg(feature = "watch")]
+pub use watch::*;
+#[cfg(feature = "waves")]
+pub use waves::*;
+#[cfg(feature = "waypoints")]
+pub use waypoints::*;
+#[cfg(feature = "webcam")]
+pub use webcam::*;
+#[cfg(feature = "webhook")]
+pub use webhook::*;
+#[cfg(feature = "webhook-off")]
+pub use webhook_off::*;
+#[cfg(feature = "weight")]
+pub use weight::*;
+#[cfg(feature = "wheat")]
+pub use wheat::*;
+#[cfg(feature = "wheat-off")]
+pub use wheat_off::*;
+#[cfg(feature = "whole-word")]
+pub use whole_word::*;
+#[cfg(feature = "wifi")]
+pub use wifi::*;
+#[cfg(feature = "wifi-high")]
+pub use wifi_high::*;
+#[cfg(feature = "wifi-low")]
+pub use wifi_low::*;
+#[cfg(feature = "wifi-off")]
+pub use wifi_off::*;
+#[cfg(feature = "wifi-zero")]
+pub use wifi_zero::*;
+#[cfg(feature = "wind")]
+pub use wind::*;
+#[cfg(feature = "wind-arrow-down")]
+pub use wind_arrow_down::*;
+#[cfg(feature = "wine")]
+pub use wine::*;
+#[cfg(feature = "wine-off")]
+pub use wine_off::*;
+#[cfg(feature = "workflow")]
+pub use workflow::*;
+#[cfg(feature = "worm")]
+pub use worm::*;
+#[cfg(feature = "wrap-text")]
+pub use wrap_text::*;
+#[cfg(feature = "wrench")]
+pub use wrench::*;
+#[cfg(feature = "x")]
+pub use x::*;
+#[cfg(feature = "youtube")]
+pub use youtube::*;
+#[cfg(feature = "zap")]
+pub use zap::*;
+#[cfg(feature = "zap-off")]
+pub use zap_off::*;
+#[cfg(feature = "zoom-in")]
+pub use zoom_in::*;
+#[cfg(feature = "zoom-out")]
+pub use zoom_out::*;
diff --git a/packages/leptos/src/library.rs b/packages/leptos/src/library.rs
new file mode 100644
index 0000000..81ccb7e
--- /dev/null
+++ b/packages/leptos/src/library.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Library(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 6 4 14"></path>
+            <path d="M12 6v14"></path>
+            <path d="M8 8v12"></path>
+            <path d="M4 4v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/library_big.rs b/packages/leptos/src/library_big.rs
new file mode 100644
index 0000000..cea550f
--- /dev/null
+++ b/packages/leptos/src/library_big.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LibraryBig(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="18" x="3" y="3" rx="1"></rect>
+            <path d="M7 3v18"></path>
+            <path d="M20.4 18.9c.2.5-.1 1.1-.6 1.3l-1.9.7c-.5.2-1.1-.1-1.3-.6L11.1 5.1c-.2-.5.1-1.1.6-1.3l1.9-.7c.5-.2 1.1.1 1.3.6Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/life_buoy.rs b/packages/leptos/src/life_buoy.rs
new file mode 100644
index 0000000..f35b0e0
--- /dev/null
+++ b/packages/leptos/src/life_buoy.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LifeBuoy(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="m4.93 4.93 4.24 4.24"></path>
+            <path d="m14.83 9.17 4.24-4.24"></path>
+            <path d="m14.83 14.83 4.24 4.24"></path>
+            <path d="m9.17 14.83-4.24 4.24"></path>
+            <circle cx="12" cy="12" r="4"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ligature.rs b/packages/leptos/src/ligature.rs
new file mode 100644
index 0000000..f0118fd
--- /dev/null
+++ b/packages/leptos/src/ligature.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ligature(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 20V8c0-2.2 1.8-4 4-4 1.5 0 2.8.8 3.5 2"></path>
+            <path d="M6 12h4"></path>
+            <path d="M14 12h2v8"></path>
+            <path d="M6 20h4"></path>
+            <path d="M14 20h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lightbulb.rs b/packages/leptos/src/lightbulb.rs
new file mode 100644
index 0000000..014decd
--- /dev/null
+++ b/packages/leptos/src/lightbulb.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Lightbulb(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5.7.7 1.3 1.5 1.5 2.5"></path>
+            <path d="M9 18h6"></path>
+            <path d="M10 22h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lightbulb_off.rs b/packages/leptos/src/lightbulb_off.rs
new file mode 100644
index 0000000..06d0237
--- /dev/null
+++ b/packages/leptos/src/lightbulb_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LightbulbOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16.8 11.2c.8-.9 1.2-2 1.2-3.2a6 6 0 0 0-9.3-5"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M6.3 6.3a4.67 4.67 0 0 0 1.2 5.2c.7.7 1.3 1.5 1.5 2.5"></path>
+            <path d="M9 18h6"></path>
+            <path d="M10 22h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/link.rs b/packages/leptos/src/link.rs
new file mode 100644
index 0000000..bdb57fa
--- /dev/null
+++ b/packages/leptos/src/link.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Link(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"></path>
+            <path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/link_2.rs b/packages/leptos/src/link_2.rs
new file mode 100644
index 0000000..345cb00
--- /dev/null
+++ b/packages/leptos/src/link_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Link2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 17H7A5 5 0 0 1 7 7h2"></path>
+            <path d="M15 7h2a5 5 0 1 1 0 10h-2"></path>
+            <line x1="8" x2="16" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/link_2_off.rs b/packages/leptos/src/link_2_off.rs
new file mode 100644
index 0000000..c5ad84f
--- /dev/null
+++ b/packages/leptos/src/link_2_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Link2Off(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 17H7A5 5 0 0 1 7 7"></path>
+            <path d="M15 7h2a5 5 0 0 1 4 8"></path>
+            <line x1="8" x2="12" y1="12" y2="12"></line>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/linkedin.rs b/packages/leptos/src/linkedin.rs
new file mode 100644
index 0000000..75fb86d
--- /dev/null
+++ b/packages/leptos/src/linkedin.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Linkedin(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z"></path>
+            <rect width="4" height="12" x="2" y="9"></rect>
+            <circle cx="4" cy="4" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list.rs b/packages/leptos/src/list.rs
new file mode 100644
index 0000000..f4c0d16
--- /dev/null
+++ b/packages/leptos/src/list.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn List(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12h.01"></path>
+            <path d="M3 18h.01"></path>
+            <path d="M3 6h.01"></path>
+            <path d="M8 12h13"></path>
+            <path d="M8 18h13"></path>
+            <path d="M8 6h13"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_check.rs b/packages/leptos/src/list_check.rs
new file mode 100644
index 0000000..4878dba
--- /dev/null
+++ b/packages/leptos/src/list_check.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 18H3"></path>
+            <path d="m15 18 2 2 4-4"></path>
+            <path d="M16 12H3"></path>
+            <path d="M16 6H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_checks.rs b/packages/leptos/src/list_checks.rs
new file mode 100644
index 0000000..7c2ad21
--- /dev/null
+++ b/packages/leptos/src/list_checks.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListChecks(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 17 2 2 4-4"></path>
+            <path d="m3 7 2 2 4-4"></path>
+            <path d="M13 6h8"></path>
+            <path d="M13 12h8"></path>
+            <path d="M13 18h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_collapse.rs b/packages/leptos/src/list_collapse.rs
new file mode 100644
index 0000000..c66ffed
--- /dev/null
+++ b/packages/leptos/src/list_collapse.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListCollapse(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 10 2.5-2.5L3 5"></path>
+            <path d="m3 19 2.5-2.5L3 14"></path>
+            <path d="M10 6h11"></path>
+            <path d="M10 12h11"></path>
+            <path d="M10 18h11"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_end.rs b/packages/leptos/src/list_end.rs
new file mode 100644
index 0000000..3276b08
--- /dev/null
+++ b/packages/leptos/src/list_end.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListEnd(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12H3"></path>
+            <path d="M16 6H3"></path>
+            <path d="M10 18H3"></path>
+            <path d="M21 6v10a2 2 0 0 1-2 2h-5"></path>
+            <path d="m16 16-2 2 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_filter.rs b/packages/leptos/src/list_filter.rs
new file mode 100644
index 0000000..b0af915
--- /dev/null
+++ b/packages/leptos/src/list_filter.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListFilter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 6h18"></path>
+            <path d="M7 12h10"></path>
+            <path d="M10 18h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_minus.rs b/packages/leptos/src/list_minus.rs
new file mode 100644
index 0000000..8a89014
--- /dev/null
+++ b/packages/leptos/src/list_minus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 12H3"></path>
+            <path d="M16 6H3"></path>
+            <path d="M16 18H3"></path>
+            <path d="M21 12h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_music.rs b/packages/leptos/src/list_music.rs
new file mode 100644
index 0000000..fce0172
--- /dev/null
+++ b/packages/leptos/src/list_music.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListMusic(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15V6"></path>
+            <path d="M18.5 18a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5Z"></path>
+            <path d="M12 12H3"></path>
+            <path d="M16 6H3"></path>
+            <path d="M12 18H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_ordered.rs b/packages/leptos/src/list_ordered.rs
new file mode 100644
index 0000000..03eeac0
--- /dev/null
+++ b/packages/leptos/src/list_ordered.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListOrdered(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 12h11"></path>
+            <path d="M10 18h11"></path>
+            <path d="M10 6h11"></path>
+            <path d="M4 10h2"></path>
+            <path d="M4 6h1v4"></path>
+            <path d="M6 18H4c0-1 2-2 2-3s-1-1.5-2-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_plus.rs b/packages/leptos/src/list_plus.rs
new file mode 100644
index 0000000..49efdf3
--- /dev/null
+++ b/packages/leptos/src/list_plus.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 12H3"></path>
+            <path d="M16 6H3"></path>
+            <path d="M16 18H3"></path>
+            <path d="M18 9v6"></path>
+            <path d="M21 12h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_restart.rs b/packages/leptos/src/list_restart.rs
new file mode 100644
index 0000000..51c20c5
--- /dev/null
+++ b/packages/leptos/src/list_restart.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListRestart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 6H3"></path>
+            <path d="M7 12H3"></path>
+            <path d="M7 18H3"></path>
+            <path d="M12 18a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L11 14"></path>
+            <path d="M11 10v4h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_start.rs b/packages/leptos/src/list_start.rs
new file mode 100644
index 0000000..9cbea4e
--- /dev/null
+++ b/packages/leptos/src/list_start.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListStart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12H3"></path>
+            <path d="M16 18H3"></path>
+            <path d="M10 6H3"></path>
+            <path d="M21 18V8a2 2 0 0 0-2-2h-5"></path>
+            <path d="m16 8-2-2 2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_todo.rs b/packages/leptos/src/list_todo.rs
new file mode 100644
index 0000000..43da2b2
--- /dev/null
+++ b/packages/leptos/src/list_todo.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListTodo(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="3" y="5" width="6" height="6" rx="1"></rect>
+            <path d="m3 17 2 2 4-4"></path>
+            <path d="M13 6h8"></path>
+            <path d="M13 12h8"></path>
+            <path d="M13 18h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_tree.rs b/packages/leptos/src/list_tree.rs
new file mode 100644
index 0000000..2901703
--- /dev/null
+++ b/packages/leptos/src/list_tree.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListTree(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12h-8"></path>
+            <path d="M21 6H8"></path>
+            <path d="M21 18h-8"></path>
+            <path d="M3 6v4c0 1.1.9 2 2 2h3"></path>
+            <path d="M3 10v6c0 1.1.9 2 2 2h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_video.rs b/packages/leptos/src/list_video.rs
new file mode 100644
index 0000000..621338e
--- /dev/null
+++ b/packages/leptos/src/list_video.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListVideo(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12H3"></path>
+            <path d="M16 6H3"></path>
+            <path d="M12 18H3"></path>
+            <path d="m16 12 5 3-5 3v-6Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/list_x.rs b/packages/leptos/src/list_x.rs
new file mode 100644
index 0000000..22305bc
--- /dev/null
+++ b/packages/leptos/src/list_x.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ListX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 12H3"></path>
+            <path d="M16 6H3"></path>
+            <path d="M16 18H3"></path>
+            <path d="m19 10-4 4"></path>
+            <path d="m15 10 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/loader.rs b/packages/leptos/src/loader.rs
new file mode 100644
index 0000000..61ef4f1
--- /dev/null
+++ b/packages/leptos/src/loader.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Loader(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v4"></path>
+            <path d="m16.2 7.8 2.9-2.9"></path>
+            <path d="M18 12h4"></path>
+            <path d="m16.2 16.2 2.9 2.9"></path>
+            <path d="M12 18v4"></path>
+            <path d="m4.9 19.1 2.9-2.9"></path>
+            <path d="M2 12h4"></path>
+            <path d="m4.9 4.9 2.9 2.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/loader_circle.rs b/packages/leptos/src/loader_circle.rs
new file mode 100644
index 0000000..f7f0176
--- /dev/null
+++ b/packages/leptos/src/loader_circle.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LoaderCircle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12a9 9 0 1 1-6.219-8.56"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/loader_pinwheel.rs b/packages/leptos/src/loader_pinwheel.rs
new file mode 100644
index 0000000..911aa5f
--- /dev/null
+++ b/packages/leptos/src/loader_pinwheel.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LoaderPinwheel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12a1 1 0 0 1-10 0 1 1 0 0 0-10 0"></path>
+            <path d="M7 20.7a1 1 0 1 1 5-8.7 1 1 0 1 0 5-8.6"></path>
+            <path d="M7 3.3a1 1 0 1 1 5 8.6 1 1 0 1 0 5 8.6"></path>
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/locate.rs b/packages/leptos/src/locate.rs
new file mode 100644
index 0000000..f254d64
--- /dev/null
+++ b/packages/leptos/src/locate.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Locate(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="5" y1="12" y2="12"></line>
+            <line x1="19" x2="22" y1="12" y2="12"></line>
+            <line x1="12" x2="12" y1="2" y2="5"></line>
+            <line x1="12" x2="12" y1="19" y2="22"></line>
+            <circle cx="12" cy="12" r="7"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/locate_fixed.rs b/packages/leptos/src/locate_fixed.rs
new file mode 100644
index 0000000..6f500ed
--- /dev/null
+++ b/packages/leptos/src/locate_fixed.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LocateFixed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="5" y1="12" y2="12"></line>
+            <line x1="19" x2="22" y1="12" y2="12"></line>
+            <line x1="12" x2="12" y1="2" y2="5"></line>
+            <line x1="12" x2="12" y1="19" y2="22"></line>
+            <circle cx="12" cy="12" r="7"></circle>
+            <circle cx="12" cy="12" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/locate_off.rs b/packages/leptos/src/locate_off.rs
new file mode 100644
index 0000000..1ef171c
--- /dev/null
+++ b/packages/leptos/src/locate_off.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LocateOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="5" y1="12" y2="12"></line>
+            <line x1="19" x2="22" y1="12" y2="12"></line>
+            <line x1="12" x2="12" y1="2" y2="5"></line>
+            <line x1="12" x2="12" y1="19" y2="22"></line>
+            <path d="M7.11 7.11C5.83 8.39 5 10.1 5 12c0 3.87 3.13 7 7 7 1.9 0 3.61-.83 4.89-2.11"></path>
+            <path d="M18.71 13.96c.19-.63.29-1.29.29-1.96 0-3.87-3.13-7-7-7-.67 0-1.33.1-1.96.29"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lock.rs b/packages/leptos/src/lock.rs
new file mode 100644
index 0000000..2f34739
--- /dev/null
+++ b/packages/leptos/src/lock.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Lock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="11" x="3" y="11" rx="2" ry="2"></rect>
+            <path d="M7 11V7a5 5 0 0 1 10 0v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lock_keyhole.rs b/packages/leptos/src/lock_keyhole.rs
new file mode 100644
index 0000000..fec8f3b
--- /dev/null
+++ b/packages/leptos/src/lock_keyhole.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LockKeyhole(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="16" r="1"></circle>
+            <rect x="3" y="10" width="18" height="12" rx="2"></rect>
+            <path d="M7 10V7a5 5 0 0 1 10 0v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lock_keyhole_open.rs b/packages/leptos/src/lock_keyhole_open.rs
new file mode 100644
index 0000000..6eea124
--- /dev/null
+++ b/packages/leptos/src/lock_keyhole_open.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LockKeyholeOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="16" r="1"></circle>
+            <rect width="18" height="12" x="3" y="10" rx="2"></rect>
+            <path d="M7 10V7a5 5 0 0 1 9.33-2.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lock_open.rs b/packages/leptos/src/lock_open.rs
new file mode 100644
index 0000000..984abdb
--- /dev/null
+++ b/packages/leptos/src/lock_open.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LockOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="11" x="3" y="11" rx="2" ry="2"></rect>
+            <path d="M7 11V7a5 5 0 0 1 9.9-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/log_in.rs b/packages/leptos/src/log_in.rs
new file mode 100644
index 0000000..7be9a0e
--- /dev/null
+++ b/packages/leptos/src/log_in.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LogIn(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4"></path>
+            <polyline points="10 17 15 12 10 7"></polyline>
+            <line x1="15" x2="3" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/log_out.rs b/packages/leptos/src/log_out.rs
new file mode 100644
index 0000000..22ced33
--- /dev/null
+++ b/packages/leptos/src/log_out.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn LogOut(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4"></path>
+            <polyline points="16 17 21 12 16 7"></polyline>
+            <line x1="21" x2="9" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/logs.rs b/packages/leptos/src/logs.rs
new file mode 100644
index 0000000..fa2b31a
--- /dev/null
+++ b/packages/leptos/src/logs.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Logs(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 12h8"></path>
+            <path d="M13 18h8"></path>
+            <path d="M13 6h8"></path>
+            <path d="M3 12h1"></path>
+            <path d="M3 18h1"></path>
+            <path d="M3 6h1"></path>
+            <path d="M8 12h1"></path>
+            <path d="M8 18h1"></path>
+            <path d="M8 6h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/lollipop.rs b/packages/leptos/src/lollipop.rs
new file mode 100644
index 0000000..5781a65
--- /dev/null
+++ b/packages/leptos/src/lollipop.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Lollipop(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="11" r="8"></circle>
+            <path d="m21 21-4.3-4.3"></path>
+            <path d="M11 11a2 2 0 0 0 4 0 4 4 0 0 0-8 0 6 6 0 0 0 12 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/luggage.rs b/packages/leptos/src/luggage.rs
new file mode 100644
index 0000000..26afdcd
--- /dev/null
+++ b/packages/leptos/src/luggage.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Luggage(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 20a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2"></path>
+            <path d="M8 18V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v14"></path>
+            <path d="M10 20h4"></path>
+            <circle cx="16" cy="20" r="2"></circle>
+            <circle cx="8" cy="20" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/magnet.rs b/packages/leptos/src/magnet.rs
new file mode 100644
index 0000000..3a08b7c
--- /dev/null
+++ b/packages/leptos/src/magnet.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Magnet(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 15-4-4 6.75-6.77a7.79 7.79 0 0 1 11 11L13 22l-4-4 6.39-6.36a2.14 2.14 0 0 0-3-3L6 15"></path>
+            <path d="m5 8 4 4"></path>
+            <path d="m12 15 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail.rs b/packages/leptos/src/mail.rs
new file mode 100644
index 0000000..2d8fedb
--- /dev/null
+++ b/packages/leptos/src/mail.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Mail(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail_check.rs b/packages/leptos/src/mail_check.rs
new file mode 100644
index 0000000..3ebe285
--- /dev/null
+++ b/packages/leptos/src/mail_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MailCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8"></path>
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+            <path d="m16 19 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail_minus.rs b/packages/leptos/src/mail_minus.rs
new file mode 100644
index 0000000..eca6ece
--- /dev/null
+++ b/packages/leptos/src/mail_minus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MailMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 15V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8"></path>
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+            <path d="M16 19h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail_open.rs b/packages/leptos/src/mail_open.rs
new file mode 100644
index 0000000..79c0980
--- /dev/null
+++ b/packages/leptos/src/mail_open.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MailOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.2 8.4c.5.38.8.97.8 1.6v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V10a2 2 0 0 1 .8-1.6l8-6a2 2 0 0 1 2.4 0l8 6Z"></path>
+            <path d="m22 10-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail_plus.rs b/packages/leptos/src/mail_plus.rs
new file mode 100644
index 0000000..a6194f3
--- /dev/null
+++ b/packages/leptos/src/mail_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MailPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8"></path>
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+            <path d="M19 16v6"></path>
+            <path d="M16 19h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail_question.rs b/packages/leptos/src/mail_question.rs
new file mode 100644
index 0000000..3a17f0a
--- /dev/null
+++ b/packages/leptos/src/mail_question.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MailQuestion(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 10.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h12.5"></path>
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+            <path d="M18 15.28c.2-.4.5-.8.9-1a2.1 2.1 0 0 1 2.6.4c.3.4.5.8.5 1.3 0 1.3-2 2-2 2"></path>
+            <path d="M20 22v.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail_search.rs b/packages/leptos/src/mail_search.rs
new file mode 100644
index 0000000..aa529c6
--- /dev/null
+++ b/packages/leptos/src/mail_search.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MailSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h7.5"></path>
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+            <path d="M18 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z"></path>
+            <circle cx="18" cy="18" r="3"></circle>
+            <path d="m22 22-1.5-1.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail_warning.rs b/packages/leptos/src/mail_warning.rs
new file mode 100644
index 0000000..9811717
--- /dev/null
+++ b/packages/leptos/src/mail_warning.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MailWarning(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 10.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h12.5"></path>
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+            <path d="M20 14v4"></path>
+            <path d="M20 22v.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mail_x.rs b/packages/leptos/src/mail_x.rs
new file mode 100644
index 0000000..eadf2c7
--- /dev/null
+++ b/packages/leptos/src/mail_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MailX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h9"></path>
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+            <path d="m17 17 4 4"></path>
+            <path d="m21 17-4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mailbox.rs b/packages/leptos/src/mailbox.rs
new file mode 100644
index 0000000..91dc364
--- /dev/null
+++ b/packages/leptos/src/mailbox.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Mailbox(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9.5C2 7 4 5 6.5 5H18c2.2 0 4 1.8 4 4v8Z"></path>
+            <polyline points="15,9 18,9 18,11"></polyline>
+            <path d="M6.5 5C9 5 11 7 11 9.5V17a2 2 0 0 1-2 2"></path>
+            <line x1="6" x2="7" y1="10" y2="10"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mails.rs b/packages/leptos/src/mails.rs
new file mode 100644
index 0000000..bec95eb
--- /dev/null
+++ b/packages/leptos/src/mails.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Mails(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="13" x="6" y="4" rx="2"></rect>
+            <path d="m22 7-7.1 3.78c-.57.3-1.23.3-1.8 0L6 7"></path>
+            <path d="M2 8v11c0 1.1.9 2 2 2h14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map.rs b/packages/leptos/src/map.rs
new file mode 100644
index 0000000..a056b67
--- /dev/null
+++ b/packages/leptos/src/map.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Map(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.106 5.553a2 2 0 0 0 1.788 0l3.659-1.83A1 1 0 0 1 21 4.619v12.764a1 1 0 0 1-.553.894l-4.553 2.277a2 2 0 0 1-1.788 0l-4.212-2.106a2 2 0 0 0-1.788 0l-3.659 1.83A1 1 0 0 1 3 19.381V6.618a1 1 0 0 1 .553-.894l4.553-2.277a2 2 0 0 1 1.788 0z"></path>
+            <path d="M15 5.764v15"></path>
+            <path d="M9 3.236v15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin.rs b/packages/leptos/src/map_pin.rs
new file mode 100644
index 0000000..e8a1a34
--- /dev/null
+++ b/packages/leptos/src/map_pin.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPin(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"></path>
+            <circle cx="12" cy="10" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_check.rs b/packages/leptos/src/map_pin_check.rs
new file mode 100644
index 0000000..1c43940
--- /dev/null
+++ b/packages/leptos/src/map_pin_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.43 12.935c.357-.967.57-1.955.57-2.935a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32.197 32.197 0 0 0 .813-.728"></path>
+            <circle cx="12" cy="10" r="3"></circle>
+            <path d="m16 18 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_check_inside.rs b/packages/leptos/src/map_pin_check_inside.rs
new file mode 100644
index 0000000..356915a
--- /dev/null
+++ b/packages/leptos/src/map_pin_check_inside.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinCheckInside(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"></path>
+            <path d="m9 10 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_house.rs b/packages/leptos/src/map_pin_house.rs
new file mode 100644
index 0000000..3ba894f
--- /dev/null
+++ b/packages/leptos/src/map_pin_house.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinHouse(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 22a1 1 0 0 1-1-1v-4a1 1 0 0 1 .445-.832l3-2a1 1 0 0 1 1.11 0l3 2A1 1 0 0 1 22 17v4a1 1 0 0 1-1 1z"></path>
+            <path d="M18 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 .601.2"></path>
+            <path d="M18 22v-3"></path>
+            <circle cx="10" cy="10" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_minus.rs b/packages/leptos/src/map_pin_minus.rs
new file mode 100644
index 0000000..7cb1379
--- /dev/null
+++ b/packages/leptos/src/map_pin_minus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.977 14C19.6 12.701 20 11.343 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32 32 0 0 0 .824-.738"></path>
+            <circle cx="12" cy="10" r="3"></circle>
+            <path d="M16 18h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_minus_inside.rs b/packages/leptos/src/map_pin_minus_inside.rs
new file mode 100644
index 0000000..b3cb7bf
--- /dev/null
+++ b/packages/leptos/src/map_pin_minus_inside.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinMinusInside(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"></path>
+            <path d="M9 10h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_off.rs b/packages/leptos/src/map_pin_off.rs
new file mode 100644
index 0000000..93050dc
--- /dev/null
+++ b/packages/leptos/src/map_pin_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.75 7.09a3 3 0 0 1 2.16 2.16"></path>
+            <path d="M17.072 17.072c-1.634 2.17-3.527 3.912-4.471 4.727a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 1.432-4.568"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M8.475 2.818A8 8 0 0 1 20 10c0 1.183-.31 2.377-.81 3.533"></path>
+            <path d="M9.13 9.13a3 3 0 0 0 3.74 3.74"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_plus.rs b/packages/leptos/src/map_pin_plus.rs
new file mode 100644
index 0000000..725a397
--- /dev/null
+++ b/packages/leptos/src/map_pin_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.914 11.105A7.298 7.298 0 0 0 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32 32 0 0 0 .824-.738"></path>
+            <circle cx="12" cy="10" r="3"></circle>
+            <path d="M16 18h6"></path>
+            <path d="M19 15v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_plus_inside.rs b/packages/leptos/src/map_pin_plus_inside.rs
new file mode 100644
index 0000000..7acb36e
--- /dev/null
+++ b/packages/leptos/src/map_pin_plus_inside.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinPlusInside(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"></path>
+            <path d="M12 7v6"></path>
+            <path d="M9 10h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_x.rs b/packages/leptos/src/map_pin_x.rs
new file mode 100644
index 0000000..9db6258
--- /dev/null
+++ b/packages/leptos/src/map_pin_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.752 11.901A7.78 7.78 0 0 0 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 19 19 0 0 0 .09-.077"></path>
+            <circle cx="12" cy="10" r="3"></circle>
+            <path d="m21.5 15.5-5 5"></path>
+            <path d="m21.5 20.5-5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pin_x_inside.rs b/packages/leptos/src/map_pin_x_inside.rs
new file mode 100644
index 0000000..469290c
--- /dev/null
+++ b/packages/leptos/src/map_pin_x_inside.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinXInside(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"></path>
+            <path d="m14.5 7.5-5 5"></path>
+            <path d="m9.5 7.5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/map_pinned.rs b/packages/leptos/src/map_pinned.rs
new file mode 100644
index 0000000..c42404a
--- /dev/null
+++ b/packages/leptos/src/map_pinned.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MapPinned(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 8c0 3.613-3.869 7.429-5.393 8.795a1 1 0 0 1-1.214 0C9.87 15.429 6 11.613 6 8a6 6 0 0 1 12 0"></path>
+            <circle cx="12" cy="8" r="2"></circle>
+            <path d="M8.714 14h-3.71a1 1 0 0 0-.948.683l-2.004 6A1 1 0 0 0 3 22h18a1 1 0 0 0 .948-1.316l-2-6a1 1 0 0 0-.949-.684h-3.712"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/martini.rs b/packages/leptos/src/martini.rs
new file mode 100644
index 0000000..0a40a5f
--- /dev/null
+++ b/packages/leptos/src/martini.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Martini(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 22h8"></path>
+            <path d="M12 11v11"></path>
+            <path d="m19 3-7 8-7-8Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/maximize.rs b/packages/leptos/src/maximize.rs
new file mode 100644
index 0000000..a374c33
--- /dev/null
+++ b/packages/leptos/src/maximize.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Maximize(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3H5a2 2 0 0 0-2 2v3"></path>
+            <path d="M21 8V5a2 2 0 0 0-2-2h-3"></path>
+            <path d="M3 16v3a2 2 0 0 0 2 2h3"></path>
+            <path d="M16 21h3a2 2 0 0 0 2-2v-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/maximize_2.rs b/packages/leptos/src/maximize_2.rs
new file mode 100644
index 0000000..c474be1
--- /dev/null
+++ b/packages/leptos/src/maximize_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Maximize2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="15 3 21 3 21 9"></polyline>
+            <polyline points="9 21 3 21 3 15"></polyline>
+            <line x1="21" x2="14" y1="3" y2="10"></line>
+            <line x1="3" x2="10" y1="21" y2="14"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/medal.rs b/packages/leptos/src/medal.rs
new file mode 100644
index 0000000..fc8e8e9
--- /dev/null
+++ b/packages/leptos/src/medal.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Medal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.21 15 2.66 7.14a2 2 0 0 1 .13-2.2L4.4 2.8A2 2 0 0 1 6 2h12a2 2 0 0 1 1.6.8l1.6 2.14a2 2 0 0 1 .14 2.2L16.79 15"></path>
+            <path d="M11 12 5.12 2.2"></path>
+            <path d="m13 12 5.88-9.8"></path>
+            <path d="M8 7h8"></path>
+            <circle cx="12" cy="17" r="5"></circle>
+            <path d="M12 18v-2h-.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/megaphone.rs b/packages/leptos/src/megaphone.rs
new file mode 100644
index 0000000..4126346
--- /dev/null
+++ b/packages/leptos/src/megaphone.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Megaphone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 11 18-5v12L3 14v-3z"></path>
+            <path d="M11.6 16.8a3 3 0 1 1-5.8-1.6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/megaphone_off.rs b/packages/leptos/src/megaphone_off.rs
new file mode 100644
index 0000000..a16a221
--- /dev/null
+++ b/packages/leptos/src/megaphone_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MegaphoneOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9.26 9.26 3 11v3l14.14 3.14"></path>
+            <path d="M21 15.34V6l-7.31 2.03"></path>
+            <path d="M11.6 16.8a3 3 0 1 1-5.8-1.6"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/meh.rs b/packages/leptos/src/meh.rs
new file mode 100644
index 0000000..f5d2393
--- /dev/null
+++ b/packages/leptos/src/meh.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Meh(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <line x1="8" x2="16" y1="15" y2="15"></line>
+            <line x1="9" x2="9.01" y1="9" y2="9"></line>
+            <line x1="15" x2="15.01" y1="9" y2="9"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/memory_stick.rs b/packages/leptos/src/memory_stick.rs
new file mode 100644
index 0000000..51445e4
--- /dev/null
+++ b/packages/leptos/src/memory_stick.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MemoryStick(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 19v-3"></path>
+            <path d="M10 19v-3"></path>
+            <path d="M14 19v-3"></path>
+            <path d="M18 19v-3"></path>
+            <path d="M8 11V9"></path>
+            <path d="M16 11V9"></path>
+            <path d="M12 11V9"></path>
+            <path d="M2 15h20"></path>
+            <path d="M2 7a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1.1a2 2 0 0 0 0 3.837V17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-5.1a2 2 0 0 0 0-3.837Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/menu.rs b/packages/leptos/src/menu.rs
new file mode 100644
index 0000000..a39b374
--- /dev/null
+++ b/packages/leptos/src/menu.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Menu(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="4" x2="20" y1="12" y2="12"></line>
+            <line x1="4" x2="20" y1="6" y2="6"></line>
+            <line x1="4" x2="20" y1="18" y2="18"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/merge.rs b/packages/leptos/src/merge.rs
new file mode 100644
index 0000000..3084d68
--- /dev/null
+++ b/packages/leptos/src/merge.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Merge(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 6 4-4 4 4"></path>
+            <path d="M12 2v10.3a4 4 0 0 1-1.172 2.872L4 22"></path>
+            <path d="m20 22-5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle.rs b/packages/leptos/src/message_circle.rs
new file mode 100644
index 0000000..d089bf2
--- /dev/null
+++ b/packages/leptos/src/message_circle.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_code.rs b/packages/leptos/src/message_circle_code.rs
new file mode 100644
index 0000000..5dedbd5
--- /dev/null
+++ b/packages/leptos/src/message_circle_code.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9.5 8 12l2 2.5"></path>
+            <path d="m14 9.5 2 2.5-2 2.5"></path>
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_dashed.rs b/packages/leptos/src/message_circle_dashed.rs
new file mode 100644
index 0000000..db4cb13
--- /dev/null
+++ b/packages/leptos/src/message_circle_dashed.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.5 3.1c-.5 0-1-.1-1.5-.1s-1 .1-1.5.1"></path>
+            <path d="M19.3 6.8a10.45 10.45 0 0 0-2.1-2.1"></path>
+            <path d="M20.9 13.5c.1-.5.1-1 .1-1.5s-.1-1-.1-1.5"></path>
+            <path d="M17.2 19.3a10.45 10.45 0 0 0 2.1-2.1"></path>
+            <path d="M10.5 20.9c.5.1 1 .1 1.5.1s1-.1 1.5-.1"></path>
+            <path d="M3.5 17.5 2 22l4.5-1.5"></path>
+            <path d="M3.1 10.5c0 .5-.1 1-.1 1.5s.1 1 .1 1.5"></path>
+            <path d="M6.8 4.7a10.45 10.45 0 0 0-2.1 2.1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_heart.rs b/packages/leptos/src/message_circle_heart.rs
new file mode 100644
index 0000000..c31e58e
--- /dev/null
+++ b/packages/leptos/src/message_circle_heart.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleHeart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"></path>
+            <path d="M15.8 9.2a2.5 2.5 0 0 0-3.5 0l-.3.4-.35-.3a2.42 2.42 0 1 0-3.2 3.6l3.6 3.5 3.6-3.5c1.2-1.2 1.1-2.7.2-3.7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_more.rs b/packages/leptos/src/message_circle_more.rs
new file mode 100644
index 0000000..726ff20
--- /dev/null
+++ b/packages/leptos/src/message_circle_more.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleMore(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"></path>
+            <path d="M8 12h.01"></path>
+            <path d="M12 12h.01"></path>
+            <path d="M16 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_off.rs b/packages/leptos/src/message_circle_off.rs
new file mode 100644
index 0000000..44541fa
--- /dev/null
+++ b/packages/leptos/src/message_circle_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20.5 14.9A9 9 0 0 0 9.1 3.5"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M5.6 5.6C3 8.3 2.2 12.5 4 16l-2 6 6-2c3.4 1.8 7.6 1.1 10.3-1.7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_plus.rs b/packages/leptos/src/message_circle_plus.rs
new file mode 100644
index 0000000..9ddde90
--- /dev/null
+++ b/packages/leptos/src/message_circle_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCirclePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"></path>
+            <path d="M8 12h8"></path>
+            <path d="M12 8v8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_question.rs b/packages/leptos/src/message_circle_question.rs
new file mode 100644
index 0000000..5d5ca1e
--- /dev/null
+++ b/packages/leptos/src/message_circle_question.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleQuestion(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"></path>
+            <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"></path>
+            <path d="M12 17h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_reply.rs b/packages/leptos/src/message_circle_reply.rs
new file mode 100644
index 0000000..5dae8ae
--- /dev/null
+++ b/packages/leptos/src/message_circle_reply.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleReply(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"></path>
+            <path d="m10 15-3-3 3-3"></path>
+            <path d="M7 12h7a2 2 0 0 1 2 2v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_warning.rs b/packages/leptos/src/message_circle_warning.rs
new file mode 100644
index 0000000..d2f9a47
--- /dev/null
+++ b/packages/leptos/src/message_circle_warning.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleWarning(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"></path>
+            <path d="M12 8v4"></path>
+            <path d="M12 16h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_circle_x.rs b/packages/leptos/src/message_circle_x.rs
new file mode 100644
index 0000000..c95220f
--- /dev/null
+++ b/packages/leptos/src/message_circle_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageCircleX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"></path>
+            <path d="m15 9-6 6"></path>
+            <path d="m9 9 6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square.rs b/packages/leptos/src/message_square.rs
new file mode 100644
index 0000000..125ae9f
--- /dev/null
+++ b/packages/leptos/src/message_square.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_code.rs b/packages/leptos/src/message_square_code.rs
new file mode 100644
index 0000000..767c57b
--- /dev/null
+++ b/packages/leptos/src/message_square_code.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 7.5 8 10l2 2.5"></path>
+            <path d="m14 7.5 2 2.5-2 2.5"></path>
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_dashed.rs b/packages/leptos/src/message_square_dashed.rs
new file mode 100644
index 0000000..4068a64
--- /dev/null
+++ b/packages/leptos/src/message_square_dashed.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 17H7l-4 4v-7"></path>
+            <path d="M14 17h1"></path>
+            <path d="M14 3h1"></path>
+            <path d="M19 3a2 2 0 0 1 2 2"></path>
+            <path d="M21 14v1a2 2 0 0 1-2 2"></path>
+            <path d="M21 9v1"></path>
+            <path d="M3 9v1"></path>
+            <path d="M5 3a2 2 0 0 0-2 2"></path>
+            <path d="M9 3h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_diff.rs b/packages/leptos/src/message_square_diff.rs
new file mode 100644
index 0000000..efc3f61
--- /dev/null
+++ b/packages/leptos/src/message_square_diff.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareDiff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5 19-2 2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2"></path>
+            <path d="M9 10h6"></path>
+            <path d="M12 7v6"></path>
+            <path d="M9 17h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_dot.rs b/packages/leptos/src/message_square_dot.rs
new file mode 100644
index 0000000..0bea602
--- /dev/null
+++ b/packages/leptos/src/message_square_dot.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.7 3H5a2 2 0 0 0-2 2v16l4-4h12a2 2 0 0 0 2-2v-2.7"></path>
+            <circle cx="18" cy="6" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_heart.rs b/packages/leptos/src/message_square_heart.rs
new file mode 100644
index 0000000..ad8bfe4
--- /dev/null
+++ b/packages/leptos/src/message_square_heart.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareHeart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+            <path d="M14.8 7.5a1.84 1.84 0 0 0-2.6 0l-.2.3-.3-.3a1.84 1.84 0 1 0-2.4 2.8L12 13l2.7-2.7c.9-.9.8-2.1.1-2.8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_lock.rs b/packages/leptos/src/message_square_lock.rs
new file mode 100644
index 0000000..b6d0681
--- /dev/null
+++ b/packages/leptos/src/message_square_lock.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareLock(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 15v-2a2 2 0 1 0-4 0v2"></path>
+            <path d="M9 17H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v3.5"></path>
+            <rect x="13" y="15" width="8" height="5" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_more.rs b/packages/leptos/src/message_square_more.rs
new file mode 100644
index 0000000..5f01d36
--- /dev/null
+++ b/packages/leptos/src/message_square_more.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareMore(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+            <path d="M8 10h.01"></path>
+            <path d="M12 10h.01"></path>
+            <path d="M16 10h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_off.rs b/packages/leptos/src/message_square_off.rs
new file mode 100644
index 0000000..4b1e7c3
--- /dev/null
+++ b/packages/leptos/src/message_square_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15V5a2 2 0 0 0-2-2H9"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M3.6 3.6c-.4.3-.6.8-.6 1.4v16l4-4h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_plus.rs b/packages/leptos/src/message_square_plus.rs
new file mode 100644
index 0000000..9dcb9da
--- /dev/null
+++ b/packages/leptos/src/message_square_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquarePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+            <path d="M12 7v6"></path>
+            <path d="M9 10h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_quote.rs b/packages/leptos/src/message_square_quote.rs
new file mode 100644
index 0000000..c151816
--- /dev/null
+++ b/packages/leptos/src/message_square_quote.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareQuote(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+            <path d="M8 12a2 2 0 0 0 2-2V8H8"></path>
+            <path d="M14 12a2 2 0 0 0 2-2V8h-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_reply.rs b/packages/leptos/src/message_square_reply.rs
new file mode 100644
index 0000000..e9e343e
--- /dev/null
+++ b/packages/leptos/src/message_square_reply.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareReply(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+            <path d="m10 7-3 3 3 3"></path>
+            <path d="M17 13v-1a2 2 0 0 0-2-2H7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_share.rs b/packages/leptos/src/message_square_share.rs
new file mode 100644
index 0000000..70a9dcc
--- /dev/null
+++ b/packages/leptos/src/message_square_share.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareShare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12v3a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h7"></path>
+            <path d="M16 3h5v5"></path>
+            <path d="m16 8 5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_text.rs b/packages/leptos/src/message_square_text.rs
new file mode 100644
index 0000000..d0060aa
--- /dev/null
+++ b/packages/leptos/src/message_square_text.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+            <path d="M13 8H7"></path>
+            <path d="M17 12H7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_warning.rs b/packages/leptos/src/message_square_warning.rs
new file mode 100644
index 0000000..06aa60b
--- /dev/null
+++ b/packages/leptos/src/message_square_warning.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareWarning(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+            <path d="M12 7v2"></path>
+            <path d="M12 13h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/message_square_x.rs b/packages/leptos/src/message_square_x.rs
new file mode 100644
index 0000000..6189ea7
--- /dev/null
+++ b/packages/leptos/src/message_square_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessageSquareX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+            <path d="m14.5 7.5-5 5"></path>
+            <path d="m9.5 7.5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/messages_square.rs b/packages/leptos/src/messages_square.rs
new file mode 100644
index 0000000..959143e
--- /dev/null
+++ b/packages/leptos/src/messages_square.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MessagesSquare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 9a2 2 0 0 1-2 2H6l-4 4V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2z"></path>
+            <path d="M18 9h2a2 2 0 0 1 2 2v11l-4-4h-6a2 2 0 0 1-2-2v-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mic.rs b/packages/leptos/src/mic.rs
new file mode 100644
index 0000000..942a122
--- /dev/null
+++ b/packages/leptos/src/mic.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Mic(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2a3 3 0 0 0-3 3v7a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3Z"></path>
+            <path d="M19 10v2a7 7 0 0 1-14 0v-2"></path>
+            <line x1="12" x2="12" y1="19" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mic_off.rs b/packages/leptos/src/mic_off.rs
new file mode 100644
index 0000000..ceac5d9
--- /dev/null
+++ b/packages/leptos/src/mic_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MicOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+            <path d="M18.89 13.23A7.12 7.12 0 0 0 19 12v-2"></path>
+            <path d="M5 10v2a7 7 0 0 0 12 5"></path>
+            <path d="M15 9.34V5a3 3 0 0 0-5.68-1.33"></path>
+            <path d="M9 9v3a3 3 0 0 0 5.12 2.12"></path>
+            <line x1="12" x2="12" y1="19" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mic_vocal.rs b/packages/leptos/src/mic_vocal.rs
new file mode 100644
index 0000000..5e66d45
--- /dev/null
+++ b/packages/leptos/src/mic_vocal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MicVocal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11 7.601-5.994 8.19a1 1 0 0 0 .1 1.298l.817.818a1 1 0 0 0 1.314.087L15.09 12"></path>
+            <path d="M16.5 21.174C15.5 20.5 14.372 20 13 20c-2.058 0-3.928 2.356-6 2-2.072-.356-2.775-3.369-1.5-4.5"></path>
+            <circle cx="16" cy="7" r="5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/microchip.rs b/packages/leptos/src/microchip.rs
new file mode 100644
index 0000000..ee1efe9
--- /dev/null
+++ b/packages/leptos/src/microchip.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Microchip(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 12h2"></path>
+            <path d="M18 16h2"></path>
+            <path d="M18 20h2"></path>
+            <path d="M18 4h2"></path>
+            <path d="M18 8h2"></path>
+            <path d="M4 12h2"></path>
+            <path d="M4 16h2"></path>
+            <path d="M4 20h2"></path>
+            <path d="M4 4h2"></path>
+            <path d="M4 8h2"></path>
+            <path d="M8 2a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2h-1.5c-.276 0-.494.227-.562.495a2 2 0 0 1-3.876 0C9.994 2.227 9.776 2 9.5 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/microscope.rs b/packages/leptos/src/microscope.rs
new file mode 100644
index 0000000..1748fb6
--- /dev/null
+++ b/packages/leptos/src/microscope.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Microscope(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 18h8"></path>
+            <path d="M3 22h18"></path>
+            <path d="M14 22a7 7 0 1 0 0-14h-1"></path>
+            <path d="M9 14h2"></path>
+            <path d="M9 12a2 2 0 0 1-2-2V6h6v4a2 2 0 0 1-2 2Z"></path>
+            <path d="M12 6V3a1 1 0 0 0-1-1H9a1 1 0 0 0-1 1v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/microwave.rs b/packages/leptos/src/microwave.rs
new file mode 100644
index 0000000..d7f1f48
--- /dev/null
+++ b/packages/leptos/src/microwave.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Microwave(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="15" x="2" y="4" rx="2"></rect>
+            <rect width="8" height="7" x="6" y="8" rx="1"></rect>
+            <path d="M18 8v7"></path>
+            <path d="M6 19v2"></path>
+            <path d="M18 19v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/milestone.rs b/packages/leptos/src/milestone.rs
new file mode 100644
index 0000000..b48987d
--- /dev/null
+++ b/packages/leptos/src/milestone.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Milestone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13v8"></path>
+            <path d="M12 3v3"></path>
+            <path d="M4 6a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1h13a2 2 0 0 0 1.152-.365l3.424-2.317a1 1 0 0 0 0-1.635l-3.424-2.318A2 2 0 0 0 17 6z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/milk.rs b/packages/leptos/src/milk.rs
new file mode 100644
index 0000000..d080f66
--- /dev/null
+++ b/packages/leptos/src/milk.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Milk(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2h8"></path>
+            <path d="M9 2v2.789a4 4 0 0 1-.672 2.219l-.656.984A4 4 0 0 0 7 10.212V20a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-9.789a4 4 0 0 0-.672-2.219l-.656-.984A4 4 0 0 1 15 4.788V2"></path>
+            <path d="M7 15a6.472 6.472 0 0 1 5 0 6.47 6.47 0 0 0 5 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/milk_off.rs b/packages/leptos/src/milk_off.rs
new file mode 100644
index 0000000..dfd558a
--- /dev/null
+++ b/packages/leptos/src/milk_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MilkOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2h8"></path>
+            <path d="M9 2v1.343M15 2v2.789a4 4 0 0 0 .672 2.219l.656.984a4 4 0 0 1 .672 2.22v1.131M7.8 7.8l-.128.192A4 4 0 0 0 7 10.212V20a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-3"></path>
+            <path d="M7 15a6.47 6.47 0 0 1 5 0 6.472 6.472 0 0 0 3.435.435"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/minimize.rs b/packages/leptos/src/minimize.rs
new file mode 100644
index 0000000..451b32f
--- /dev/null
+++ b/packages/leptos/src/minimize.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Minimize(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3v3a2 2 0 0 1-2 2H3"></path>
+            <path d="M21 8h-3a2 2 0 0 1-2-2V3"></path>
+            <path d="M3 16h3a2 2 0 0 1 2 2v3"></path>
+            <path d="M16 21v-3a2 2 0 0 1 2-2h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/minimize_2.rs b/packages/leptos/src/minimize_2.rs
new file mode 100644
index 0000000..42ecab8
--- /dev/null
+++ b/packages/leptos/src/minimize_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Minimize2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="4 14 10 14 10 20"></polyline>
+            <polyline points="20 10 14 10 14 4"></polyline>
+            <line x1="14" x2="21" y1="10" y2="3"></line>
+            <line x1="3" x2="10" y1="21" y2="14"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/minus.rs b/packages/leptos/src/minus.rs
new file mode 100644
index 0000000..58a15c9
--- /dev/null
+++ b/packages/leptos/src/minus.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Minus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 12h14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor.rs b/packages/leptos/src/monitor.rs
new file mode 100644
index 0000000..bb8d5a3
--- /dev/null
+++ b/packages/leptos/src/monitor.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Monitor(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="14" x="2" y="3" rx="2"></rect>
+            <line x1="8" x2="16" y1="21" y2="21"></line>
+            <line x1="12" x2="12" y1="17" y2="21"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_check.rs b/packages/leptos/src/monitor_check.rs
new file mode 100644
index 0000000..481c338
--- /dev/null
+++ b/packages/leptos/src/monitor_check.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 10 2 2 4-4"></path>
+            <rect width="20" height="14" x="2" y="3" rx="2"></rect>
+            <path d="M12 17v4"></path>
+            <path d="M8 21h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_cog.rs b/packages/leptos/src/monitor_cog.rs
new file mode 100644
index 0000000..cf6b3f8
--- /dev/null
+++ b/packages/leptos/src/monitor_cog.rs
@@ -0,0 +1,46 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17v4"></path>
+            <path d="m15.2 4.9-.9-.4"></path>
+            <path d="m15.2 7.1-.9.4"></path>
+            <path d="m16.9 3.2-.4-.9"></path>
+            <path d="m16.9 8.8-.4.9"></path>
+            <path d="m19.5 2.3-.4.9"></path>
+            <path d="m19.5 9.7-.4-.9"></path>
+            <path d="m21.7 4.5-.9.4"></path>
+            <path d="m21.7 7.5-.9-.4"></path>
+            <path d="M22 13v2a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7"></path>
+            <path d="M8 21h8"></path>
+            <circle cx="18" cy="6" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_dot.rs b/packages/leptos/src/monitor_dot.rs
new file mode 100644
index 0000000..7aa8742
--- /dev/null
+++ b/packages/leptos/src/monitor_dot.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="19" cy="6" r="3"></circle>
+            <path d="M22 12v3a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h9"></path>
+            <path d="M12 17v4"></path>
+            <path d="M8 21h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_down.rs b/packages/leptos/src/monitor_down.rs
new file mode 100644
index 0000000..1917157
--- /dev/null
+++ b/packages/leptos/src/monitor_down.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V7"></path>
+            <path d="m15 10-3 3-3-3"></path>
+            <rect width="20" height="14" x="2" y="3" rx="2"></rect>
+            <path d="M12 17v4"></path>
+            <path d="M8 21h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_off.rs b/packages/leptos/src/monitor_off.rs
new file mode 100644
index 0000000..2b606b5
--- /dev/null
+++ b/packages/leptos/src/monitor_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 17H4a2 2 0 0 1-2-2V5c0-1.5 1-2 1-2"></path>
+            <path d="M22 15V5a2 2 0 0 0-2-2H9"></path>
+            <path d="M8 21h8"></path>
+            <path d="M12 17v4"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_pause.rs b/packages/leptos/src/monitor_pause.rs
new file mode 100644
index 0000000..a55d82b
--- /dev/null
+++ b/packages/leptos/src/monitor_pause.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorPause(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 13V7"></path>
+            <path d="M14 13V7"></path>
+            <rect width="20" height="14" x="2" y="3" rx="2"></rect>
+            <path d="M12 17v4"></path>
+            <path d="M8 21h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_play.rs b/packages/leptos/src/monitor_play.rs
new file mode 100644
index 0000000..3f7fb28
--- /dev/null
+++ b/packages/leptos/src/monitor_play.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorPlay(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 7.75a.75.75 0 0 1 1.142-.638l3.664 2.249a.75.75 0 0 1 0 1.278l-3.664 2.25a.75.75 0 0 1-1.142-.64z"></path>
+            <path d="M12 17v4"></path>
+            <path d="M8 21h8"></path>
+            <rect x="2" y="3" width="20" height="14" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_smartphone.rs b/packages/leptos/src/monitor_smartphone.rs
new file mode 100644
index 0000000..e731ee2
--- /dev/null
+++ b/packages/leptos/src/monitor_smartphone.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorSmartphone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 8V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v7a2 2 0 0 0 2 2h8"></path>
+            <path d="M10 19v-3.96 3.15"></path>
+            <path d="M7 19h5"></path>
+            <rect width="6" height="10" x="16" y="12" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_speaker.rs b/packages/leptos/src/monitor_speaker.rs
new file mode 100644
index 0000000..07de458
--- /dev/null
+++ b/packages/leptos/src/monitor_speaker.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorSpeaker(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5.5 20H8"></path>
+            <path d="M17 9h.01"></path>
+            <rect width="10" height="16" x="12" y="4" rx="2"></rect>
+            <path d="M8 6H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h4"></path>
+            <circle cx="17" cy="15" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_stop.rs b/packages/leptos/src/monitor_stop.rs
new file mode 100644
index 0000000..f975021
--- /dev/null
+++ b/packages/leptos/src/monitor_stop.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorStop(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17v4"></path>
+            <path d="M8 21h8"></path>
+            <rect x="2" y="3" width="20" height="14" rx="2"></rect>
+            <rect x="9" y="7" width="6" height="6" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_up.rs b/packages/leptos/src/monitor_up.rs
new file mode 100644
index 0000000..e53584c
--- /dev/null
+++ b/packages/leptos/src/monitor_up.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 10 3-3 3 3"></path>
+            <path d="M12 13V7"></path>
+            <rect width="20" height="14" x="2" y="3" rx="2"></rect>
+            <path d="M12 17v4"></path>
+            <path d="M8 21h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/monitor_x.rs b/packages/leptos/src/monitor_x.rs
new file mode 100644
index 0000000..e348f1f
--- /dev/null
+++ b/packages/leptos/src/monitor_x.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MonitorX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14.5 12.5-5-5"></path>
+            <path d="m9.5 12.5 5-5"></path>
+            <rect width="20" height="14" x="2" y="3" rx="2"></rect>
+            <path d="M12 17v4"></path>
+            <path d="M8 21h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/moon.rs b/packages/leptos/src/moon.rs
new file mode 100644
index 0000000..1296bb9
--- /dev/null
+++ b/packages/leptos/src/moon.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Moon(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/moon_star.rs b/packages/leptos/src/moon_star.rs
new file mode 100644
index 0000000..54c1a18
--- /dev/null
+++ b/packages/leptos/src/moon_star.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoonStar(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9"></path>
+            <path d="M20 3v4"></path>
+            <path d="M22 5h-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mountain.rs b/packages/leptos/src/mountain.rs
new file mode 100644
index 0000000..5317312
--- /dev/null
+++ b/packages/leptos/src/mountain.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Mountain(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 3 4 8 5-5 5 15H2L8 3z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mountain_snow.rs b/packages/leptos/src/mountain_snow.rs
new file mode 100644
index 0000000..d6cecbc
--- /dev/null
+++ b/packages/leptos/src/mountain_snow.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MountainSnow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 3 4 8 5-5 5 15H2L8 3z"></path>
+            <path d="M4.14 15.08c2.62-1.57 5.24-1.43 7.86.42 2.74 1.94 5.49 2 8.23.19"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mouse.rs b/packages/leptos/src/mouse.rs
new file mode 100644
index 0000000..44eeac8
--- /dev/null
+++ b/packages/leptos/src/mouse.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Mouse(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="5" y="2" width="14" height="20" rx="7"></rect>
+            <path d="M12 6v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mouse_off.rs b/packages/leptos/src/mouse_off.rs
new file mode 100644
index 0000000..58f4a2e
--- /dev/null
+++ b/packages/leptos/src/mouse_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MouseOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v.343"></path>
+            <path d="M18.218 18.218A7 7 0 0 1 5 15V9a7 7 0 0 1 .782-3.218"></path>
+            <path d="M19 13.343V9A7 7 0 0 0 8.56 2.902"></path>
+            <path d="M22 22 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mouse_pointer.rs b/packages/leptos/src/mouse_pointer.rs
new file mode 100644
index 0000000..05aeef0
--- /dev/null
+++ b/packages/leptos/src/mouse_pointer.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MousePointer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.586 12.586 19 19"></path>
+            <path d="M3.688 3.037a.497.497 0 0 0-.651.651l6.5 15.999a.501.501 0 0 0 .947-.062l1.569-6.083a2 2 0 0 1 1.448-1.479l6.124-1.579a.5.5 0 0 0 .063-.947z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mouse_pointer_2.rs b/packages/leptos/src/mouse_pointer_2.rs
new file mode 100644
index 0000000..b5c1906
--- /dev/null
+++ b/packages/leptos/src/mouse_pointer_2.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MousePointer2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.037 4.688a.495.495 0 0 1 .651-.651l16 6.5a.5.5 0 0 1-.063.947l-6.124 1.58a2 2 0 0 0-1.438 1.435l-1.579 6.126a.5.5 0 0 1-.947.063z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mouse_pointer_ban.rs b/packages/leptos/src/mouse_pointer_ban.rs
new file mode 100644
index 0000000..11d2b1b
--- /dev/null
+++ b/packages/leptos/src/mouse_pointer_ban.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MousePointerBan(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.034 2.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.944L8.204 7.545a1 1 0 0 0-.66.66l-1.066 3.443a.5.5 0 0 1-.944.033z"></path>
+            <circle cx="16" cy="16" r="6"></circle>
+            <path d="m11.8 11.8 8.4 8.4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/mouse_pointer_click.rs b/packages/leptos/src/mouse_pointer_click.rs
new file mode 100644
index 0000000..d6229a2
--- /dev/null
+++ b/packages/leptos/src/mouse_pointer_click.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MousePointerClick(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 4.1 12 6"></path>
+            <path d="m5.1 8-2.9-.8"></path>
+            <path d="m6 12-1.9 2"></path>
+            <path d="M7.2 2.2 8 5.1"></path>
+            <path d="M9.037 9.69a.498.498 0 0 1 .653-.653l11 4.5a.5.5 0 0 1-.074.949l-4.349 1.041a1 1 0 0 0-.74.739l-1.04 4.35a.5.5 0 0 1-.95.074z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move.rs b/packages/leptos/src/move.rs
new file mode 100644
index 0000000..3f1dce4
--- /dev/null
+++ b/packages/leptos/src/move.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Move(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v20"></path>
+            <path d="m15 19-3 3-3-3"></path>
+            <path d="m19 9 3 3-3 3"></path>
+            <path d="M2 12h20"></path>
+            <path d="m5 9-3 3 3 3"></path>
+            <path d="m9 5 3-3 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_3_d.rs b/packages/leptos/src/move_3_d.rs
new file mode 100644
index 0000000..abffee6
--- /dev/null
+++ b/packages/leptos/src/move_3_d.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Move3D(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 3v16h16"></path>
+            <path d="m5 19 6-6"></path>
+            <path d="m2 6 3-3 3 3"></path>
+            <path d="m18 16 3 3-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_diagonal.rs b/packages/leptos/src/move_diagonal.rs
new file mode 100644
index 0000000..882d261
--- /dev/null
+++ b/packages/leptos/src/move_diagonal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveDiagonal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 19H5v-6"></path>
+            <path d="M13 5h6v6"></path>
+            <path d="M19 5 5 19"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_diagonal_2.rs b/packages/leptos/src/move_diagonal_2.rs
new file mode 100644
index 0000000..c234594
--- /dev/null
+++ b/packages/leptos/src/move_diagonal_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveDiagonal2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 13v6h-6"></path>
+            <path d="M5 11V5h6"></path>
+            <path d="m5 5 14 14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_down.rs b/packages/leptos/src/move_down.rs
new file mode 100644
index 0000000..ab45751
--- /dev/null
+++ b/packages/leptos/src/move_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 18L12 22L16 18"></path>
+            <path d="M12 2V22"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_down_left.rs b/packages/leptos/src/move_down_left.rs
new file mode 100644
index 0000000..d07968b
--- /dev/null
+++ b/packages/leptos/src/move_down_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveDownLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 19H5V13"></path>
+            <path d="M19 5L5 19"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_down_right.rs b/packages/leptos/src/move_down_right.rs
new file mode 100644
index 0000000..7ff80c5
--- /dev/null
+++ b/packages/leptos/src/move_down_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveDownRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 13V19H13"></path>
+            <path d="M5 5L19 19"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_horizontal.rs b/packages/leptos/src/move_horizontal.rs
new file mode 100644
index 0000000..0a0fbfd
--- /dev/null
+++ b/packages/leptos/src/move_horizontal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 8 4 4-4 4"></path>
+            <path d="M2 12h20"></path>
+            <path d="m6 8-4 4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_left.rs b/packages/leptos/src/move_left.rs
new file mode 100644
index 0000000..0bdfc22
--- /dev/null
+++ b/packages/leptos/src/move_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8L2 12L6 16"></path>
+            <path d="M2 12H22"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_right.rs b/packages/leptos/src/move_right.rs
new file mode 100644
index 0000000..cc50e1c
--- /dev/null
+++ b/packages/leptos/src/move_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 8L22 12L18 16"></path>
+            <path d="M2 12H22"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_up.rs b/packages/leptos/src/move_up.rs
new file mode 100644
index 0000000..c04d85d
--- /dev/null
+++ b/packages/leptos/src/move_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 6L12 2L16 6"></path>
+            <path d="M12 2V22"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_up_left.rs b/packages/leptos/src/move_up_left.rs
new file mode 100644
index 0000000..b4830c7
--- /dev/null
+++ b/packages/leptos/src/move_up_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveUpLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 11V5H11"></path>
+            <path d="M5 5L19 19"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_up_right.rs b/packages/leptos/src/move_up_right.rs
new file mode 100644
index 0000000..84d59cd
--- /dev/null
+++ b/packages/leptos/src/move_up_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveUpRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 5H19V11"></path>
+            <path d="M19 5L5 19"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/move_vertical.rs b/packages/leptos/src/move_vertical.rs
new file mode 100644
index 0000000..0718c9d
--- /dev/null
+++ b/packages/leptos/src/move_vertical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn MoveVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v20"></path>
+            <path d="m8 18 4 4 4-4"></path>
+            <path d="m8 6 4-4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/music.rs b/packages/leptos/src/music.rs
new file mode 100644
index 0000000..97404d5
--- /dev/null
+++ b/packages/leptos/src/music.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Music(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 18V5l12-2v13"></path>
+            <circle cx="6" cy="18" r="3"></circle>
+            <circle cx="18" cy="16" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/music_2.rs b/packages/leptos/src/music_2.rs
new file mode 100644
index 0000000..df86790
--- /dev/null
+++ b/packages/leptos/src/music_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Music2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="8" cy="18" r="4"></circle>
+            <path d="M12 18V2l7 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/music_3.rs b/packages/leptos/src/music_3.rs
new file mode 100644
index 0000000..c32e845
--- /dev/null
+++ b/packages/leptos/src/music_3.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Music3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="18" r="4"></circle>
+            <path d="M16 18V2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/music_4.rs b/packages/leptos/src/music_4.rs
new file mode 100644
index 0000000..8a1dc69
--- /dev/null
+++ b/packages/leptos/src/music_4.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Music4(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 18V5l12-2v13"></path>
+            <path d="m9 9 12-2"></path>
+            <circle cx="6" cy="18" r="3"></circle>
+            <circle cx="18" cy="16" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/navigation.rs b/packages/leptos/src/navigation.rs
new file mode 100644
index 0000000..1b6cd70
--- /dev/null
+++ b/packages/leptos/src/navigation.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Navigation(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="3 11 22 2 13 21 11 13 3 11"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/navigation_2.rs b/packages/leptos/src/navigation_2.rs
new file mode 100644
index 0000000..54603fd
--- /dev/null
+++ b/packages/leptos/src/navigation_2.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Navigation2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="12 2 19 21 12 17 5 21 12 2"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/navigation_2_off.rs b/packages/leptos/src/navigation_2_off.rs
new file mode 100644
index 0000000..b28242b
--- /dev/null
+++ b/packages/leptos/src/navigation_2_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Navigation2Off(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9.31 9.31 5 21l7-4 7 4-1.17-3.17"></path>
+            <path d="M14.53 8.88 12 2l-1.17 3.17"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/navigation_off.rs b/packages/leptos/src/navigation_off.rs
new file mode 100644
index 0000000..488276f
--- /dev/null
+++ b/packages/leptos/src/navigation_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn NavigationOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.43 8.43 3 11l8 2 2 8 2.57-5.43"></path>
+            <path d="M17.39 11.73 22 2l-9.73 4.61"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/network.rs b/packages/leptos/src/network.rs
new file mode 100644
index 0000000..e1d1d1d
--- /dev/null
+++ b/packages/leptos/src/network.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Network(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="16" y="16" width="6" height="6" rx="1"></rect>
+            <rect x="2" y="16" width="6" height="6" rx="1"></rect>
+            <rect x="9" y="2" width="6" height="6" rx="1"></rect>
+            <path d="M5 16v-3a1 1 0 0 1 1-1h12a1 1 0 0 1 1 1v3"></path>
+            <path d="M12 12V8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/newspaper.rs b/packages/leptos/src/newspaper.rs
new file mode 100644
index 0000000..512d56a
--- /dev/null
+++ b/packages/leptos/src/newspaper.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Newspaper(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h16a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v16a2 2 0 0 1-2 2Zm0 0a2 2 0 0 1-2-2v-9c0-1.1.9-2 2-2h2"></path>
+            <path d="M18 14h-8"></path>
+            <path d="M15 18h-5"></path>
+            <path d="M10 6h8v4h-8V6Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/nfc.rs b/packages/leptos/src/nfc.rs
new file mode 100644
index 0000000..948f792
--- /dev/null
+++ b/packages/leptos/src/nfc.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Nfc(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8.32a7.43 7.43 0 0 1 0 7.36"></path>
+            <path d="M9.46 6.21a11.76 11.76 0 0 1 0 11.58"></path>
+            <path d="M12.91 4.1a15.91 15.91 0 0 1 .01 15.8"></path>
+            <path d="M16.37 2a20.16 20.16 0 0 1 0 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/notebook.rs b/packages/leptos/src/notebook.rs
new file mode 100644
index 0000000..025be9e
--- /dev/null
+++ b/packages/leptos/src/notebook.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Notebook(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 6h4"></path>
+            <path d="M2 10h4"></path>
+            <path d="M2 14h4"></path>
+            <path d="M2 18h4"></path>
+            <rect width="16" height="20" x="4" y="2" rx="2"></rect>
+            <path d="M16 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/notebook_pen.rs b/packages/leptos/src/notebook_pen.rs
new file mode 100644
index 0000000..30fb888
--- /dev/null
+++ b/packages/leptos/src/notebook_pen.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn NotebookPen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.4 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-7.4"></path>
+            <path d="M2 6h4"></path>
+            <path d="M2 10h4"></path>
+            <path d="M2 14h4"></path>
+            <path d="M2 18h4"></path>
+            <path d="M21.378 5.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/notebook_tabs.rs b/packages/leptos/src/notebook_tabs.rs
new file mode 100644
index 0000000..87987b7
--- /dev/null
+++ b/packages/leptos/src/notebook_tabs.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn NotebookTabs(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 6h4"></path>
+            <path d="M2 10h4"></path>
+            <path d="M2 14h4"></path>
+            <path d="M2 18h4"></path>
+            <rect width="16" height="20" x="4" y="2" rx="2"></rect>
+            <path d="M15 2v20"></path>
+            <path d="M15 7h5"></path>
+            <path d="M15 12h5"></path>
+            <path d="M15 17h5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/notebook_text.rs b/packages/leptos/src/notebook_text.rs
new file mode 100644
index 0000000..e9d187d
--- /dev/null
+++ b/packages/leptos/src/notebook_text.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn NotebookText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 6h4"></path>
+            <path d="M2 10h4"></path>
+            <path d="M2 14h4"></path>
+            <path d="M2 18h4"></path>
+            <rect width="16" height="20" x="4" y="2" rx="2"></rect>
+            <path d="M9.5 8h5"></path>
+            <path d="M9.5 12H16"></path>
+            <path d="M9.5 16H14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/notepad_text.rs b/packages/leptos/src/notepad_text.rs
new file mode 100644
index 0000000..3d8e62a
--- /dev/null
+++ b/packages/leptos/src/notepad_text.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn NotepadText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M12 2v4"></path>
+            <path d="M16 2v4"></path>
+            <rect width="16" height="18" x="4" y="4" rx="2"></rect>
+            <path d="M8 10h6"></path>
+            <path d="M8 14h8"></path>
+            <path d="M8 18h5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/notepad_text_dashed.rs b/packages/leptos/src/notepad_text_dashed.rs
new file mode 100644
index 0000000..47a9f71
--- /dev/null
+++ b/packages/leptos/src/notepad_text_dashed.rs
@@ -0,0 +1,47 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn NotepadTextDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4"></path>
+            <path d="M12 2v4"></path>
+            <path d="M16 2v4"></path>
+            <path d="M16 4h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M20 12v2"></path>
+            <path d="M20 18v2a2 2 0 0 1-2 2h-1"></path>
+            <path d="M13 22h-2"></path>
+            <path d="M7 22H6a2 2 0 0 1-2-2v-2"></path>
+            <path d="M4 14v-2"></path>
+            <path d="M4 8V6a2 2 0 0 1 2-2h2"></path>
+            <path d="M8 10h6"></path>
+            <path d="M8 14h8"></path>
+            <path d="M8 18h5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/nut.rs b/packages/leptos/src/nut.rs
new file mode 100644
index 0000000..d2ee0e3
--- /dev/null
+++ b/packages/leptos/src/nut.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Nut(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 4V2"></path>
+            <path d="M5 10v4a7.004 7.004 0 0 0 5.277 6.787c.412.104.802.292 1.102.592L12 22l.621-.621c.3-.3.69-.488 1.102-.592A7.003 7.003 0 0 0 19 14v-4"></path>
+            <path d="M12 4C8 4 4.5 6 4 8c-.243.97-.919 1.952-2 3 1.31-.082 1.972-.29 3-1 .54.92.982 1.356 2 2 1.452-.647 1.954-1.098 2.5-2 .595.995 1.151 1.427 2.5 2 1.31-.621 1.862-1.058 2.5-2 .629.977 1.162 1.423 2.5 2 1.209-.548 1.68-.967 2-2 1.032.916 1.683 1.157 3 1-1.297-1.036-1.758-2.03-2-3-.5-2-4-4-8-4Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/nut_off.rs b/packages/leptos/src/nut_off.rs
new file mode 100644
index 0000000..6f0463c
--- /dev/null
+++ b/packages/leptos/src/nut_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn NutOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 4V2"></path>
+            <path d="M5 10v4a7.004 7.004 0 0 0 5.277 6.787c.412.104.802.292 1.102.592L12 22l.621-.621c.3-.3.69-.488 1.102-.592a7.01 7.01 0 0 0 4.125-2.939"></path>
+            <path d="M19 10v3.343"></path>
+            <path d="M12 12c-1.349-.573-1.905-1.005-2.5-2-.546.902-1.048 1.353-2.5 2-1.018-.644-1.46-1.08-2-2-1.028.71-1.69.918-3 1 1.081-1.048 1.757-2.03 2-3 .194-.776.84-1.551 1.79-2.21m11.654 5.997c.887-.457 1.28-.891 1.556-1.787 1.032.916 1.683 1.157 3 1-1.297-1.036-1.758-2.03-2-3-.5-2-4-4-8-4-.74 0-1.461.068-2.15.192"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/octagon.rs b/packages/leptos/src/octagon.rs
new file mode 100644
index 0000000..2f720f0
--- /dev/null
+++ b/packages/leptos/src/octagon.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Octagon(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/octagon_alert.rs b/packages/leptos/src/octagon_alert.rs
new file mode 100644
index 0000000..c1d5884
--- /dev/null
+++ b/packages/leptos/src/octagon_alert.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn OctagonAlert(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 16h.01"></path>
+            <path d="M12 8v4"></path>
+            <path d="M15.312 2a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586l-4.688-4.688A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/octagon_minus.rs b/packages/leptos/src/octagon_minus.rs
new file mode 100644
index 0000000..551f38d
--- /dev/null
+++ b/packages/leptos/src/octagon_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn OctagonMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"></path>
+            <path d="M8 12h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/octagon_pause.rs b/packages/leptos/src/octagon_pause.rs
new file mode 100644
index 0000000..1d0c8ff
--- /dev/null
+++ b/packages/leptos/src/octagon_pause.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn OctagonPause(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 15V9"></path>
+            <path d="M14 15V9"></path>
+            <path d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/octagon_x.rs b/packages/leptos/src/octagon_x.rs
new file mode 100644
index 0000000..da58668
--- /dev/null
+++ b/packages/leptos/src/octagon_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn OctagonX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 9-6 6"></path>
+            <path d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"></path>
+            <path d="m9 9 6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/omega.rs b/packages/leptos/src/omega.rs
new file mode 100644
index 0000000..c2f5f90
--- /dev/null
+++ b/packages/leptos/src/omega.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Omega(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 20h4.5a.5.5 0 0 0 .5-.5v-.282a.52.52 0 0 0-.247-.437 8 8 0 1 1 8.494-.001.52.52 0 0 0-.247.438v.282a.5.5 0 0 0 .5.5H21"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/option.rs b/packages/leptos/src/option.rs
new file mode 100644
index 0000000..c0718c6
--- /dev/null
+++ b/packages/leptos/src/option.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Option(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3h6l6 18h6"></path>
+            <path d="M14 3h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/orbit.rs b/packages/leptos/src/orbit.rs
new file mode 100644
index 0000000..edf1efa
--- /dev/null
+++ b/packages/leptos/src/orbit.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Orbit(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3"></circle>
+            <circle cx="19" cy="5" r="2"></circle>
+            <circle cx="5" cy="19" r="2"></circle>
+            <path d="M10.4 21.9a10 10 0 0 0 9.941-15.416"></path>
+            <path d="M13.5 2.1a10 10 0 0 0-9.841 15.416"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/origami.rs b/packages/leptos/src/origami.rs
new file mode 100644
index 0000000..2054527
--- /dev/null
+++ b/packages/leptos/src/origami.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Origami(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12V4a1 1 0 0 1 1-1h6.297a1 1 0 0 1 .651 1.759l-4.696 4.025"></path>
+            <path d="m12 21-7.414-7.414A2 2 0 0 1 4 12.172V6.415a1.002 1.002 0 0 1 1.707-.707L20 20.009"></path>
+            <path d="m12.214 3.381 8.414 14.966a1 1 0 0 1-.167 1.199l-1.168 1.163a1 1 0 0 1-.706.291H6.351a1 1 0 0 1-.625-.219L3.25 18.8a1 1 0 0 1 .631-1.781l4.165.027"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/package.rs b/packages/leptos/src/package.rs
new file mode 100644
index 0000000..8b33d9a
--- /dev/null
+++ b/packages/leptos/src/package.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Package(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 21.73a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73z"></path>
+            <path d="M12 22V12"></path>
+            <path d="m3.3 7 7.703 4.734a2 2 0 0 0 1.994 0L20.7 7"></path>
+            <path d="m7.5 4.27 9 5.15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/package_2.rs b/packages/leptos/src/package_2.rs
new file mode 100644
index 0000000..1fc5ebc
--- /dev/null
+++ b/packages/leptos/src/package_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Package2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 9h18v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V9Z"></path>
+            <path d="m3 9 2.45-4.9A2 2 0 0 1 7.24 3h9.52a2 2 0 0 1 1.8 1.1L21 9"></path>
+            <path d="M12 3v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/package_check.rs b/packages/leptos/src/package_check.rs
new file mode 100644
index 0000000..a2619d6
--- /dev/null
+++ b/packages/leptos/src/package_check.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PackageCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 16 2 2 4-4"></path>
+            <path d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"></path>
+            <path d="m7.5 4.27 9 5.15"></path>
+            <polyline points="3.29 7 12 12 20.71 7"></polyline>
+            <line x1="12" x2="12" y1="22" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/package_minus.rs b/packages/leptos/src/package_minus.rs
new file mode 100644
index 0000000..49e67f3
--- /dev/null
+++ b/packages/leptos/src/package_minus.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PackageMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 16h6"></path>
+            <path d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"></path>
+            <path d="m7.5 4.27 9 5.15"></path>
+            <polyline points="3.29 7 12 12 20.71 7"></polyline>
+            <line x1="12" x2="12" y1="22" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/package_open.rs b/packages/leptos/src/package_open.rs
new file mode 100644
index 0000000..2d97dc5
--- /dev/null
+++ b/packages/leptos/src/package_open.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PackageOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-9"></path>
+            <path d="M15.17 2.21a1.67 1.67 0 0 1 1.63 0L21 4.57a1.93 1.93 0 0 1 0 3.36L8.82 14.79a1.655 1.655 0 0 1-1.64 0L3 12.43a1.93 1.93 0 0 1 0-3.36z"></path>
+            <path d="M20 13v3.87a2.06 2.06 0 0 1-1.11 1.83l-6 3.08a1.93 1.93 0 0 1-1.78 0l-6-3.08A2.06 2.06 0 0 1 4 16.87V13"></path>
+            <path d="M21 12.43a1.93 1.93 0 0 0 0-3.36L8.83 2.2a1.64 1.64 0 0 0-1.63 0L3 4.57a1.93 1.93 0 0 0 0 3.36l12.18 6.86a1.636 1.636 0 0 0 1.63 0z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/package_plus.rs b/packages/leptos/src/package_plus.rs
new file mode 100644
index 0000000..a3b6fbc
--- /dev/null
+++ b/packages/leptos/src/package_plus.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PackagePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 16h6"></path>
+            <path d="M19 13v6"></path>
+            <path d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"></path>
+            <path d="m7.5 4.27 9 5.15"></path>
+            <polyline points="3.29 7 12 12 20.71 7"></polyline>
+            <line x1="12" x2="12" y1="22" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/package_search.rs b/packages/leptos/src/package_search.rs
new file mode 100644
index 0000000..7d7f6ef
--- /dev/null
+++ b/packages/leptos/src/package_search.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PackageSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"></path>
+            <path d="m7.5 4.27 9 5.15"></path>
+            <polyline points="3.29 7 12 12 20.71 7"></polyline>
+            <line x1="12" x2="12" y1="22" y2="12"></line>
+            <circle cx="18.5" cy="15.5" r="2.5"></circle>
+            <path d="M20.27 17.27 22 19"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/package_x.rs b/packages/leptos/src/package_x.rs
new file mode 100644
index 0000000..da34f65
--- /dev/null
+++ b/packages/leptos/src/package_x.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PackageX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"></path>
+            <path d="m7.5 4.27 9 5.15"></path>
+            <polyline points="3.29 7 12 12 20.71 7"></polyline>
+            <line x1="12" x2="12" y1="22" y2="12"></line>
+            <path d="m17 13 5 5m-5 0 5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/paint_bucket.rs b/packages/leptos/src/paint_bucket.rs
new file mode 100644
index 0000000..b5a92cc
--- /dev/null
+++ b/packages/leptos/src/paint_bucket.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PaintBucket(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 11-8-8-8.6 8.6a2 2 0 0 0 0 2.8l5.2 5.2c.8.8 2 .8 2.8 0L19 11Z"></path>
+            <path d="m5 2 5 5"></path>
+            <path d="M2 13h15"></path>
+            <path d="M22 20a2 2 0 1 1-4 0c0-1.6 1.7-2.4 2-4 .3 1.6 2 2.4 2 4Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/paint_roller.rs b/packages/leptos/src/paint_roller.rs
new file mode 100644
index 0000000..9e010db
--- /dev/null
+++ b/packages/leptos/src/paint_roller.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PaintRoller(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="6" x="2" y="2" rx="2"></rect>
+            <path d="M10 16v-2a2 2 0 0 1 2-2h8a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2"></path>
+            <rect width="4" height="6" x="8" y="16" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/paintbrush.rs b/packages/leptos/src/paintbrush.rs
new file mode 100644
index 0000000..f73878e
--- /dev/null
+++ b/packages/leptos/src/paintbrush.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Paintbrush(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14.622 17.897-10.68-2.913"></path>
+            <path d="M18.376 2.622a1 1 0 1 1 3.002 3.002L17.36 9.643a.5.5 0 0 0 0 .707l.944.944a2.41 2.41 0 0 1 0 3.408l-.944.944a.5.5 0 0 1-.707 0L8.354 7.348a.5.5 0 0 1 0-.707l.944-.944a2.41 2.41 0 0 1 3.408 0l.944.944a.5.5 0 0 0 .707 0z"></path>
+            <path d="M9 8c-1.804 2.71-3.97 3.46-6.583 3.948a.507.507 0 0 0-.302.819l7.32 8.883a1 1 0 0 0 1.185.204C12.735 20.405 16 16.792 16 15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/paintbrush_vertical.rs b/packages/leptos/src/paintbrush_vertical.rs
new file mode 100644
index 0000000..6bf4fcd
--- /dev/null
+++ b/packages/leptos/src/paintbrush_vertical.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PaintbrushVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v2"></path>
+            <path d="M14 2v4"></path>
+            <path d="M17 2a1 1 0 0 1 1 1v9H6V3a1 1 0 0 1 1-1z"></path>
+            <path d="M6 12a1 1 0 0 0-1 1v1a2 2 0 0 0 2 2h2a1 1 0 0 1 1 1v2.9a2 2 0 1 0 4 0V17a1 1 0 0 1 1-1h2a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/palette.rs b/packages/leptos/src/palette.rs
new file mode 100644
index 0000000..d162d87
--- /dev/null
+++ b/packages/leptos/src/palette.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Palette(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="13.5" cy="6.5" r=".5" fill="currentColor"></circle>
+            <circle cx="17.5" cy="10.5" r=".5" fill="currentColor"></circle>
+            <circle cx="8.5" cy="7.5" r=".5" fill="currentColor"></circle>
+            <circle cx="6.5" cy="12.5" r=".5" fill="currentColor"></circle>
+            <path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10c.926 0 1.648-.746 1.648-1.688 0-.437-.18-.835-.437-1.125-.29-.289-.438-.652-.438-1.125a1.64 1.64 0 0 1 1.668-1.668h1.996c3.051 0 5.555-2.503 5.555-5.554C21.965 6.012 17.461 2 12 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_bottom.rs b/packages/leptos/src/panel_bottom.rs
new file mode 100644
index 0000000..d5e6e26
--- /dev/null
+++ b/packages/leptos/src/panel_bottom.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelBottom(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 15h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_bottom_close.rs b/packages/leptos/src/panel_bottom_close.rs
new file mode 100644
index 0000000..e6539b8
--- /dev/null
+++ b/packages/leptos/src/panel_bottom_close.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelBottomClose(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 15h18"></path>
+            <path d="m15 8-3 3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_bottom_dashed.rs b/packages/leptos/src/panel_bottom_dashed.rs
new file mode 100644
index 0000000..ce27868
--- /dev/null
+++ b/packages/leptos/src/panel_bottom_dashed.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelBottomDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M14 15h1"></path>
+            <path d="M19 15h2"></path>
+            <path d="M3 15h2"></path>
+            <path d="M9 15h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_bottom_open.rs b/packages/leptos/src/panel_bottom_open.rs
new file mode 100644
index 0000000..bff62a3
--- /dev/null
+++ b/packages/leptos/src/panel_bottom_open.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelBottomOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 15h18"></path>
+            <path d="m9 10 3-3 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_left.rs b/packages/leptos/src/panel_left.rs
new file mode 100644
index 0000000..a8a52fe
--- /dev/null
+++ b/packages/leptos/src/panel_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M9 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_left_close.rs b/packages/leptos/src/panel_left_close.rs
new file mode 100644
index 0000000..e7e7296
--- /dev/null
+++ b/packages/leptos/src/panel_left_close.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelLeftClose(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M9 3v18"></path>
+            <path d="m16 15-3-3 3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_left_dashed.rs b/packages/leptos/src/panel_left_dashed.rs
new file mode 100644
index 0000000..6123c84
--- /dev/null
+++ b/packages/leptos/src/panel_left_dashed.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelLeftDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M9 14v1"></path>
+            <path d="M9 19v2"></path>
+            <path d="M9 3v2"></path>
+            <path d="M9 9v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_left_open.rs b/packages/leptos/src/panel_left_open.rs
new file mode 100644
index 0000000..9b207d6
--- /dev/null
+++ b/packages/leptos/src/panel_left_open.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelLeftOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M9 3v18"></path>
+            <path d="m14 9 3 3-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_right.rs b/packages/leptos/src/panel_right.rs
new file mode 100644
index 0000000..2478650
--- /dev/null
+++ b/packages/leptos/src/panel_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M15 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_right_close.rs b/packages/leptos/src/panel_right_close.rs
new file mode 100644
index 0000000..8a9281f
--- /dev/null
+++ b/packages/leptos/src/panel_right_close.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelRightClose(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M15 3v18"></path>
+            <path d="m8 9 3 3-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_right_dashed.rs b/packages/leptos/src/panel_right_dashed.rs
new file mode 100644
index 0000000..68cc8dd
--- /dev/null
+++ b/packages/leptos/src/panel_right_dashed.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelRightDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M15 14v1"></path>
+            <path d="M15 19v2"></path>
+            <path d="M15 3v2"></path>
+            <path d="M15 9v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_right_open.rs b/packages/leptos/src/panel_right_open.rs
new file mode 100644
index 0000000..253a26c
--- /dev/null
+++ b/packages/leptos/src/panel_right_open.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelRightOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M15 3v18"></path>
+            <path d="m10 15-3-3 3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_top.rs b/packages/leptos/src/panel_top.rs
new file mode 100644
index 0000000..fb5b077
--- /dev/null
+++ b/packages/leptos/src/panel_top.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelTop(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 9h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_top_close.rs b/packages/leptos/src/panel_top_close.rs
new file mode 100644
index 0000000..c90c98d
--- /dev/null
+++ b/packages/leptos/src/panel_top_close.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelTopClose(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 9h18"></path>
+            <path d="m9 16 3-3 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_top_dashed.rs b/packages/leptos/src/panel_top_dashed.rs
new file mode 100644
index 0000000..d133179
--- /dev/null
+++ b/packages/leptos/src/panel_top_dashed.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelTopDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M14 9h1"></path>
+            <path d="M19 9h2"></path>
+            <path d="M3 9h2"></path>
+            <path d="M9 9h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panel_top_open.rs b/packages/leptos/src/panel_top_open.rs
new file mode 100644
index 0000000..8e24850
--- /dev/null
+++ b/packages/leptos/src/panel_top_open.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelTopOpen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 9h18"></path>
+            <path d="m15 14-3 3-3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panels_left_bottom.rs b/packages/leptos/src/panels_left_bottom.rs
new file mode 100644
index 0000000..8484cdc
--- /dev/null
+++ b/packages/leptos/src/panels_left_bottom.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelsLeftBottom(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M9 3v18"></path>
+            <path d="M9 15h12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panels_right_bottom.rs b/packages/leptos/src/panels_right_bottom.rs
new file mode 100644
index 0000000..d5fb00e
--- /dev/null
+++ b/packages/leptos/src/panels_right_bottom.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelsRightBottom(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 15h12"></path>
+            <path d="M15 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/panels_top_left.rs b/packages/leptos/src/panels_top_left.rs
new file mode 100644
index 0000000..4ab984f
--- /dev/null
+++ b/packages/leptos/src/panels_top_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PanelsTopLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 9h18"></path>
+            <path d="M9 21V9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/paperclip.rs b/packages/leptos/src/paperclip.rs
new file mode 100644
index 0000000..4a17bde
--- /dev/null
+++ b/packages/leptos/src/paperclip.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Paperclip(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21.44 11.05-9.19 9.19a6 6 0 0 1-8.49-8.49l8.57-8.57A4 4 0 1 1 18 8.84l-8.59 8.57a2 2 0 0 1-2.83-2.83l8.49-8.48"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/parentheses.rs b/packages/leptos/src/parentheses.rs
new file mode 100644
index 0000000..f419101
--- /dev/null
+++ b/packages/leptos/src/parentheses.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Parentheses(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 21s-4-3-4-9 4-9 4-9"></path>
+            <path d="M16 3s4 3 4 9-4 9-4 9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/parking_meter.rs b/packages/leptos/src/parking_meter.rs
new file mode 100644
index 0000000..2c0a25f
--- /dev/null
+++ b/packages/leptos/src/parking_meter.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ParkingMeter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 15h2"></path>
+            <path d="M12 12v3"></path>
+            <path d="M12 19v3"></path>
+            <path d="M15.282 19a1 1 0 0 0 .948-.68l2.37-6.988a7 7 0 1 0-13.2 0l2.37 6.988a1 1 0 0 0 .948.68z"></path>
+            <path d="M9 9a3 3 0 1 1 6 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/party_popper.rs b/packages/leptos/src/party_popper.rs
new file mode 100644
index 0000000..0927e13
--- /dev/null
+++ b/packages/leptos/src/party_popper.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PartyPopper(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5.8 11.3 2 22l10.7-3.79"></path>
+            <path d="M4 3h.01"></path>
+            <path d="M22 8h.01"></path>
+            <path d="M15 2h.01"></path>
+            <path d="M22 20h.01"></path>
+            <path d="m22 2-2.24.75a2.9 2.9 0 0 0-1.96 3.12c.1.86-.57 1.63-1.45 1.63h-.38c-.86 0-1.6.6-1.76 1.44L14 10"></path>
+            <path d="m22 13-.82-.33c-.86-.34-1.82.2-1.98 1.11c-.11.7-.72 1.22-1.43 1.22H17"></path>
+            <path d="m11 2 .33.82c.34.86-.2 1.82-1.11 1.98C9.52 4.9 9 5.52 9 6.23V7"></path>
+            <path d="M11 13c1.93 1.93 2.83 4.17 2 5-.83.83-3.07-.07-5-2-1.93-1.93-2.83-4.17-2-5 .83-.83 3.07.07 5 2Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pause.rs b/packages/leptos/src/pause.rs
new file mode 100644
index 0000000..41155da
--- /dev/null
+++ b/packages/leptos/src/pause.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pause(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="14" y="4" width="4" height="16" rx="1"></rect>
+            <rect x="6" y="4" width="4" height="16" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/paw_print.rs b/packages/leptos/src/paw_print.rs
new file mode 100644
index 0000000..e7fcc47
--- /dev/null
+++ b/packages/leptos/src/paw_print.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PawPrint(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="4" r="2"></circle>
+            <circle cx="18" cy="8" r="2"></circle>
+            <circle cx="20" cy="16" r="2"></circle>
+            <path d="M9 10a5 5 0 0 1 5 5v3.5a3.5 3.5 0 0 1-6.84 1.045Q6.52 17.48 4.46 16.84A3.5 3.5 0 0 1 5.5 10Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pc_case.rs b/packages/leptos/src/pc_case.rs
new file mode 100644
index 0000000..00b1cac
--- /dev/null
+++ b/packages/leptos/src/pc_case.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PcCase(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="20" x="5" y="2" rx="2"></rect>
+            <path d="M15 14h.01"></path>
+            <path d="M9 6h6"></path>
+            <path d="M9 10h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pen.rs b/packages/leptos/src/pen.rs
new file mode 100644
index 0000000..e050ee9
--- /dev/null
+++ b/packages/leptos/src/pen.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pen_line.rs b/packages/leptos/src/pen_line.rs
new file mode 100644
index 0000000..33dee33
--- /dev/null
+++ b/packages/leptos/src/pen_line.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PenLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h9"></path>
+            <path d="M16.376 3.622a1 1 0 0 1 3.002 3.002L7.368 18.635a2 2 0 0 1-.855.506l-2.872.838a.5.5 0 0 1-.62-.62l.838-2.872a2 2 0 0 1 .506-.854z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pen_off.rs b/packages/leptos/src/pen_off.rs
new file mode 100644
index 0000000..051ff05
--- /dev/null
+++ b/packages/leptos/src/pen_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PenOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10 10-6.157 6.162a2 2 0 0 0-.5.833l-1.322 4.36a.5.5 0 0 0 .622.624l4.358-1.323a2 2 0 0 0 .83-.5L14 13.982"></path>
+            <path d="m12.829 7.172 4.359-4.346a1 1 0 1 1 3.986 3.986l-4.353 4.353"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pen_tool.rs b/packages/leptos/src/pen_tool.rs
new file mode 100644
index 0000000..751e617
--- /dev/null
+++ b/packages/leptos/src/pen_tool.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PenTool(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.707 21.293a1 1 0 0 1-1.414 0l-1.586-1.586a1 1 0 0 1 0-1.414l5.586-5.586a1 1 0 0 1 1.414 0l1.586 1.586a1 1 0 0 1 0 1.414z"></path>
+            <path d="m18 13-1.375-6.874a1 1 0 0 0-.746-.776L3.235 2.028a1 1 0 0 0-1.207 1.207L5.35 15.879a1 1 0 0 0 .776.746L13 18"></path>
+            <path d="m2.3 2.3 7.286 7.286"></path>
+            <circle cx="11" cy="11" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pencil.rs b/packages/leptos/src/pencil.rs
new file mode 100644
index 0000000..1ccff7e
--- /dev/null
+++ b/packages/leptos/src/pencil.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pencil(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"></path>
+            <path d="m15 5 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pencil_line.rs b/packages/leptos/src/pencil_line.rs
new file mode 100644
index 0000000..a01f55c
--- /dev/null
+++ b/packages/leptos/src/pencil_line.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PencilLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h9"></path>
+            <path d="M16.376 3.622a1 1 0 0 1 3.002 3.002L7.368 18.635a2 2 0 0 1-.855.506l-2.872.838a.5.5 0 0 1-.62-.62l.838-2.872a2 2 0 0 1 .506-.854z"></path>
+            <path d="m15 5 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pencil_off.rs b/packages/leptos/src/pencil_off.rs
new file mode 100644
index 0000000..1a73a7b
--- /dev/null
+++ b/packages/leptos/src/pencil_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PencilOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10 10-6.157 6.162a2 2 0 0 0-.5.833l-1.322 4.36a.5.5 0 0 0 .622.624l4.358-1.323a2 2 0 0 0 .83-.5L14 13.982"></path>
+            <path d="m12.829 7.172 4.359-4.346a1 1 0 1 1 3.986 3.986l-4.353 4.353"></path>
+            <path d="m15 5 4 4"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pencil_ruler.rs b/packages/leptos/src/pencil_ruler.rs
new file mode 100644
index 0000000..206e4d7
--- /dev/null
+++ b/packages/leptos/src/pencil_ruler.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PencilRuler(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 7 8.7 2.7a2.41 2.41 0 0 0-3.4 0L2.7 5.3a2.41 2.41 0 0 0 0 3.4L7 13"></path>
+            <path d="m8 6 2-2"></path>
+            <path d="m18 16 2-2"></path>
+            <path d="m17 11 4.3 4.3c.94.94.94 2.46 0 3.4l-2.6 2.6c-.94.94-2.46.94-3.4 0L11 17"></path>
+            <path d="M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"></path>
+            <path d="m15 5 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pentagon.rs b/packages/leptos/src/pentagon.rs
new file mode 100644
index 0000000..abade1d
--- /dev/null
+++ b/packages/leptos/src/pentagon.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pentagon(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.83 2.38a2 2 0 0 1 2.34 0l8 5.74a2 2 0 0 1 .73 2.25l-3.04 9.26a2 2 0 0 1-1.9 1.37H7.04a2 2 0 0 1-1.9-1.37L2.1 10.37a2 2 0 0 1 .73-2.25z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/percent.rs b/packages/leptos/src/percent.rs
new file mode 100644
index 0000000..1663317
--- /dev/null
+++ b/packages/leptos/src/percent.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Percent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="19" x2="5" y1="5" y2="19"></line>
+            <circle cx="6.5" cy="6.5" r="2.5"></circle>
+            <circle cx="17.5" cy="17.5" r="2.5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/person_standing.rs b/packages/leptos/src/person_standing.rs
new file mode 100644
index 0000000..28b6db2
--- /dev/null
+++ b/packages/leptos/src/person_standing.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PersonStanding(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="5" r="1"></circle>
+            <path d="m9 20 3-6 3 6"></path>
+            <path d="m6 8 6 2 6-2"></path>
+            <path d="M12 10v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/philippine_peso.rs b/packages/leptos/src/philippine_peso.rs
new file mode 100644
index 0000000..20a840d
--- /dev/null
+++ b/packages/leptos/src/philippine_peso.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PhilippinePeso(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 11H4"></path>
+            <path d="M20 7H4"></path>
+            <path d="M7 21V4a1 1 0 0 1 1-1h4a1 1 0 0 1 0 12H7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/phone.rs b/packages/leptos/src/phone.rs
new file mode 100644
index 0000000..b2e1b17
--- /dev/null
+++ b/packages/leptos/src/phone.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Phone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/phone_call.rs b/packages/leptos/src/phone_call.rs
new file mode 100644
index 0000000..c6b39ff
--- /dev/null
+++ b/packages/leptos/src/phone_call.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PhoneCall(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>
+            <path d="M14.05 2a9 9 0 0 1 8 7.94"></path>
+            <path d="M14.05 6A5 5 0 0 1 18 10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/phone_forwarded.rs b/packages/leptos/src/phone_forwarded.rs
new file mode 100644
index 0000000..a929fd4
--- /dev/null
+++ b/packages/leptos/src/phone_forwarded.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PhoneForwarded(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="18 2 22 6 18 10"></polyline>
+            <line x1="14" x2="22" y1="6" y2="6"></line>
+            <path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/phone_incoming.rs b/packages/leptos/src/phone_incoming.rs
new file mode 100644
index 0000000..6c55095
--- /dev/null
+++ b/packages/leptos/src/phone_incoming.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PhoneIncoming(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="16 2 16 8 22 8"></polyline>
+            <line x1="22" x2="16" y1="2" y2="8"></line>
+            <path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/phone_missed.rs b/packages/leptos/src/phone_missed.rs
new file mode 100644
index 0000000..16569ef
--- /dev/null
+++ b/packages/leptos/src/phone_missed.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PhoneMissed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="22" x2="16" y1="2" y2="8"></line>
+            <line x1="16" x2="22" y1="2" y2="8"></line>
+            <path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/phone_off.rs b/packages/leptos/src/phone_off.rs
new file mode 100644
index 0000000..a19ea99
--- /dev/null
+++ b/packages/leptos/src/phone_off.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PhoneOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.68 13.31a16 16 0 0 0 3.41 2.6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7 2 2 0 0 1 1.72 2v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.42 19.42 0 0 1-3.33-2.67m-2.67-3.34a19.79 19.79 0 0 1-3.07-8.63A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91"></path>
+            <line x1="22" x2="2" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/phone_outgoing.rs b/packages/leptos/src/phone_outgoing.rs
new file mode 100644
index 0000000..b3059f4
--- /dev/null
+++ b/packages/leptos/src/phone_outgoing.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PhoneOutgoing(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="22 8 22 2 16 2"></polyline>
+            <line x1="16" x2="22" y1="8" y2="2"></line>
+            <path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pi.rs b/packages/leptos/src/pi.rs
new file mode 100644
index 0000000..89739fa
--- /dev/null
+++ b/packages/leptos/src/pi.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pi(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="9" x2="9" y1="4" y2="20"></line>
+            <path d="M4 7c0-1.7 1.3-3 3-3h13"></path>
+            <path d="M18 20c-1.7 0-3-1.3-3-3V4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/piano.rs b/packages/leptos/src/piano.rs
new file mode 100644
index 0000000..f8fe4ad
--- /dev/null
+++ b/packages/leptos/src/piano.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Piano(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.5 8c-1.4 0-2.6-.8-3.2-2A6.87 6.87 0 0 0 2 9v11a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-8.5C22 9.6 20.4 8 18.5 8"></path>
+            <path d="M2 14h20"></path>
+            <path d="M6 14v4"></path>
+            <path d="M10 14v4"></path>
+            <path d="M14 14v4"></path>
+            <path d="M18 14v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pickaxe.rs b/packages/leptos/src/pickaxe.rs
new file mode 100644
index 0000000..1d01f77
--- /dev/null
+++ b/packages/leptos/src/pickaxe.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pickaxe(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.531 12.469 6.619 20.38a1 1 0 1 1-3-3l7.912-7.912"></path>
+            <path d="M15.686 4.314A12.5 12.5 0 0 0 5.461 2.958 1 1 0 0 0 5.58 4.71a22 22 0 0 1 6.318 3.393"></path>
+            <path d="M17.7 3.7a1 1 0 0 0-1.4 0l-4.6 4.6a1 1 0 0 0 0 1.4l2.6 2.6a1 1 0 0 0 1.4 0l4.6-4.6a1 1 0 0 0 0-1.4z"></path>
+            <path d="M19.686 8.314a12.501 12.501 0 0 1 1.356 10.225 1 1 0 0 1-1.751-.119 22 22 0 0 0-3.393-6.319"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/picture_in_picture.rs b/packages/leptos/src/picture_in_picture.rs
new file mode 100644
index 0000000..a9ca295
--- /dev/null
+++ b/packages/leptos/src/picture_in_picture.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PictureInPicture(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 4.5v5H3m-1-6 6 6m13 0v-3c0-1.16-.84-2-2-2h-7m-9 9v2c0 1.05.95 2 2 2h3"></path>
+            <rect width="10" height="7" x="12" y="13.5" ry="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/picture_in_picture_2.rs b/packages/leptos/src/picture_in_picture_2.rs
new file mode 100644
index 0000000..01d20c5
--- /dev/null
+++ b/packages/leptos/src/picture_in_picture_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PictureInPicture2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 9V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10c0 1.1.9 2 2 2h4"></path>
+            <rect width="10" height="7" x="12" y="13" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/piggy_bank.rs b/packages/leptos/src/piggy_bank.rs
new file mode 100644
index 0000000..c5cc0a0
--- /dev/null
+++ b/packages/leptos/src/piggy_bank.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PiggyBank(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 5c-1.5 0-2.8 1.4-3 2-3.5-1.5-11-.3-11 5 0 1.8 0 3 2 4.5V20h4v-2h3v2h4v-4c1-.5 1.7-1 2-2h2v-4h-2c0-1-.5-1.5-1-2V5z"></path>
+            <path d="M2 9v1c0 1.1.9 2 2 2h1"></path>
+            <path d="M16 11h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pilcrow.rs b/packages/leptos/src/pilcrow.rs
new file mode 100644
index 0000000..01fa970
--- /dev/null
+++ b/packages/leptos/src/pilcrow.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pilcrow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 4v16"></path>
+            <path d="M17 4v16"></path>
+            <path d="M19 4H9.5a4.5 4.5 0 0 0 0 9H13"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pilcrow_left.rs b/packages/leptos/src/pilcrow_left.rs
new file mode 100644
index 0000000..f446303
--- /dev/null
+++ b/packages/leptos/src/pilcrow_left.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PilcrowLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 3v11"></path>
+            <path d="M14 9h-3a3 3 0 0 1 0-6h9"></path>
+            <path d="M18 3v11"></path>
+            <path d="M22 18H2l4-4"></path>
+            <path d="m6 22-4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pilcrow_right.rs b/packages/leptos/src/pilcrow_right.rs
new file mode 100644
index 0000000..bc39958
--- /dev/null
+++ b/packages/leptos/src/pilcrow_right.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PilcrowRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 3v11"></path>
+            <path d="M10 9H7a1 1 0 0 1 0-6h8"></path>
+            <path d="M14 3v11"></path>
+            <path d="m18 14 4 4H2"></path>
+            <path d="m22 18-4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pill.rs b/packages/leptos/src/pill.rs
new file mode 100644
index 0000000..bb783eb
--- /dev/null
+++ b/packages/leptos/src/pill.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pill(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10.5 20.5 10-10a4.95 4.95 0 1 0-7-7l-10 10a4.95 4.95 0 1 0 7 7Z"></path>
+            <path d="m8.5 8.5 7 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pill_bottle.rs b/packages/leptos/src/pill_bottle.rs
new file mode 100644
index 0000000..23a6649
--- /dev/null
+++ b/packages/leptos/src/pill_bottle.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PillBottle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 11h-4a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1h4"></path>
+            <path d="M6 7v13a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V7"></path>
+            <rect width="16" height="5" x="4" y="2" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pin.rs b/packages/leptos/src/pin.rs
new file mode 100644
index 0000000..008f5aa
--- /dev/null
+++ b/packages/leptos/src/pin.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pin(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17v5"></path>
+            <path d="M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H8a2 2 0 0 0 0 4 1 1 0 0 1 1 1z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pin_off.rs b/packages/leptos/src/pin_off.rs
new file mode 100644
index 0000000..624e854
--- /dev/null
+++ b/packages/leptos/src/pin_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PinOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17v5"></path>
+            <path d="M15 9.34V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H7.89"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M9 9v1.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h11"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pipette.rs b/packages/leptos/src/pipette.rs
new file mode 100644
index 0000000..3396b11
--- /dev/null
+++ b/packages/leptos/src/pipette.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pipette(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 22 1-1h3l9-9"></path>
+            <path d="M3 21v-3l9-9"></path>
+            <path d="m15 6 3.4-3.4a2.1 2.1 0 1 1 3 3L18 9l.4.4a2.1 2.1 0 1 1-3 3l-3.8-3.8a2.1 2.1 0 1 1 3-3l.4.4Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pizza.rs b/packages/leptos/src/pizza.rs
new file mode 100644
index 0000000..da930d2
--- /dev/null
+++ b/packages/leptos/src/pizza.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pizza(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 14-1 1"></path>
+            <path d="m13.75 18.25-1.25 1.42"></path>
+            <path d="M17.775 5.654a15.68 15.68 0 0 0-12.121 12.12"></path>
+            <path d="M18.8 9.3a1 1 0 0 0 2.1 7.7"></path>
+            <path d="M21.964 20.732a1 1 0 0 1-1.232 1.232l-18-5a1 1 0 0 1-.695-1.232A19.68 19.68 0 0 1 15.732 2.037a1 1 0 0 1 1.232.695z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/plane.rs b/packages/leptos/src/plane.rs
new file mode 100644
index 0000000..9a913a6
--- /dev/null
+++ b/packages/leptos/src/plane.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Plane(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/plane_landing.rs b/packages/leptos/src/plane_landing.rs
new file mode 100644
index 0000000..6f94a1a
--- /dev/null
+++ b/packages/leptos/src/plane_landing.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PlaneLanding(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22h20"></path>
+            <path d="M3.77 10.77 2 9l2-4.5 1.1.55c.55.28.9.84.9 1.45s.35 1.17.9 1.45L8 8.5l3-6 1.05.53a2 2 0 0 1 1.09 1.52l.72 5.4a2 2 0 0 0 1.09 1.52l4.4 2.2c.42.22.78.55 1.01.96l.6 1.03c.49.88-.06 1.98-1.06 2.1l-1.18.15c-.47.06-.95-.02-1.37-.24L4.29 11.15a2 2 0 0 1-.52-.38Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/plane_takeoff.rs b/packages/leptos/src/plane_takeoff.rs
new file mode 100644
index 0000000..80a80eb
--- /dev/null
+++ b/packages/leptos/src/plane_takeoff.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PlaneTakeoff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22h20"></path>
+            <path d="M6.36 17.4 4 17l-2-4 1.1-.55a2 2 0 0 1 1.8 0l.17.1a2 2 0 0 0 1.8 0L8 12 5 6l.9-.45a2 2 0 0 1 2.09.2l4.02 3a2 2 0 0 0 2.1.2l4.19-2.06a2.41 2.41 0 0 1 1.73-.17L21 7a1.4 1.4 0 0 1 .87 1.99l-.38.76c-.23.46-.6.84-1.07 1.08L7.58 17.2a2 2 0 0 1-1.22.18Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/play.rs b/packages/leptos/src/play.rs
new file mode 100644
index 0000000..2edac6e
--- /dev/null
+++ b/packages/leptos/src/play.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Play(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="6 3 20 12 6 21 6 3"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/plug.rs b/packages/leptos/src/plug.rs
new file mode 100644
index 0000000..7b39dd8
--- /dev/null
+++ b/packages/leptos/src/plug.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Plug(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-5"></path>
+            <path d="M9 8V2"></path>
+            <path d="M15 8V2"></path>
+            <path d="M18 8v5a4 4 0 0 1-4 4h-4a4 4 0 0 1-4-4V8Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/plug_2.rs b/packages/leptos/src/plug_2.rs
new file mode 100644
index 0000000..061a7c1
--- /dev/null
+++ b/packages/leptos/src/plug_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Plug2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 2v6"></path>
+            <path d="M15 2v6"></path>
+            <path d="M12 17v5"></path>
+            <path d="M5 8h14"></path>
+            <path d="M6 11V8h12v3a6 6 0 1 1-12 0Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/plug_zap.rs b/packages/leptos/src/plug_zap.rs
new file mode 100644
index 0000000..d7175c3
--- /dev/null
+++ b/packages/leptos/src/plug_zap.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PlugZap(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z"></path>
+            <path d="m2 22 3-3"></path>
+            <path d="M7.5 13.5 10 11"></path>
+            <path d="M10.5 16.5 13 14"></path>
+            <path d="m18 3-4 4h6l-4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/plus.rs b/packages/leptos/src/plus.rs
new file mode 100644
index 0000000..d5274f9
--- /dev/null
+++ b/packages/leptos/src/plus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Plus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 12h14"></path>
+            <path d="M12 5v14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pocket.rs b/packages/leptos/src/pocket.rs
new file mode 100644
index 0000000..e71a986
--- /dev/null
+++ b/packages/leptos/src/pocket.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pocket(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 3h16a2 2 0 0 1 2 2v6a10 10 0 0 1-10 10A10 10 0 0 1 2 11V5a2 2 0 0 1 2-2z"></path>
+            <polyline points="8 10 12 14 16 10"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pocket_knife.rs b/packages/leptos/src/pocket_knife.rs
new file mode 100644
index 0000000..5d8e621
--- /dev/null
+++ b/packages/leptos/src/pocket_knife.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PocketKnife(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 2v1c0 1 2 1 2 2S3 6 3 7s2 1 2 2-2 1-2 2 2 1 2 2"></path>
+            <path d="M18 6h.01"></path>
+            <path d="M6 18h.01"></path>
+            <path d="M20.83 8.83a4 4 0 0 0-5.66-5.66l-12 12a4 4 0 1 0 5.66 5.66Z"></path>
+            <path d="M18 11.66V22a4 4 0 0 0 4-4V6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/podcast.rs b/packages/leptos/src/podcast.rs
new file mode 100644
index 0000000..6feaa34
--- /dev/null
+++ b/packages/leptos/src/podcast.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Podcast(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16.85 18.58a9 9 0 1 0-9.7 0"></path>
+            <path d="M8 14a5 5 0 1 1 8 0"></path>
+            <circle cx="12" cy="11" r="1"></circle>
+            <path d="M13 17a1 1 0 1 0-2 0l.5 4.5a.5.5 0 1 0 1 0Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pointer.rs b/packages/leptos/src/pointer.rs
new file mode 100644
index 0000000..ada418a
--- /dev/null
+++ b/packages/leptos/src/pointer.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pointer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 14a8 8 0 0 1-8 8"></path>
+            <path d="M18 11v-1a2 2 0 0 0-2-2a2 2 0 0 0-2 2"></path>
+            <path d="M14 10V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1"></path>
+            <path d="M10 9.5V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v10"></path>
+            <path d="M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pointer_off.rs b/packages/leptos/src/pointer_off.rs
new file mode 100644
index 0000000..7506ef9
--- /dev/null
+++ b/packages/leptos/src/pointer_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PointerOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 4.5V4a2 2 0 0 0-2.41-1.957"></path>
+            <path d="M13.9 8.4a2 2 0 0 0-1.26-1.295"></path>
+            <path d="M21.7 16.2A8 8 0 0 0 22 14v-3a2 2 0 1 0-4 0v-1a2 2 0 0 0-3.63-1.158"></path>
+            <path d="m7 15-1.8-1.8a2 2 0 0 0-2.79 2.86L6 19.7a7.74 7.74 0 0 0 6 2.3h2a8 8 0 0 0 5.657-2.343"></path>
+            <path d="M6 6v8"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/popcorn.rs b/packages/leptos/src/popcorn.rs
new file mode 100644
index 0000000..5cd69d7
--- /dev/null
+++ b/packages/leptos/src/popcorn.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Popcorn(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 8a2 2 0 0 0 0-4 2 2 0 0 0-4 0 2 2 0 0 0-4 0 2 2 0 0 0-4 0 2 2 0 0 0 0 4"></path>
+            <path d="M10 22 9 8"></path>
+            <path d="m14 22 1-14"></path>
+            <path d="M20 8c.5 0 .9.4.8 1l-2.6 12c-.1.5-.7 1-1.2 1H7c-.6 0-1.1-.4-1.2-1L3.2 9c-.1-.6.3-1 .8-1Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/popsicle.rs b/packages/leptos/src/popsicle.rs
new file mode 100644
index 0000000..a87557f
--- /dev/null
+++ b/packages/leptos/src/popsicle.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Popsicle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.6 14.4c.8-.8.8-2 0-2.8l-8.1-8.1a4.95 4.95 0 1 0-7.1 7.1l8.1 8.1c.9.7 2.1.7 2.9-.1Z"></path>
+            <path d="m22 22-5.5-5.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pound_sterling.rs b/packages/leptos/src/pound_sterling.rs
new file mode 100644
index 0000000..38c9273
--- /dev/null
+++ b/packages/leptos/src/pound_sterling.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PoundSterling(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 7c0-5.333-8-5.333-8 0"></path>
+            <path d="M10 7v14"></path>
+            <path d="M6 21h12"></path>
+            <path d="M6 13h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/power.rs b/packages/leptos/src/power.rs
new file mode 100644
index 0000000..880bfc8
--- /dev/null
+++ b/packages/leptos/src/power.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Power(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v10"></path>
+            <path d="M18.4 6.6a9 9 0 1 1-12.77.04"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/power_off.rs b/packages/leptos/src/power_off.rs
new file mode 100644
index 0000000..4c809c2
--- /dev/null
+++ b/packages/leptos/src/power_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PowerOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.36 6.64A9 9 0 0 1 20.77 15"></path>
+            <path d="M6.16 6.16a9 9 0 1 0 12.68 12.68"></path>
+            <path d="M12 2v4"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/presentation.rs b/packages/leptos/src/presentation.rs
new file mode 100644
index 0000000..0befcfe
--- /dev/null
+++ b/packages/leptos/src/presentation.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Presentation(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 3h20"></path>
+            <path d="M21 3v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V3"></path>
+            <path d="m7 21 5-5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/printer.rs b/packages/leptos/src/printer.rs
new file mode 100644
index 0000000..bf7768b
--- /dev/null
+++ b/packages/leptos/src/printer.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Printer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"></path>
+            <path d="M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6"></path>
+            <rect x="6" y="14" width="12" height="8" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/printer_check.rs b/packages/leptos/src/printer_check.rs
new file mode 100644
index 0000000..4bc3da7
--- /dev/null
+++ b/packages/leptos/src/printer_check.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn PrinterCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.5 22H7a1 1 0 0 1-1-1v-6a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v.5"></path>
+            <path d="m16 19 2 2 4-4"></path>
+            <path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v2"></path>
+            <path d="M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/projector.rs b/packages/leptos/src/projector.rs
new file mode 100644
index 0000000..0e19f50
--- /dev/null
+++ b/packages/leptos/src/projector.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Projector(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 7 3 5"></path>
+            <path d="M9 6V3"></path>
+            <path d="m13 7 2-2"></path>
+            <circle cx="9" cy="13" r="3"></circle>
+            <path d="M11.83 12H20a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-4a2 2 0 0 1 2-2h2.17"></path>
+            <path d="M16 16h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/proportions.rs b/packages/leptos/src/proportions.rs
new file mode 100644
index 0000000..7fdab09
--- /dev/null
+++ b/packages/leptos/src/proportions.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Proportions(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+            <path d="M12 9v11"></path>
+            <path d="M2 9h13a2 2 0 0 1 2 2v9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/puzzle.rs b/packages/leptos/src/puzzle.rs
new file mode 100644
index 0000000..e0094b3
--- /dev/null
+++ b/packages/leptos/src/puzzle.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Puzzle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.39 4.39a1 1 0 0 0 1.68-.474 2.5 2.5 0 1 1 3.014 3.015 1 1 0 0 0-.474 1.68l1.683 1.682a2.414 2.414 0 0 1 0 3.414L19.61 15.39a1 1 0 0 1-1.68-.474 2.5 2.5 0 1 0-3.014 3.015 1 1 0 0 1 .474 1.68l-1.683 1.682a2.414 2.414 0 0 1-3.414 0L8.61 19.61a1 1 0 0 0-1.68.474 2.5 2.5 0 1 1-3.014-3.015 1 1 0 0 0 .474-1.68l-1.683-1.682a2.414 2.414 0 0 1 0-3.414L4.39 8.61a1 1 0 0 1 1.68.474 2.5 2.5 0 1 0 3.014-3.015 1 1 0 0 1-.474-1.68l1.683-1.682a2.414 2.414 0 0 1 3.414 0z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/pyramid.rs b/packages/leptos/src/pyramid.rs
new file mode 100644
index 0000000..0b69525
--- /dev/null
+++ b/packages/leptos/src/pyramid.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Pyramid(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.5 16.88a1 1 0 0 1-.32-1.43l9-13.02a1 1 0 0 1 1.64 0l9 13.01a1 1 0 0 1-.32 1.44l-8.51 4.86a2 2 0 0 1-1.98 0Z"></path>
+            <path d="M12 2v20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/qr_code.rs b/packages/leptos/src/qr_code.rs
new file mode 100644
index 0000000..64c350b
--- /dev/null
+++ b/packages/leptos/src/qr_code.rs
@@ -0,0 +1,46 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn QrCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="5" height="5" x="3" y="3" rx="1"></rect>
+            <rect width="5" height="5" x="16" y="3" rx="1"></rect>
+            <rect width="5" height="5" x="3" y="16" rx="1"></rect>
+            <path d="M21 16h-3a2 2 0 0 0-2 2v3"></path>
+            <path d="M21 21v.01"></path>
+            <path d="M12 7v3a2 2 0 0 1-2 2H7"></path>
+            <path d="M3 12h.01"></path>
+            <path d="M12 3h.01"></path>
+            <path d="M12 16v.01"></path>
+            <path d="M16 12h1"></path>
+            <path d="M21 12v.01"></path>
+            <path d="M12 21v-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/quote.rs b/packages/leptos/src/quote.rs
new file mode 100644
index 0000000..71d0969
--- /dev/null
+++ b/packages/leptos/src/quote.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Quote(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z"></path>
+            <path d="M5 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rabbit.rs b/packages/leptos/src/rabbit.rs
new file mode 100644
index 0000000..6a8a232
--- /dev/null
+++ b/packages/leptos/src/rabbit.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rabbit(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 16a3 3 0 0 1 2.24 5"></path>
+            <path d="M18 12h.01"></path>
+            <path d="M18 21h-8a4 4 0 0 1-4-4 7 7 0 0 1 7-7h.2L9.6 6.4a1 1 0 1 1 2.8-2.8L15.8 7h.2c3.3 0 6 2.7 6 6v1a2 2 0 0 1-2 2h-1a3 3 0 0 0-3 3"></path>
+            <path d="M20 8.54V4a2 2 0 1 0-4 0v3"></path>
+            <path d="M7.612 12.524a3 3 0 1 0-1.6 4.3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/radar.rs b/packages/leptos/src/radar.rs
new file mode 100644
index 0000000..ae53433
--- /dev/null
+++ b/packages/leptos/src/radar.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Radar(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.07 4.93A10 10 0 0 0 6.99 3.34"></path>
+            <path d="M4 6h.01"></path>
+            <path d="M2.29 9.62A10 10 0 1 0 21.31 8.35"></path>
+            <path d="M16.24 7.76A6 6 0 1 0 8.23 16.67"></path>
+            <path d="M12 18h.01"></path>
+            <path d="M17.99 11.66A6 6 0 0 1 15.77 16.67"></path>
+            <circle cx="12" cy="12" r="2"></circle>
+            <path d="m13.41 10.59 5.66-5.66"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/radiation.rs b/packages/leptos/src/radiation.rs
new file mode 100644
index 0000000..93b596c
--- /dev/null
+++ b/packages/leptos/src/radiation.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Radiation(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12h.01"></path>
+            <path d="M7.5 4.2c-.3-.5-.9-.7-1.3-.4C3.9 5.5 2.3 8.1 2 11c-.1.5.4 1 1 1h5c0-1.5.8-2.8 2-3.4-1.1-1.9-2-3.5-2.5-4.4z"></path>
+            <path d="M21 12c.6 0 1-.4 1-1-.3-2.9-1.8-5.5-4.1-7.1-.4-.3-1.1-.2-1.3.3-.6.9-1.5 2.5-2.6 4.3 1.2.7 2 2 2 3.5h5z"></path>
+            <path d="M7.5 19.8c-.3.5-.1 1.1.4 1.3 2.6 1.2 5.6 1.2 8.2 0 .5-.2.7-.8.4-1.3-.5-.9-1.4-2.5-2.5-4.3-1.2.7-2.8.7-4 0-1.1 1.8-2 3.4-2.5 4.3z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/radical.rs b/packages/leptos/src/radical.rs
new file mode 100644
index 0000000..042efbe
--- /dev/null
+++ b/packages/leptos/src/radical.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Radical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12h3.28a1 1 0 0 1 .948.684l2.298 7.934a.5.5 0 0 0 .96-.044L13.82 4.771A1 1 0 0 1 14.792 4H21"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/radio.rs b/packages/leptos/src/radio.rs
new file mode 100644
index 0000000..6074b33
--- /dev/null
+++ b/packages/leptos/src/radio.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Radio(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.9 19.1C1 15.2 1 8.8 4.9 4.9"></path>
+            <path d="M7.8 16.2c-2.3-2.3-2.3-6.1 0-8.5"></path>
+            <circle cx="12" cy="12" r="2"></circle>
+            <path d="M16.2 7.8c2.3 2.3 2.3 6.1 0 8.5"></path>
+            <path d="M19.1 4.9C23 8.8 23 15.1 19.1 19"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/radio_receiver.rs b/packages/leptos/src/radio_receiver.rs
new file mode 100644
index 0000000..7db4966
--- /dev/null
+++ b/packages/leptos/src/radio_receiver.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RadioReceiver(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 16v2"></path>
+            <path d="M19 16v2"></path>
+            <rect width="20" height="8" x="2" y="8" rx="2"></rect>
+            <path d="M18 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/radio_tower.rs b/packages/leptos/src/radio_tower.rs
new file mode 100644
index 0000000..7ecf15a
--- /dev/null
+++ b/packages/leptos/src/radio_tower.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RadioTower(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.9 16.1C1 12.2 1 5.8 4.9 1.9"></path>
+            <path d="M7.8 4.7a6.14 6.14 0 0 0-.8 7.5"></path>
+            <circle cx="12" cy="9" r="2"></circle>
+            <path d="M16.2 4.8c2 2 2.26 5.11.8 7.47"></path>
+            <path d="M19.1 1.9a9.96 9.96 0 0 1 0 14.1"></path>
+            <path d="M9.5 18h5"></path>
+            <path d="m8 22 4-11 4 11"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/radius.rs b/packages/leptos/src/radius.rs
new file mode 100644
index 0000000..2343e47
--- /dev/null
+++ b/packages/leptos/src/radius.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Radius(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20.34 17.52a10 10 0 1 0-2.82 2.82"></path>
+            <circle cx="19" cy="19" r="2"></circle>
+            <path d="m13.41 13.41 4.18 4.18"></path>
+            <circle cx="12" cy="12" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rail_symbol.rs b/packages/leptos/src/rail_symbol.rs
new file mode 100644
index 0000000..79ab80d
--- /dev/null
+++ b/packages/leptos/src/rail_symbol.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RailSymbol(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 15h14"></path>
+            <path d="M5 9h14"></path>
+            <path d="m14 20-5-5 6-6-5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rainbow.rs b/packages/leptos/src/rainbow.rs
new file mode 100644
index 0000000..7ec3226
--- /dev/null
+++ b/packages/leptos/src/rainbow.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rainbow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 17a10 10 0 0 0-20 0"></path>
+            <path d="M6 17a6 6 0 0 1 12 0"></path>
+            <path d="M10 17a2 2 0 0 1 4 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rat.rs b/packages/leptos/src/rat.rs
new file mode 100644
index 0000000..fff93f2
--- /dev/null
+++ b/packages/leptos/src/rat.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rat(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 5c0-1.7-1.3-3-3-3s-3 1.3-3 3c0 .8.3 1.5.8 2H11c-3.9 0-7 3.1-7 7c0 2.2 1.8 4 4 4"></path>
+            <path d="M16.8 3.9c.3-.3.6-.5 1-.7 1.5-.6 3.3.1 3.9 1.6.6 1.5-.1 3.3-1.6 3.9l1.6 2.8c.2.3.2.7.2 1-.2.8-.9 1.2-1.7 1.1 0 0-1.6-.3-2.7-.6H17c-1.7 0-3 1.3-3 3"></path>
+            <path d="M13.2 18a3 3 0 0 0-2.2-5"></path>
+            <path d="M13 22H4a2 2 0 0 1 0-4h12"></path>
+            <path d="M16 9h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ratio.rs b/packages/leptos/src/ratio.rs
new file mode 100644
index 0000000..f8af055
--- /dev/null
+++ b/packages/leptos/src/ratio.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ratio(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="12" height="20" x="6" y="2" rx="2"></rect>
+            <rect width="20" height="12" x="2" y="6" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt.rs b/packages/leptos/src/receipt.rs
new file mode 100644
index 0000000..a08b4c5
--- /dev/null
+++ b/packages/leptos/src/receipt.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Receipt(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8"></path>
+            <path d="M12 17.5v-11"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt_cent.rs b/packages/leptos/src/receipt_cent.rs
new file mode 100644
index 0000000..2ac50d6
--- /dev/null
+++ b/packages/leptos/src/receipt_cent.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReceiptCent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="M12 6.5v11"></path>
+            <path d="M15 9.4a4 4 0 1 0 0 5.2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt_euro.rs b/packages/leptos/src/receipt_euro.rs
new file mode 100644
index 0000000..1e6c2df
--- /dev/null
+++ b/packages/leptos/src/receipt_euro.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReceiptEuro(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="M8 12h5"></path>
+            <path d="M16 9.5a4 4 0 1 0 0 5.2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt_indian_rupee.rs b/packages/leptos/src/receipt_indian_rupee.rs
new file mode 100644
index 0000000..f544b78
--- /dev/null
+++ b/packages/leptos/src/receipt_indian_rupee.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReceiptIndianRupee(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="M8 7h8"></path>
+            <path d="M12 17.5 8 15h1a4 4 0 0 0 0-8"></path>
+            <path d="M8 11h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt_japanese_yen.rs b/packages/leptos/src/receipt_japanese_yen.rs
new file mode 100644
index 0000000..e837c21
--- /dev/null
+++ b/packages/leptos/src/receipt_japanese_yen.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReceiptJapaneseYen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="m12 10 3-3"></path>
+            <path d="m9 7 3 3v7.5"></path>
+            <path d="M9 11h6"></path>
+            <path d="M9 15h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt_pound_sterling.rs b/packages/leptos/src/receipt_pound_sterling.rs
new file mode 100644
index 0000000..87eb924
--- /dev/null
+++ b/packages/leptos/src/receipt_pound_sterling.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReceiptPoundSterling(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="M8 13h5"></path>
+            <path d="M10 17V9.5a2.5 2.5 0 0 1 5 0"></path>
+            <path d="M8 17h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt_russian_ruble.rs b/packages/leptos/src/receipt_russian_ruble.rs
new file mode 100644
index 0000000..61552de
--- /dev/null
+++ b/packages/leptos/src/receipt_russian_ruble.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReceiptRussianRuble(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="M8 15h5"></path>
+            <path d="M8 11h5a2 2 0 1 0 0-4h-3v10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt_swiss_franc.rs b/packages/leptos/src/receipt_swiss_franc.rs
new file mode 100644
index 0000000..f6d4fc4
--- /dev/null
+++ b/packages/leptos/src/receipt_swiss_franc.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReceiptSwissFranc(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="M10 17V7h5"></path>
+            <path d="M10 11h4"></path>
+            <path d="M8 15h5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/receipt_text.rs b/packages/leptos/src/receipt_text.rs
new file mode 100644
index 0000000..712ef65
--- /dev/null
+++ b/packages/leptos/src/receipt_text.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReceiptText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"></path>
+            <path d="M14 8H8"></path>
+            <path d="M16 12H8"></path>
+            <path d="M13 16H8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rectangle_ellipsis.rs b/packages/leptos/src/rectangle_ellipsis.rs
new file mode 100644
index 0000000..f350db1
--- /dev/null
+++ b/packages/leptos/src/rectangle_ellipsis.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RectangleEllipsis(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="2"></rect>
+            <path d="M12 12h.01"></path>
+            <path d="M17 12h.01"></path>
+            <path d="M7 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rectangle_horizontal.rs b/packages/leptos/src/rectangle_horizontal.rs
new file mode 100644
index 0000000..9355164
--- /dev/null
+++ b/packages/leptos/src/rectangle_horizontal.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RectangleHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rectangle_vertical.rs b/packages/leptos/src/rectangle_vertical.rs
new file mode 100644
index 0000000..43c57ff
--- /dev/null
+++ b/packages/leptos/src/rectangle_vertical.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RectangleVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="12" height="20" x="6" y="2" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/recycle.rs b/packages/leptos/src/recycle.rs
new file mode 100644
index 0000000..3840b20
--- /dev/null
+++ b/packages/leptos/src/recycle.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Recycle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 19H4.815a1.83 1.83 0 0 1-1.57-.881 1.785 1.785 0 0 1-.004-1.784L7.196 9.5"></path>
+            <path d="M11 19h8.203a1.83 1.83 0 0 0 1.556-.89 1.784 1.784 0 0 0 0-1.775l-1.226-2.12"></path>
+            <path d="m14 16-3 3 3 3"></path>
+            <path d="M8.293 13.596 7.196 9.5 3.1 10.598"></path>
+            <path d="m9.344 5.811 1.093-1.892A1.83 1.83 0 0 1 11.985 3a1.784 1.784 0 0 1 1.546.888l3.943 6.843"></path>
+            <path d="m13.378 9.633 4.096 1.098 1.097-4.096"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/redo.rs b/packages/leptos/src/redo.rs
new file mode 100644
index 0000000..9b7b1f1
--- /dev/null
+++ b/packages/leptos/src/redo.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Redo(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 7v6h-6"></path>
+            <path d="M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/redo_2.rs b/packages/leptos/src/redo_2.rs
new file mode 100644
index 0000000..0580bfb
--- /dev/null
+++ b/packages/leptos/src/redo_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Redo2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 14 5-5-5-5"></path>
+            <path d="M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/redo_dot.rs b/packages/leptos/src/redo_dot.rs
new file mode 100644
index 0000000..dad0c0f
--- /dev/null
+++ b/packages/leptos/src/redo_dot.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RedoDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="17" r="1"></circle>
+            <path d="M21 7v6h-6"></path>
+            <path d="M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/refresh_ccw.rs b/packages/leptos/src/refresh_ccw.rs
new file mode 100644
index 0000000..b5664c4
--- /dev/null
+++ b/packages/leptos/src/refresh_ccw.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RefreshCcw(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"></path>
+            <path d="M3 3v5h5"></path>
+            <path d="M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16"></path>
+            <path d="M16 16h5v5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/refresh_ccw_dot.rs b/packages/leptos/src/refresh_ccw_dot.rs
new file mode 100644
index 0000000..346d59b
--- /dev/null
+++ b/packages/leptos/src/refresh_ccw_dot.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RefreshCcwDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 2v6h6"></path>
+            <path d="M21 12A9 9 0 0 0 6 5.3L3 8"></path>
+            <path d="M21 22v-6h-6"></path>
+            <path d="M3 12a9 9 0 0 0 15 6.7l3-2.7"></path>
+            <circle cx="12" cy="12" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/refresh_cw.rs b/packages/leptos/src/refresh_cw.rs
new file mode 100644
index 0000000..30e0a45
--- /dev/null
+++ b/packages/leptos/src/refresh_cw.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RefreshCw(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8"></path>
+            <path d="M21 3v5h-5"></path>
+            <path d="M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16"></path>
+            <path d="M8 16H3v5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/refresh_cw_off.rs b/packages/leptos/src/refresh_cw_off.rs
new file mode 100644
index 0000000..a2486d7
--- /dev/null
+++ b/packages/leptos/src/refresh_cw_off.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RefreshCwOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 8L18.74 5.74A9.75 9.75 0 0 0 12 3C11 3 10.03 3.16 9.13 3.47"></path>
+            <path d="M8 16H3v5"></path>
+            <path d="M3 12C3 9.51 4 7.26 5.64 5.64"></path>
+            <path d="m3 16 2.26 2.26A9.75 9.75 0 0 0 12 21c2.49 0 4.74-1 6.36-2.64"></path>
+            <path d="M21 12c0 1-.16 1.97-.47 2.87"></path>
+            <path d="M21 3v5h-5"></path>
+            <path d="M22 22 2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/refrigerator.rs b/packages/leptos/src/refrigerator.rs
new file mode 100644
index 0000000..62fc684
--- /dev/null
+++ b/packages/leptos/src/refrigerator.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Refrigerator(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 6a4 4 0 0 1 4-4h6a4 4 0 0 1 4 4v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6Z"></path>
+            <path d="M5 10h14"></path>
+            <path d="M15 7v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/regex.rs b/packages/leptos/src/regex.rs
new file mode 100644
index 0000000..bed8294
--- /dev/null
+++ b/packages/leptos/src/regex.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Regex(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 3v10"></path>
+            <path d="m12.67 5.5 8.66 5"></path>
+            <path d="m12.67 10.5 8.66-5"></path>
+            <path d="M9 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/remove_formatting.rs b/packages/leptos/src/remove_formatting.rs
new file mode 100644
index 0000000..00fc522
--- /dev/null
+++ b/packages/leptos/src/remove_formatting.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RemoveFormatting(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 7V4h16v3"></path>
+            <path d="M5 20h6"></path>
+            <path d="M13 4 8 20"></path>
+            <path d="m15 15 5 5"></path>
+            <path d="m20 15-5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/repeat.rs b/packages/leptos/src/repeat.rs
new file mode 100644
index 0000000..fa396f1
--- /dev/null
+++ b/packages/leptos/src/repeat.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Repeat(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 2 4 4-4 4"></path>
+            <path d="M3 11v-1a4 4 0 0 1 4-4h14"></path>
+            <path d="m7 22-4-4 4-4"></path>
+            <path d="M21 13v1a4 4 0 0 1-4 4H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/repeat_1.rs b/packages/leptos/src/repeat_1.rs
new file mode 100644
index 0000000..6a1a073
--- /dev/null
+++ b/packages/leptos/src/repeat_1.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Repeat1(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 2 4 4-4 4"></path>
+            <path d="M3 11v-1a4 4 0 0 1 4-4h14"></path>
+            <path d="m7 22-4-4 4-4"></path>
+            <path d="M21 13v1a4 4 0 0 1-4 4H3"></path>
+            <path d="M11 10h1v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/repeat_2.rs b/packages/leptos/src/repeat_2.rs
new file mode 100644
index 0000000..b5aca14
--- /dev/null
+++ b/packages/leptos/src/repeat_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Repeat2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 9 3-3 3 3"></path>
+            <path d="M13 18H7a2 2 0 0 1-2-2V6"></path>
+            <path d="m22 15-3 3-3-3"></path>
+            <path d="M11 6h6a2 2 0 0 1 2 2v10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/replace.rs b/packages/leptos/src/replace.rs
new file mode 100644
index 0000000..5713abc
--- /dev/null
+++ b/packages/leptos/src/replace.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Replace(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 4a2 2 0 0 1 2-2"></path>
+            <path d="M16 10a2 2 0 0 1-2-2"></path>
+            <path d="M20 2a2 2 0 0 1 2 2"></path>
+            <path d="M22 8a2 2 0 0 1-2 2"></path>
+            <path d="m3 7 3 3 3-3"></path>
+            <path d="M6 10V5a3 3 0 0 1 3-3h1"></path>
+            <rect x="2" y="14" width="8" height="8" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/replace_all.rs b/packages/leptos/src/replace_all.rs
new file mode 100644
index 0000000..7c182c4
--- /dev/null
+++ b/packages/leptos/src/replace_all.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReplaceAll(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 14a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2"></path>
+            <path d="M14 4a2 2 0 0 1 2-2"></path>
+            <path d="M16 10a2 2 0 0 1-2-2"></path>
+            <path d="M20 14a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2"></path>
+            <path d="M20 2a2 2 0 0 1 2 2"></path>
+            <path d="M22 8a2 2 0 0 1-2 2"></path>
+            <path d="m3 7 3 3 3-3"></path>
+            <path d="M6 10V5a 3 3 0 0 1 3-3h1"></path>
+            <rect x="2" y="14" width="8" height="8" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/reply.rs b/packages/leptos/src/reply.rs
new file mode 100644
index 0000000..cfdea0a
--- /dev/null
+++ b/packages/leptos/src/reply.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Reply(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="9 17 4 12 9 7"></polyline>
+            <path d="M20 18v-2a4 4 0 0 0-4-4H4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/reply_all.rs b/packages/leptos/src/reply_all.rs
new file mode 100644
index 0000000..d0e1bc4
--- /dev/null
+++ b/packages/leptos/src/reply_all.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ReplyAll(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="7 17 2 12 7 7"></polyline>
+            <polyline points="12 17 7 12 12 7"></polyline>
+            <path d="M22 18v-2a4 4 0 0 0-4-4H7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rewind.rs b/packages/leptos/src/rewind.rs
new file mode 100644
index 0000000..a473d0f
--- /dev/null
+++ b/packages/leptos/src/rewind.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rewind(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="11 19 2 12 11 5 11 19"></polygon>
+            <polygon points="22 19 13 12 22 5 22 19"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ribbon.rs b/packages/leptos/src/ribbon.rs
new file mode 100644
index 0000000..50e9a3c
--- /dev/null
+++ b/packages/leptos/src/ribbon.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ribbon(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 11.22C11 9.997 10 9 10 8a2 2 0 0 1 4 0c0 1-.998 2.002-2.01 3.22"></path>
+            <path d="m12 18 2.57-3.5"></path>
+            <path d="M6.243 9.016a7 7 0 0 1 11.507-.009"></path>
+            <path d="M9.35 14.53 12 11.22"></path>
+            <path d="M9.35 14.53C7.728 12.246 6 10.221 6 7a6 5 0 0 1 12 0c-.005 3.22-1.778 5.235-3.43 7.5l3.557 4.527a1 1 0 0 1-.203 1.43l-1.894 1.36a1 1 0 0 1-1.384-.215L12 18l-2.679 3.593a1 1 0 0 1-1.39.213l-1.865-1.353a1 1 0 0 1-.203-1.422z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rocket.rs b/packages/leptos/src/rocket.rs
new file mode 100644
index 0000000..0060f64
--- /dev/null
+++ b/packages/leptos/src/rocket.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rocket(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z"></path>
+            <path d="m12 15-3-3a22 22 0 0 1 2-3.95A12.88 12.88 0 0 1 22 2c0 2.72-.78 7.5-6 11a22.35 22.35 0 0 1-4 2z"></path>
+            <path d="M9 12H4s.55-3.03 2-4c1.62-1.08 5 0 5 0"></path>
+            <path d="M12 15v5s3.03-.55 4-2c1.08-1.62 0-5 0-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rocking_chair.rs b/packages/leptos/src/rocking_chair.rs
new file mode 100644
index 0000000..2b0a1ff
--- /dev/null
+++ b/packages/leptos/src/rocking_chair.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RockingChair(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="3.5 2 6.5 12.5 18 12.5"></polyline>
+            <line x1="9.5" x2="5.5" y1="12.5" y2="20"></line>
+            <line x1="15" x2="18.5" y1="12.5" y2="20"></line>
+            <path d="M2.75 18a13 13 0 0 0 18.5 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/roller_coaster.rs b/packages/leptos/src/roller_coaster.rs
new file mode 100644
index 0000000..656806c
--- /dev/null
+++ b/packages/leptos/src/roller_coaster.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RollerCoaster(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 19V5"></path>
+            <path d="M10 19V6.8"></path>
+            <path d="M14 19v-7.8"></path>
+            <path d="M18 5v4"></path>
+            <path d="M18 19v-6"></path>
+            <path d="M22 19V9"></path>
+            <path d="M2 19V9a4 4 0 0 1 4-4c2 0 4 1.33 6 4s4 4 6 4a4 4 0 1 0-3-6.65"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rotate_3_d.rs b/packages/leptos/src/rotate_3_d.rs
new file mode 100644
index 0000000..4297499
--- /dev/null
+++ b/packages/leptos/src/rotate_3_d.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rotate3D(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16.466 7.5C15.643 4.237 13.952 2 12 2 9.239 2 7 6.477 7 12s2.239 10 5 10c.342 0 .677-.069 1-.2"></path>
+            <path d="m15.194 13.707 3.814 1.86-1.86 3.814"></path>
+            <path d="M19 15.57c-1.804.885-4.274 1.43-7 1.43-5.523 0-10-2.239-10-5s4.477-5 10-5c4.838 0 8.873 1.718 9.8 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rotate_ccw.rs b/packages/leptos/src/rotate_ccw.rs
new file mode 100644
index 0000000..b6887e3
--- /dev/null
+++ b/packages/leptos/src/rotate_ccw.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RotateCcw(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"></path>
+            <path d="M3 3v5h5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rotate_ccw_square.rs b/packages/leptos/src/rotate_ccw_square.rs
new file mode 100644
index 0000000..ffb9686
--- /dev/null
+++ b/packages/leptos/src/rotate_ccw_square.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RotateCcwSquare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 9V7a2 2 0 0 0-2-2h-6"></path>
+            <path d="m15 2-3 3 3 3"></path>
+            <path d="M20 13v5a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rotate_cw.rs b/packages/leptos/src/rotate_cw.rs
new file mode 100644
index 0000000..d50719e
--- /dev/null
+++ b/packages/leptos/src/rotate_cw.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RotateCw(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8"></path>
+            <path d="M21 3v5h-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rotate_cw_square.rs b/packages/leptos/src/rotate_cw_square.rs
new file mode 100644
index 0000000..e3df6e8
--- /dev/null
+++ b/packages/leptos/src/rotate_cw_square.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RotateCwSquare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5H6a2 2 0 0 0-2 2v3"></path>
+            <path d="m9 8 3-3-3-3"></path>
+            <path d="M4 14v4a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/route.rs b/packages/leptos/src/route.rs
new file mode 100644
index 0000000..bffc8be
--- /dev/null
+++ b/packages/leptos/src/route.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Route(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="19" r="3"></circle>
+            <path d="M9 19h8.5a3.5 3.5 0 0 0 0-7h-11a3.5 3.5 0 0 1 0-7H15"></path>
+            <circle cx="18" cy="5" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/route_off.rs b/packages/leptos/src/route_off.rs
new file mode 100644
index 0000000..af32889
--- /dev/null
+++ b/packages/leptos/src/route_off.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RouteOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="19" r="3"></circle>
+            <path d="M9 19h8.5c.4 0 .9-.1 1.3-.2"></path>
+            <path d="M5.2 5.2A3.5 3.53 0 0 0 6.5 12H12"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M21 15.3a3.5 3.5 0 0 0-3.3-3.3"></path>
+            <path d="M15 5h-4.3"></path>
+            <circle cx="18" cy="5" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/router.rs b/packages/leptos/src/router.rs
new file mode 100644
index 0000000..a599c4c
--- /dev/null
+++ b/packages/leptos/src/router.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Router(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="8" x="2" y="14" rx="2"></rect>
+            <path d="M6.01 18H6"></path>
+            <path d="M10.01 18H10"></path>
+            <path d="M15 10v4"></path>
+            <path d="M17.84 7.17a4 4 0 0 0-5.66 0"></path>
+            <path d="M20.66 4.34a8 8 0 0 0-11.31 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rows_2.rs b/packages/leptos/src/rows_2.rs
new file mode 100644
index 0000000..b81a785
--- /dev/null
+++ b/packages/leptos/src/rows_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rows2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 12h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rows_3.rs b/packages/leptos/src/rows_3.rs
new file mode 100644
index 0000000..652bdd2
--- /dev/null
+++ b/packages/leptos/src/rows_3.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rows3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M21 9H3"></path>
+            <path d="M21 15H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rows_4.rs b/packages/leptos/src/rows_4.rs
new file mode 100644
index 0000000..42cfc2f
--- /dev/null
+++ b/packages/leptos/src/rows_4.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rows4(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M21 7.5H3"></path>
+            <path d="M21 12H3"></path>
+            <path d="M21 16.5H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/rss.rs b/packages/leptos/src/rss.rs
new file mode 100644
index 0000000..bdb7a0d
--- /dev/null
+++ b/packages/leptos/src/rss.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Rss(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 11a9 9 0 0 1 9 9"></path>
+            <path d="M4 4a16 16 0 0 1 16 16"></path>
+            <circle cx="5" cy="19" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ruler.rs b/packages/leptos/src/ruler.rs
new file mode 100644
index 0000000..982b07e
--- /dev/null
+++ b/packages/leptos/src/ruler.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ruler(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.3 15.3a2.4 2.4 0 0 1 0 3.4l-2.6 2.6a2.4 2.4 0 0 1-3.4 0L2.7 8.7a2.41 2.41 0 0 1 0-3.4l2.6-2.6a2.41 2.41 0 0 1 3.4 0Z"></path>
+            <path d="m14.5 12.5 2-2"></path>
+            <path d="m11.5 9.5 2-2"></path>
+            <path d="m8.5 6.5 2-2"></path>
+            <path d="m17.5 15.5 2-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/russian_ruble.rs b/packages/leptos/src/russian_ruble.rs
new file mode 100644
index 0000000..93296ef
--- /dev/null
+++ b/packages/leptos/src/russian_ruble.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn RussianRuble(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 11h8a4 4 0 0 0 0-8H9v18"></path>
+            <path d="M6 15h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sailboat.rs b/packages/leptos/src/sailboat.rs
new file mode 100644
index 0000000..af7cc99
--- /dev/null
+++ b/packages/leptos/src/sailboat.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sailboat(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 18H2a4 4 0 0 0 4 4h12a4 4 0 0 0 4-4Z"></path>
+            <path d="M21 14 10 2 3 14h18Z"></path>
+            <path d="M10 2v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/salad.rs b/packages/leptos/src/salad.rs
new file mode 100644
index 0000000..67a38e5
--- /dev/null
+++ b/packages/leptos/src/salad.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Salad(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 21h10"></path>
+            <path d="M12 21a9 9 0 0 0 9-9H3a9 9 0 0 0 9 9Z"></path>
+            <path d="M11.38 12a2.4 2.4 0 0 1-.4-4.77 2.4 2.4 0 0 1 3.2-2.77 2.4 2.4 0 0 1 3.47-.63 2.4 2.4 0 0 1 3.37 3.37 2.4 2.4 0 0 1-1.1 3.7 2.51 2.51 0 0 1 .03 1.1"></path>
+            <path d="m13 12 4-4"></path>
+            <path d="M10.9 7.25A3.99 3.99 0 0 0 4 10c0 .73.2 1.41.54 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sandwich.rs b/packages/leptos/src/sandwich.rs
new file mode 100644
index 0000000..c0df32c
--- /dev/null
+++ b/packages/leptos/src/sandwich.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sandwich(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2.37 11.223 8.372-6.777a2 2 0 0 1 2.516 0l8.371 6.777"></path>
+            <path d="M21 15a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1h-5.25"></path>
+            <path d="M3 15a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h9"></path>
+            <path d="m6.67 15 6.13 4.6a2 2 0 0 0 2.8-.4l3.15-4.2"></path>
+            <rect width="20" height="4" x="2" y="11" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/satellite.rs b/packages/leptos/src/satellite.rs
new file mode 100644
index 0000000..6804bcc
--- /dev/null
+++ b/packages/leptos/src/satellite.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Satellite(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 7 9 3 5 7l4 4"></path>
+            <path d="m17 11 4 4-4 4-4-4"></path>
+            <path d="m8 12 4 4 6-6-4-4Z"></path>
+            <path d="m16 8 3-3"></path>
+            <path d="M9 21a6 6 0 0 0-6-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/satellite_dish.rs b/packages/leptos/src/satellite_dish.rs
new file mode 100644
index 0000000..e913efc
--- /dev/null
+++ b/packages/leptos/src/satellite_dish.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SatelliteDish(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10a7.31 7.31 0 0 0 10 10Z"></path>
+            <path d="m9 15 3-3"></path>
+            <path d="M17 13a6 6 0 0 0-6-6"></path>
+            <path d="M21 13A10 10 0 0 0 11 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/save.rs b/packages/leptos/src/save.rs
new file mode 100644
index 0000000..22f9359
--- /dev/null
+++ b/packages/leptos/src/save.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Save(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.2 3a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2z"></path>
+            <path d="M17 21v-7a1 1 0 0 0-1-1H8a1 1 0 0 0-1 1v7"></path>
+            <path d="M7 3v4a1 1 0 0 0 1 1h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/save_all.rs b/packages/leptos/src/save_all.rs
new file mode 100644
index 0000000..afce924
--- /dev/null
+++ b/packages/leptos/src/save_all.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SaveAll(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v3a1 1 0 0 0 1 1h5"></path>
+            <path d="M18 18v-6a1 1 0 0 0-1-1h-6a1 1 0 0 0-1 1v6"></path>
+            <path d="M18 22H4a2 2 0 0 1-2-2V6"></path>
+            <path d="M8 18a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9.172a2 2 0 0 1 1.414.586l2.828 2.828A2 2 0 0 1 22 6.828V16a2 2 0 0 1-2.01 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/save_off.rs b/packages/leptos/src/save_off.rs
new file mode 100644
index 0000000..c68437b
--- /dev/null
+++ b/packages/leptos/src/save_off.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SaveOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 13H8a1 1 0 0 0-1 1v7"></path>
+            <path d="M14 8h1"></path>
+            <path d="M17 21v-4"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M20.41 20.41A2 2 0 0 1 19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 .59-1.41"></path>
+            <path d="M29.5 11.5s5 5 4 5"></path>
+            <path d="M9 3h6.2a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scale.rs b/packages/leptos/src/scale.rs
new file mode 100644
index 0000000..6583d66
--- /dev/null
+++ b/packages/leptos/src/scale.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Scale(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 16 3-8 3 8c-.87.65-1.92 1-3 1s-2.13-.35-3-1Z"></path>
+            <path d="m2 16 3-8 3 8c-.87.65-1.92 1-3 1s-2.13-.35-3-1Z"></path>
+            <path d="M7 21h10"></path>
+            <path d="M12 3v18"></path>
+            <path d="M3 7h2c2 0 5-1 7-2 2 1 5 2 7 2h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scale_3_d.rs b/packages/leptos/src/scale_3_d.rs
new file mode 100644
index 0000000..052f0ed
--- /dev/null
+++ b/packages/leptos/src/scale_3_d.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Scale3D(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="19" cy="19" r="2"></circle>
+            <circle cx="5" cy="5" r="2"></circle>
+            <path d="M5 7v12h12"></path>
+            <path d="m5 19 6-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scaling.rs b/packages/leptos/src/scaling.rs
new file mode 100644
index 0000000..2ed6814
--- /dev/null
+++ b/packages/leptos/src/scaling.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Scaling(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path>
+            <path d="M14 15H9v-5"></path>
+            <path d="M16 3h5v5"></path>
+            <path d="M21 3 9 15"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scan.rs b/packages/leptos/src/scan.rs
new file mode 100644
index 0000000..93e9d5d
--- /dev/null
+++ b/packages/leptos/src/scan.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Scan(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scan_barcode.rs b/packages/leptos/src/scan_barcode.rs
new file mode 100644
index 0000000..5f99cc9
--- /dev/null
+++ b/packages/leptos/src/scan_barcode.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScanBarcode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+            <path d="M8 7v10"></path>
+            <path d="M12 7v10"></path>
+            <path d="M17 7v10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scan_eye.rs b/packages/leptos/src/scan_eye.rs
new file mode 100644
index 0000000..ccb4bff
--- /dev/null
+++ b/packages/leptos/src/scan_eye.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScanEye(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+            <circle cx="12" cy="12" r="1"></circle>
+            <path d="M18.944 12.33a1 1 0 0 0 0-.66 7.5 7.5 0 0 0-13.888 0 1 1 0 0 0 0 .66 7.5 7.5 0 0 0 13.888 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scan_face.rs b/packages/leptos/src/scan_face.rs
new file mode 100644
index 0000000..791393e
--- /dev/null
+++ b/packages/leptos/src/scan_face.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScanFace(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+            <path d="M8 14s1.5 2 4 2 4-2 4-2"></path>
+            <path d="M9 9h.01"></path>
+            <path d="M15 9h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scan_line.rs b/packages/leptos/src/scan_line.rs
new file mode 100644
index 0000000..5cbdaba
--- /dev/null
+++ b/packages/leptos/src/scan_line.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScanLine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+            <path d="M7 12h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scan_qr_code.rs b/packages/leptos/src/scan_qr_code.rs
new file mode 100644
index 0000000..2c61fd8
--- /dev/null
+++ b/packages/leptos/src/scan_qr_code.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScanQrCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 12v4a1 1 0 0 1-1 1h-4"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M17 8V7"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M7 17h.01"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+            <rect x="7" y="7" width="5" height="5" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scan_search.rs b/packages/leptos/src/scan_search.rs
new file mode 100644
index 0000000..3d349e2
--- /dev/null
+++ b/packages/leptos/src/scan_search.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScanSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+            <circle cx="12" cy="12" r="3"></circle>
+            <path d="m16 16-1.9-1.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scan_text.rs b/packages/leptos/src/scan_text.rs
new file mode 100644
index 0000000..809d31e
--- /dev/null
+++ b/packages/leptos/src/scan_text.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScanText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2"></path>
+            <path d="M17 3h2a2 2 0 0 1 2 2v2"></path>
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2"></path>
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2"></path>
+            <path d="M7 8h8"></path>
+            <path d="M7 12h10"></path>
+            <path d="M7 16h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/school.rs b/packages/leptos/src/school.rs
new file mode 100644
index 0000000..e2de123
--- /dev/null
+++ b/packages/leptos/src/school.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn School(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 22v-4a2 2 0 1 0-4 0v4"></path>
+            <path d="m18 10 3.447 1.724a1 1 0 0 1 .553.894V20a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-7.382a1 1 0 0 1 .553-.894L6 10"></path>
+            <path d="M18 5v17"></path>
+            <path d="m4 6 7.106-3.553a2 2 0 0 1 1.788 0L20 6"></path>
+            <path d="M6 5v17"></path>
+            <circle cx="12" cy="9" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scissors.rs b/packages/leptos/src/scissors.rs
new file mode 100644
index 0000000..00a5e99
--- /dev/null
+++ b/packages/leptos/src/scissors.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Scissors(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="6" r="3"></circle>
+            <path d="M8.12 8.12 12 12"></path>
+            <path d="M20 4 8.12 15.88"></path>
+            <circle cx="6" cy="18" r="3"></circle>
+            <path d="M14.8 14.8 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scissors_line_dashed.rs b/packages/leptos/src/scissors_line_dashed.rs
new file mode 100644
index 0000000..1a3fdc3
--- /dev/null
+++ b/packages/leptos/src/scissors_line_dashed.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScissorsLineDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5.42 9.42 8 12"></path>
+            <circle cx="4" cy="8" r="2"></circle>
+            <path d="m14 6-8.58 8.58"></path>
+            <circle cx="4" cy="16" r="2"></circle>
+            <path d="M10.8 14.8 14 18"></path>
+            <path d="M16 12h-2"></path>
+            <path d="M22 12h-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/screen_share.rs b/packages/leptos/src/screen_share.rs
new file mode 100644
index 0000000..f1e6108
--- /dev/null
+++ b/packages/leptos/src/screen_share.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScreenShare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 3H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-3"></path>
+            <path d="M8 21h8"></path>
+            <path d="M12 17v4"></path>
+            <path d="m17 8 5-5"></path>
+            <path d="M17 3h5v5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/screen_share_off.rs b/packages/leptos/src/screen_share_off.rs
new file mode 100644
index 0000000..db383dc
--- /dev/null
+++ b/packages/leptos/src/screen_share_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScreenShareOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 3H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-3"></path>
+            <path d="M8 21h8"></path>
+            <path d="M12 17v4"></path>
+            <path d="m22 3-5 5"></path>
+            <path d="m17 3 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scroll.rs b/packages/leptos/src/scroll.rs
new file mode 100644
index 0000000..360bee1
--- /dev/null
+++ b/packages/leptos/src/scroll.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Scroll(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 17V5a2 2 0 0 0-2-2H4"></path>
+            <path d="M8 21h12a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1H11a1 1 0 0 0-1 1v1a2 2 0 1 1-4 0V5a2 2 0 1 0-4 0v2a1 1 0 0 0 1 1h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/scroll_text.rs b/packages/leptos/src/scroll_text.rs
new file mode 100644
index 0000000..879ce71
--- /dev/null
+++ b/packages/leptos/src/scroll_text.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ScrollText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 12h-5"></path>
+            <path d="M15 8h-5"></path>
+            <path d="M19 17V5a2 2 0 0 0-2-2H4"></path>
+            <path d="M8 21h12a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1H11a1 1 0 0 0-1 1v1a2 2 0 1 1-4 0V5a2 2 0 1 0-4 0v2a1 1 0 0 0 1 1h3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/search.rs b/packages/leptos/src/search.rs
new file mode 100644
index 0000000..4302fda
--- /dev/null
+++ b/packages/leptos/src/search.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Search(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="11" r="8"></circle>
+            <path d="m21 21-4.3-4.3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/search_check.rs b/packages/leptos/src/search_check.rs
new file mode 100644
index 0000000..5cf669b
--- /dev/null
+++ b/packages/leptos/src/search_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SearchCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 11 2 2 4-4"></path>
+            <circle cx="11" cy="11" r="8"></circle>
+            <path d="m21 21-4.3-4.3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/search_code.rs b/packages/leptos/src/search_code.rs
new file mode 100644
index 0000000..82f7068
--- /dev/null
+++ b/packages/leptos/src/search_code.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SearchCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m13 13.5 2-2.5-2-2.5"></path>
+            <path d="m21 21-4.3-4.3"></path>
+            <path d="M9 8.5 7 11l2 2.5"></path>
+            <circle cx="11" cy="11" r="8"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/search_slash.rs b/packages/leptos/src/search_slash.rs
new file mode 100644
index 0000000..6e52d29
--- /dev/null
+++ b/packages/leptos/src/search_slash.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SearchSlash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m13.5 8.5-5 5"></path>
+            <circle cx="11" cy="11" r="8"></circle>
+            <path d="m21 21-4.3-4.3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/search_x.rs b/packages/leptos/src/search_x.rs
new file mode 100644
index 0000000..57538da
--- /dev/null
+++ b/packages/leptos/src/search_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SearchX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m13.5 8.5-5 5"></path>
+            <path d="m8.5 8.5 5 5"></path>
+            <circle cx="11" cy="11" r="8"></circle>
+            <path d="m21 21-4.3-4.3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/section.rs b/packages/leptos/src/section.rs
new file mode 100644
index 0000000..1d9ea0b
--- /dev/null
+++ b/packages/leptos/src/section.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Section(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 5a4 3 0 0 0-8 0c0 4 8 3 8 7a4 3 0 0 1-8 0"></path>
+            <path d="M8 19a4 3 0 0 0 8 0c0-4-8-3-8-7a4 3 0 0 1 8 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/send.rs b/packages/leptos/src/send.rs
new file mode 100644
index 0000000..0679d1c
--- /dev/null
+++ b/packages/leptos/src/send.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Send(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.536 21.686a.5.5 0 0 0 .937-.024l6.5-19a.496.496 0 0 0-.635-.635l-19 6.5a.5.5 0 0 0-.024.937l7.93 3.18a2 2 0 0 1 1.112 1.11z"></path>
+            <path d="m21.854 2.147-10.94 10.939"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/send_horizontal.rs b/packages/leptos/src/send_horizontal.rs
new file mode 100644
index 0000000..3652e66
--- /dev/null
+++ b/packages/leptos/src/send_horizontal.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SendHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.714 3.048a.498.498 0 0 0-.683.627l2.843 7.627a2 2 0 0 1 0 1.396l-2.842 7.627a.498.498 0 0 0 .682.627l18-8.5a.5.5 0 0 0 0-.904z"></path>
+            <path d="M6 12h16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/send_to_back.rs b/packages/leptos/src/send_to_back.rs
new file mode 100644
index 0000000..e516e40
--- /dev/null
+++ b/packages/leptos/src/send_to_back.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SendToBack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="14" y="14" width="8" height="8" rx="2"></rect>
+            <rect x="2" y="2" width="8" height="8" rx="2"></rect>
+            <path d="M7 14v1a2 2 0 0 0 2 2h1"></path>
+            <path d="M14 7h1a2 2 0 0 1 2 2v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/separator_horizontal.rs b/packages/leptos/src/separator_horizontal.rs
new file mode 100644
index 0000000..cad1a68
--- /dev/null
+++ b/packages/leptos/src/separator_horizontal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SeparatorHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="3" x2="21" y1="12" y2="12"></line>
+            <polyline points="8 8 12 4 16 8"></polyline>
+            <polyline points="16 16 12 20 8 16"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/separator_vertical.rs b/packages/leptos/src/separator_vertical.rs
new file mode 100644
index 0000000..4cf1c26
--- /dev/null
+++ b/packages/leptos/src/separator_vertical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SeparatorVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="12" y1="3" y2="21"></line>
+            <polyline points="8 8 4 12 8 16"></polyline>
+            <polyline points="16 16 20 12 16 8"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/server.rs b/packages/leptos/src/server.rs
new file mode 100644
index 0000000..27d9c64
--- /dev/null
+++ b/packages/leptos/src/server.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Server(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="8" x="2" y="2" rx="2" ry="2"></rect>
+            <rect width="20" height="8" x="2" y="14" rx="2" ry="2"></rect>
+            <line x1="6" x2="6.01" y1="6" y2="6"></line>
+            <line x1="6" x2="6.01" y1="18" y2="18"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/server_cog.rs b/packages/leptos/src/server_cog.rs
new file mode 100644
index 0000000..adc63fe
--- /dev/null
+++ b/packages/leptos/src/server_cog.rs
@@ -0,0 +1,47 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ServerCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3"></circle>
+            <path d="M4.5 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-.5"></path>
+            <path d="M4.5 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-.5"></path>
+            <path d="M6 6h.01"></path>
+            <path d="M6 18h.01"></path>
+            <path d="m15.7 13.4-.9-.3"></path>
+            <path d="m9.2 10.9-.9-.3"></path>
+            <path d="m10.6 15.7.3-.9"></path>
+            <path d="m13.6 15.7-.4-1"></path>
+            <path d="m10.8 9.3-.4-1"></path>
+            <path d="m8.3 13.6 1-.4"></path>
+            <path d="m14.7 10.8 1-.4"></path>
+            <path d="m13.4 8.3-.3.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/server_crash.rs b/packages/leptos/src/server_crash.rs
new file mode 100644
index 0000000..3aa940c
--- /dev/null
+++ b/packages/leptos/src/server_crash.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ServerCrash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-2"></path>
+            <path d="M6 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-2"></path>
+            <path d="M6 6h.01"></path>
+            <path d="M6 18h.01"></path>
+            <path d="m13 6-4 6h6l-4 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/server_off.rs b/packages/leptos/src/server_off.rs
new file mode 100644
index 0000000..b60e5fc
--- /dev/null
+++ b/packages/leptos/src/server_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ServerOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 2h13a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-5"></path>
+            <path d="M10 10 2.5 2.5C2 2 2 2.5 2 5v3a2 2 0 0 0 2 2h6z"></path>
+            <path d="M22 17v-1a2 2 0 0 0-2-2h-1"></path>
+            <path d="M4 14a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16.5l1-.5.5.5-8-8H4z"></path>
+            <path d="M6 18h.01"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/settings.rs b/packages/leptos/src/settings.rs
new file mode 100644
index 0000000..e89e3b6
--- /dev/null
+++ b/packages/leptos/src/settings.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Settings(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"></path>
+            <circle cx="12" cy="12" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/settings_2.rs b/packages/leptos/src/settings_2.rs
new file mode 100644
index 0000000..22d5095
--- /dev/null
+++ b/packages/leptos/src/settings_2.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Settings2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 7h-9"></path>
+            <path d="M14 17H5"></path>
+            <circle cx="17" cy="17" r="3"></circle>
+            <circle cx="7" cy="7" r="3"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shapes.rs b/packages/leptos/src/shapes.rs
new file mode 100644
index 0000000..26e50a9
--- /dev/null
+++ b/packages/leptos/src/shapes.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Shapes(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.3 10a.7.7 0 0 1-.626-1.079L11.4 3a.7.7 0 0 1 1.198-.043L16.3 8.9a.7.7 0 0 1-.572 1.1Z"></path>
+            <rect x="3" y="14" width="7" height="7" rx="1"></rect>
+            <circle cx="17.5" cy="17.5" r="3.5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/share.rs b/packages/leptos/src/share.rs
new file mode 100644
index 0000000..497eab9
--- /dev/null
+++ b/packages/leptos/src/share.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Share(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8"></path>
+            <polyline points="16 6 12 2 8 6"></polyline>
+            <line x1="12" x2="12" y1="2" y2="15"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/share_2.rs b/packages/leptos/src/share_2.rs
new file mode 100644
index 0000000..1871f9a
--- /dev/null
+++ b/packages/leptos/src/share_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Share2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="5" r="3"></circle>
+            <circle cx="6" cy="12" r="3"></circle>
+            <circle cx="18" cy="19" r="3"></circle>
+            <line x1="8.59" x2="15.42" y1="13.51" y2="17.49"></line>
+            <line x1="15.41" x2="8.59" y1="6.51" y2="10.49"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sheet.rs b/packages/leptos/src/sheet.rs
new file mode 100644
index 0000000..08bbe74
--- /dev/null
+++ b/packages/leptos/src/sheet.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sheet(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <line x1="3" x2="21" y1="9" y2="9"></line>
+            <line x1="3" x2="21" y1="15" y2="15"></line>
+            <line x1="9" x2="9" y1="9" y2="21"></line>
+            <line x1="15" x2="15" y1="9" y2="21"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shell.rs b/packages/leptos/src/shell.rs
new file mode 100644
index 0000000..61a376f
--- /dev/null
+++ b/packages/leptos/src/shell.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Shell(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 11a2 2 0 1 1-4 0 4 4 0 0 1 8 0 6 6 0 0 1-12 0 8 8 0 0 1 16 0 10 10 0 1 1-20 0 11.93 11.93 0 0 1 2.42-7.22 2 2 0 1 1 3.16 2.44"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield.rs b/packages/leptos/src/shield.rs
new file mode 100644
index 0000000..11f513e
--- /dev/null
+++ b/packages/leptos/src/shield.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Shield(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_alert.rs b/packages/leptos/src/shield_alert.rs
new file mode 100644
index 0000000..af9177b
--- /dev/null
+++ b/packages/leptos/src/shield_alert.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldAlert(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="M12 8v4"></path>
+            <path d="M12 16h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_ban.rs b/packages/leptos/src/shield_ban.rs
new file mode 100644
index 0000000..98bd489
--- /dev/null
+++ b/packages/leptos/src/shield_ban.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldBan(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="m4.243 5.21 14.39 12.472"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_check.rs b/packages/leptos/src/shield_check.rs
new file mode 100644
index 0000000..da46dc5
--- /dev/null
+++ b/packages/leptos/src/shield_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="m9 12 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_ellipsis.rs b/packages/leptos/src/shield_ellipsis.rs
new file mode 100644
index 0000000..3012451
--- /dev/null
+++ b/packages/leptos/src/shield_ellipsis.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldEllipsis(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="M8 12h.01"></path>
+            <path d="M12 12h.01"></path>
+            <path d="M16 12h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_half.rs b/packages/leptos/src/shield_half.rs
new file mode 100644
index 0000000..381e19d
--- /dev/null
+++ b/packages/leptos/src/shield_half.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldHalf(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="M12 22V2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_minus.rs b/packages/leptos/src/shield_minus.rs
new file mode 100644
index 0000000..f2fcf0b
--- /dev/null
+++ b/packages/leptos/src/shield_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="M9 12h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_off.rs b/packages/leptos/src/shield_off.rs
new file mode 100644
index 0000000..f0525af
--- /dev/null
+++ b/packages/leptos/src/shield_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 2 20 20"></path>
+            <path d="M5 5a1 1 0 0 0-1 1v7c0 5 3.5 7.5 7.67 8.94a1 1 0 0 0 .67.01c2.35-.82 4.48-1.97 5.9-3.71"></path>
+            <path d="M9.309 3.652A12.252 12.252 0 0 0 11.24 2.28a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1v7a9.784 9.784 0 0 1-.08 1.264"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_plus.rs b/packages/leptos/src/shield_plus.rs
new file mode 100644
index 0000000..4784c6f
--- /dev/null
+++ b/packages/leptos/src/shield_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="M9 12h6"></path>
+            <path d="M12 9v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_question.rs b/packages/leptos/src/shield_question.rs
new file mode 100644
index 0000000..c4b6203
--- /dev/null
+++ b/packages/leptos/src/shield_question.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldQuestion(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3"></path>
+            <path d="M12 17h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shield_x.rs b/packages/leptos/src/shield_x.rs
new file mode 100644
index 0000000..742fbaf
--- /dev/null
+++ b/packages/leptos/src/shield_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShieldX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"></path>
+            <path d="m14.5 9.5-5 5"></path>
+            <path d="m9.5 9.5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ship.rs b/packages/leptos/src/ship.rs
new file mode 100644
index 0000000..514972a
--- /dev/null
+++ b/packages/leptos/src/ship.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ship(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1 .6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"></path>
+            <path d="M19.38 20A11.6 11.6 0 0 0 21 14l-9-4-9 4c0 2.9.94 5.34 2.81 7.76"></path>
+            <path d="M19 13V7a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v6"></path>
+            <path d="M12 10v4"></path>
+            <path d="M12 2v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ship_wheel.rs b/packages/leptos/src/ship_wheel.rs
new file mode 100644
index 0000000..c91ff59
--- /dev/null
+++ b/packages/leptos/src/ship_wheel.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShipWheel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="8"></circle>
+            <path d="M12 2v7.5"></path>
+            <path d="m19 5-5.23 5.23"></path>
+            <path d="M22 12h-7.5"></path>
+            <path d="m19 19-5.23-5.23"></path>
+            <path d="M12 14.5V22"></path>
+            <path d="M10.23 13.77 5 19"></path>
+            <path d="M9.5 12H2"></path>
+            <path d="M10.23 10.23 5 5"></path>
+            <circle cx="12" cy="12" r="2.5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shirt.rs b/packages/leptos/src/shirt.rs
new file mode 100644
index 0000000..05a527f
--- /dev/null
+++ b/packages/leptos/src/shirt.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Shirt(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20.38 3.46 16 2a4 4 0 0 1-8 0L3.62 3.46a2 2 0 0 0-1.34 2.23l.58 3.47a1 1 0 0 0 .99.84H6v10c0 1.1.9 2 2 2h8a2 2 0 0 0 2-2V10h2.15a1 1 0 0 0 .99-.84l.58-3.47a2 2 0 0 0-1.34-2.23z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shopping_bag.rs b/packages/leptos/src/shopping_bag.rs
new file mode 100644
index 0000000..e8d6116
--- /dev/null
+++ b/packages/leptos/src/shopping_bag.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShoppingBag(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 2 3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4Z"></path>
+            <path d="M3 6h18"></path>
+            <path d="M16 10a4 4 0 0 1-8 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shopping_basket.rs b/packages/leptos/src/shopping_basket.rs
new file mode 100644
index 0000000..a708d3b
--- /dev/null
+++ b/packages/leptos/src/shopping_basket.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShoppingBasket(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 11-1 9"></path>
+            <path d="m19 11-4-7"></path>
+            <path d="M2 11h20"></path>
+            <path d="m3.5 11 1.6 7.4a2 2 0 0 0 2 1.6h9.8a2 2 0 0 0 2-1.6l1.7-7.4"></path>
+            <path d="M4.5 15.5h15"></path>
+            <path d="m5 11 4-7"></path>
+            <path d="m9 11 1 9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shopping_cart.rs b/packages/leptos/src/shopping_cart.rs
new file mode 100644
index 0000000..03fc474
--- /dev/null
+++ b/packages/leptos/src/shopping_cart.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShoppingCart(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="8" cy="21" r="1"></circle>
+            <circle cx="19" cy="21" r="1"></circle>
+            <path d="M2.05 2.05h2l2.66 12.42a2 2 0 0 0 2 1.58h9.78a2 2 0 0 0 1.95-1.57l1.65-7.43H5.12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shovel.rs b/packages/leptos/src/shovel.rs
new file mode 100644
index 0000000..f35c75e
--- /dev/null
+++ b/packages/leptos/src/shovel.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Shovel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22v-5l5-5 5 5-5 5z"></path>
+            <path d="M9.5 14.5 16 8"></path>
+            <path d="m17 2 5 5-.5.5a3.53 3.53 0 0 1-5 0s0 0 0 0a3.53 3.53 0 0 1 0-5L17 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shower_head.rs b/packages/leptos/src/shower_head.rs
new file mode 100644
index 0000000..b27c15a
--- /dev/null
+++ b/packages/leptos/src/shower_head.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ShowerHead(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4 4 2.5 2.5"></path>
+            <path d="M13.5 6.5a4.95 4.95 0 0 0-7 7"></path>
+            <path d="M15 5 5 15"></path>
+            <path d="M14 17v.01"></path>
+            <path d="M10 16v.01"></path>
+            <path d="M13 13v.01"></path>
+            <path d="M16 10v.01"></path>
+            <path d="M11 20v.01"></path>
+            <path d="M17 14v.01"></path>
+            <path d="M20 11v.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shrink.rs b/packages/leptos/src/shrink.rs
new file mode 100644
index 0000000..f0c95f4
--- /dev/null
+++ b/packages/leptos/src/shrink.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Shrink(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 15 6 6m-6-6v4.8m0-4.8h4.8"></path>
+            <path d="M9 19.8V15m0 0H4.2M9 15l-6 6"></path>
+            <path d="M15 4.2V9m0 0h4.8M15 9l6-6"></path>
+            <path d="M9 4.2V9m0 0H4.2M9 9 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shrub.rs b/packages/leptos/src/shrub.rs
new file mode 100644
index 0000000..8ef4ce2
--- /dev/null
+++ b/packages/leptos/src/shrub.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Shrub(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-7l-2-2"></path>
+            <path d="M17 8v.8A6 6 0 0 1 13.8 20H10A6.5 6.5 0 0 1 7 8a5 5 0 0 1 10 0Z"></path>
+            <path d="m14 14-2 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/shuffle.rs b/packages/leptos/src/shuffle.rs
new file mode 100644
index 0000000..b03ea65
--- /dev/null
+++ b/packages/leptos/src/shuffle.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Shuffle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 18h1.4c1.3 0 2.5-.6 3.3-1.7l6.1-8.6c.7-1.1 2-1.7 3.3-1.7H22"></path>
+            <path d="m18 2 4 4-4 4"></path>
+            <path d="M2 6h1.9c1.5 0 2.9.9 3.6 2.2"></path>
+            <path d="M22 18h-5.9c-1.3 0-2.6-.7-3.3-1.8l-.5-.8"></path>
+            <path d="m18 14 4 4-4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sigma.rs b/packages/leptos/src/sigma.rs
new file mode 100644
index 0000000..b9ac97a
--- /dev/null
+++ b/packages/leptos/src/sigma.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sigma(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 7V5a1 1 0 0 0-1-1H6.5a.5.5 0 0 0-.4.8l4.5 6a2 2 0 0 1 0 2.4l-4.5 6a.5.5 0 0 0 .4.8H17a1 1 0 0 0 1-1v-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/signal.rs b/packages/leptos/src/signal.rs
new file mode 100644
index 0000000..18e31b4
--- /dev/null
+++ b/packages/leptos/src/signal.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Signal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01"></path>
+            <path d="M7 20v-4"></path>
+            <path d="M12 20v-8"></path>
+            <path d="M17 20V8"></path>
+            <path d="M22 4v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/signal_high.rs b/packages/leptos/src/signal_high.rs
new file mode 100644
index 0000000..63713c4
--- /dev/null
+++ b/packages/leptos/src/signal_high.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SignalHigh(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01"></path>
+            <path d="M7 20v-4"></path>
+            <path d="M12 20v-8"></path>
+            <path d="M17 20V8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/signal_low.rs b/packages/leptos/src/signal_low.rs
new file mode 100644
index 0000000..262b263
--- /dev/null
+++ b/packages/leptos/src/signal_low.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SignalLow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01"></path>
+            <path d="M7 20v-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/signal_medium.rs b/packages/leptos/src/signal_medium.rs
new file mode 100644
index 0000000..e16189b
--- /dev/null
+++ b/packages/leptos/src/signal_medium.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SignalMedium(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01"></path>
+            <path d="M7 20v-4"></path>
+            <path d="M12 20v-8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/signal_zero.rs b/packages/leptos/src/signal_zero.rs
new file mode 100644
index 0000000..e521514
--- /dev/null
+++ b/packages/leptos/src/signal_zero.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SignalZero(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/signature.rs b/packages/leptos/src/signature.rs
new file mode 100644
index 0000000..249873b
--- /dev/null
+++ b/packages/leptos/src/signature.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Signature(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21 17-2.156-1.868A.5.5 0 0 0 18 15.5v.5a1 1 0 0 1-1 1h-2a1 1 0 0 1-1-1c0-2.545-3.991-3.97-8.5-4a1 1 0 0 0 0 5c4.153 0 4.745-11.295 5.708-13.5a2.5 2.5 0 1 1 3.31 3.284"></path>
+            <path d="M3 21h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/signpost.rs b/packages/leptos/src/signpost.rs
new file mode 100644
index 0000000..6c2d1cf
--- /dev/null
+++ b/packages/leptos/src/signpost.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Signpost(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13v8"></path>
+            <path d="M12 3v3"></path>
+            <path d="M18 6a2 2 0 0 1 1.387.56l2.307 2.22a1 1 0 0 1 0 1.44l-2.307 2.22A2 2 0 0 1 18 13H6a2 2 0 0 1-1.387-.56l-2.306-2.22a1 1 0 0 1 0-1.44l2.306-2.22A2 2 0 0 1 6 6z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/signpost_big.rs b/packages/leptos/src/signpost_big.rs
new file mode 100644
index 0000000..7d7b36f
--- /dev/null
+++ b/packages/leptos/src/signpost_big.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SignpostBig(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9H4L2 7l2-2h6"></path>
+            <path d="M14 5h6l2 2-2 2h-6"></path>
+            <path d="M10 22V4a2 2 0 1 1 4 0v18"></path>
+            <path d="M8 22h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/siren.rs b/packages/leptos/src/siren.rs
new file mode 100644
index 0000000..a632fda
--- /dev/null
+++ b/packages/leptos/src/siren.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Siren(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 18v-6a5 5 0 1 1 10 0v6"></path>
+            <path d="M5 21a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-1a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2z"></path>
+            <path d="M21 12h1"></path>
+            <path d="M18.5 4.5 18 5"></path>
+            <path d="M2 12h1"></path>
+            <path d="M12 2v1"></path>
+            <path d="m4.929 4.929.707.707"></path>
+            <path d="M12 12v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/skip_back.rs b/packages/leptos/src/skip_back.rs
new file mode 100644
index 0000000..f3337e2
--- /dev/null
+++ b/packages/leptos/src/skip_back.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SkipBack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="19 20 9 12 19 4 19 20"></polygon>
+            <line x1="5" x2="5" y1="19" y2="5"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/skip_forward.rs b/packages/leptos/src/skip_forward.rs
new file mode 100644
index 0000000..5f340a1
--- /dev/null
+++ b/packages/leptos/src/skip_forward.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SkipForward(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="5 4 15 12 5 20 5 4"></polygon>
+            <line x1="19" x2="19" y1="5" y2="19"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/skull.rs b/packages/leptos/src/skull.rs
new file mode 100644
index 0000000..3ca5823
--- /dev/null
+++ b/packages/leptos/src/skull.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Skull(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12.5 17-.5-1-.5 1h1z"></path>
+            <path d="M15 22a1 1 0 0 0 1-1v-1a2 2 0 0 0 1.56-3.25 8 8 0 1 0-11.12 0A2 2 0 0 0 8 20v1a1 1 0 0 0 1 1z"></path>
+            <circle cx="15" cy="12" r="1"></circle>
+            <circle cx="9" cy="12" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/slack.rs b/packages/leptos/src/slack.rs
new file mode 100644
index 0000000..1c76c52
--- /dev/null
+++ b/packages/leptos/src/slack.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Slack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="3" height="8" x="13" y="2" rx="1.5"></rect>
+            <path d="M19 8.5V10h1.5A1.5 1.5 0 1 0 19 8.5"></path>
+            <rect width="3" height="8" x="8" y="14" rx="1.5"></rect>
+            <path d="M5 15.5V14H3.5A1.5 1.5 0 1 0 5 15.5"></path>
+            <rect width="8" height="3" x="14" y="13" rx="1.5"></rect>
+            <path d="M15.5 19H14v1.5a1.5 1.5 0 1 0 1.5-1.5"></path>
+            <rect width="8" height="3" x="2" y="8" rx="1.5"></rect>
+            <path d="M8.5 5H10V3.5A1.5 1.5 0 1 0 8.5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/slash.rs b/packages/leptos/src/slash.rs
new file mode 100644
index 0000000..841c0bf
--- /dev/null
+++ b/packages/leptos/src/slash.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Slash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 2 2 22"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/slice.rs b/packages/leptos/src/slice.rs
new file mode 100644
index 0000000..d3c3cd7
--- /dev/null
+++ b/packages/leptos/src/slice.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Slice(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 16.586V19a1 1 0 0 1-1 1H2L18.37 3.63a1 1 0 1 1 3 3l-9.663 9.663a1 1 0 0 1-1.414 0L8 14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sliders_horizontal.rs b/packages/leptos/src/sliders_horizontal.rs
new file mode 100644
index 0000000..d9e0ef7
--- /dev/null
+++ b/packages/leptos/src/sliders_horizontal.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SlidersHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="21" x2="14" y1="4" y2="4"></line>
+            <line x1="10" x2="3" y1="4" y2="4"></line>
+            <line x1="21" x2="12" y1="12" y2="12"></line>
+            <line x1="8" x2="3" y1="12" y2="12"></line>
+            <line x1="21" x2="16" y1="20" y2="20"></line>
+            <line x1="12" x2="3" y1="20" y2="20"></line>
+            <line x1="14" x2="14" y1="2" y2="6"></line>
+            <line x1="8" x2="8" y1="10" y2="14"></line>
+            <line x1="16" x2="16" y1="18" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sliders_vertical.rs b/packages/leptos/src/sliders_vertical.rs
new file mode 100644
index 0000000..6468351
--- /dev/null
+++ b/packages/leptos/src/sliders_vertical.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SlidersVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="4" x2="4" y1="21" y2="14"></line>
+            <line x1="4" x2="4" y1="10" y2="3"></line>
+            <line x1="12" x2="12" y1="21" y2="12"></line>
+            <line x1="12" x2="12" y1="8" y2="3"></line>
+            <line x1="20" x2="20" y1="21" y2="16"></line>
+            <line x1="20" x2="20" y1="12" y2="3"></line>
+            <line x1="2" x2="6" y1="14" y2="14"></line>
+            <line x1="10" x2="14" y1="8" y2="8"></line>
+            <line x1="18" x2="22" y1="16" y2="16"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/smartphone.rs b/packages/leptos/src/smartphone.rs
new file mode 100644
index 0000000..563d1f0
--- /dev/null
+++ b/packages/leptos/src/smartphone.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Smartphone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="20" x="5" y="2" rx="2" ry="2"></rect>
+            <path d="M12 18h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/smartphone_charging.rs b/packages/leptos/src/smartphone_charging.rs
new file mode 100644
index 0000000..d6233ce
--- /dev/null
+++ b/packages/leptos/src/smartphone_charging.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SmartphoneCharging(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="20" x="5" y="2" rx="2" ry="2"></rect>
+            <path d="M12.667 8 10 12h4l-2.667 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/smartphone_nfc.rs b/packages/leptos/src/smartphone_nfc.rs
new file mode 100644
index 0000000..80711b4
--- /dev/null
+++ b/packages/leptos/src/smartphone_nfc.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SmartphoneNfc(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="12" x="2" y="6" rx="1"></rect>
+            <path d="M13 8.32a7.43 7.43 0 0 1 0 7.36"></path>
+            <path d="M16.46 6.21a11.76 11.76 0 0 1 0 11.58"></path>
+            <path d="M19.91 4.1a15.91 15.91 0 0 1 .01 15.8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/smile.rs b/packages/leptos/src/smile.rs
new file mode 100644
index 0000000..0b2a6da
--- /dev/null
+++ b/packages/leptos/src/smile.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Smile(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <path d="M8 14s1.5 2 4 2 4-2 4-2"></path>
+            <line x1="9" x2="9.01" y1="9" y2="9"></line>
+            <line x1="15" x2="15.01" y1="9" y2="9"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/smile_plus.rs b/packages/leptos/src/smile_plus.rs
new file mode 100644
index 0000000..b4a7616
--- /dev/null
+++ b/packages/leptos/src/smile_plus.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SmilePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 11v1a10 10 0 1 1-9-10"></path>
+            <path d="M8 14s1.5 2 4 2 4-2 4-2"></path>
+            <line x1="9" x2="9.01" y1="9" y2="9"></line>
+            <line x1="15" x2="15.01" y1="9" y2="9"></line>
+            <path d="M16 5h6"></path>
+            <path d="M19 2v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/snail.rs b/packages/leptos/src/snail.rs
new file mode 100644
index 0000000..47075f9
--- /dev/null
+++ b/packages/leptos/src/snail.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Snail(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 13a6 6 0 1 0 12 0 4 4 0 1 0-8 0 2 2 0 0 0 4 0"></path>
+            <circle cx="10" cy="13" r="8"></circle>
+            <path d="M2 21h12c4.4 0 8-3.6 8-8V7a2 2 0 1 0-4 0v6"></path>
+            <path d="M18 3 19.1 5.2"></path>
+            <path d="M22 3 20.9 5.2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/snowflake.rs b/packages/leptos/src/snowflake.rs
new file mode 100644
index 0000000..ba7b795
--- /dev/null
+++ b/packages/leptos/src/snowflake.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Snowflake(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="22" y1="12" y2="12"></line>
+            <line x1="12" x2="12" y1="2" y2="22"></line>
+            <path d="m20 16-4-4 4-4"></path>
+            <path d="m4 8 4 4-4 4"></path>
+            <path d="m16 4-4 4-4-4"></path>
+            <path d="m8 20 4-4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sofa.rs b/packages/leptos/src/sofa.rs
new file mode 100644
index 0000000..70ec9a8
--- /dev/null
+++ b/packages/leptos/src/sofa.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sofa(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 9V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v3"></path>
+            <path d="M2 16a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-11a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z"></path>
+            <path d="M4 18v2"></path>
+            <path d="M20 18v2"></path>
+            <path d="M12 4v9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/soup.rs b/packages/leptos/src/soup.rs
new file mode 100644
index 0000000..6f548e5
--- /dev/null
+++ b/packages/leptos/src/soup.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Soup(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 21a9 9 0 0 0 9-9H3a9 9 0 0 0 9 9Z"></path>
+            <path d="M7 21h10"></path>
+            <path d="M19.5 12 22 6"></path>
+            <path d="M16.25 3c.27.1.8.53.75 1.36-.06.83-.93 1.2-1 2.02-.05.78.34 1.24.73 1.62"></path>
+            <path d="M11.25 3c.27.1.8.53.74 1.36-.05.83-.93 1.2-.98 2.02-.06.78.33 1.24.72 1.62"></path>
+            <path d="M6.25 3c.27.1.8.53.75 1.36-.06.83-.93 1.2-1 2.02-.05.78.34 1.24.74 1.62"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/space.rs b/packages/leptos/src/space.rs
new file mode 100644
index 0000000..a5f6bc4
--- /dev/null
+++ b/packages/leptos/src/space.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Space(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/spade.rs b/packages/leptos/src/spade.rs
new file mode 100644
index 0000000..fcd6068
--- /dev/null
+++ b/packages/leptos/src/spade.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Spade(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 9c-1.5 1.5-3 3.2-3 5.5A5.5 5.5 0 0 0 7.5 20c1.8 0 3-.5 4.5-2 1.5 1.5 2.7 2 4.5 2a5.5 5.5 0 0 0 5.5-5.5c0-2.3-1.5-4-3-5.5l-7-7-7 7Z"></path>
+            <path d="M12 18v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sparkle.rs b/packages/leptos/src/sparkle.rs
new file mode 100644
index 0000000..11f03ef
--- /dev/null
+++ b/packages/leptos/src/sparkle.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sparkle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .963 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.963 0z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sparkles.rs b/packages/leptos/src/sparkles.rs
new file mode 100644
index 0000000..7e29a97
--- /dev/null
+++ b/packages/leptos/src/sparkles.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sparkles(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .963 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.963 0z"></path>
+            <path d="M20 3v4"></path>
+            <path d="M22 5h-4"></path>
+            <path d="M4 17v2"></path>
+            <path d="M5 18H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/speaker.rs b/packages/leptos/src/speaker.rs
new file mode 100644
index 0000000..60a9c27
--- /dev/null
+++ b/packages/leptos/src/speaker.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Speaker(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="20" x="4" y="2" rx="2"></rect>
+            <path d="M12 6h.01"></path>
+            <circle cx="12" cy="14" r="4"></circle>
+            <path d="M12 14h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/speech.rs b/packages/leptos/src/speech.rs
new file mode 100644
index 0000000..498e3e9
--- /dev/null
+++ b/packages/leptos/src/speech.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Speech(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.8 20v-4.1l1.9.2a2.3 2.3 0 0 0 2.164-2.1V8.3A5.37 5.37 0 0 0 2 8.25c0 2.8.656 3.054 1 4.55a5.77 5.77 0 0 1 .029 2.758L2 20"></path>
+            <path d="M19.8 17.8a7.5 7.5 0 0 0 .003-10.603"></path>
+            <path d="M17 15a3.5 3.5 0 0 0-.025-4.975"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/spell_check.rs b/packages/leptos/src/spell_check.rs
new file mode 100644
index 0000000..2f62f82
--- /dev/null
+++ b/packages/leptos/src/spell_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SpellCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 16 6-12 6 12"></path>
+            <path d="M8 12h8"></path>
+            <path d="m16 20 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/spell_check_2.rs b/packages/leptos/src/spell_check_2.rs
new file mode 100644
index 0000000..578b20c
--- /dev/null
+++ b/packages/leptos/src/spell_check_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SpellCheck2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 16 6-12 6 12"></path>
+            <path d="M8 12h8"></path>
+            <path d="M4 21c1.1 0 1.1-1 2.3-1s1.1 1 2.3 1c1.1 0 1.1-1 2.3-1 1.1 0 1.1 1 2.3 1 1.1 0 1.1-1 2.3-1 1.1 0 1.1 1 2.3 1 1.1 0 1.1-1 2.3-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/spline.rs b/packages/leptos/src/spline.rs
new file mode 100644
index 0000000..96adeac
--- /dev/null
+++ b/packages/leptos/src/spline.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Spline(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="19" cy="5" r="2"></circle>
+            <circle cx="5" cy="19" r="2"></circle>
+            <path d="M5 17A12 12 0 0 1 17 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/split.rs b/packages/leptos/src/split.rs
new file mode 100644
index 0000000..2a73886
--- /dev/null
+++ b/packages/leptos/src/split.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Split(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 3h5v5"></path>
+            <path d="M8 3H3v5"></path>
+            <path d="M12 22v-8.3a4 4 0 0 0-1.172-2.872L3 3"></path>
+            <path d="m15 9 6-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/spray_can.rs b/packages/leptos/src/spray_can.rs
new file mode 100644
index 0000000..d73fb97
--- /dev/null
+++ b/packages/leptos/src/spray_can.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SprayCan(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3h.01"></path>
+            <path d="M7 5h.01"></path>
+            <path d="M11 7h.01"></path>
+            <path d="M3 7h.01"></path>
+            <path d="M7 9h.01"></path>
+            <path d="M3 11h.01"></path>
+            <rect width="4" height="4" x="15" y="5"></rect>
+            <path d="m19 9 2 2v10c0 .6-.4 1-1 1h-6c-.6 0-1-.4-1-1V11l2-2"></path>
+            <path d="m13 14 8-2"></path>
+            <path d="m13 19 8-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sprout.rs b/packages/leptos/src/sprout.rs
new file mode 100644
index 0000000..34bb268
--- /dev/null
+++ b/packages/leptos/src/sprout.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sprout(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 20h10"></path>
+            <path d="M10 20c5.5-2.5.8-6.4 3-10"></path>
+            <path d="M9.5 9.4c1.1.8 1.8 2.2 2.3 3.7-2 .4-3.5.4-4.8-.3-1.2-.6-2.3-1.9-3-4.2 2.8-.5 4.4 0 5.5.8z"></path>
+            <path d="M14.1 6a7 7 0 0 0-1.1 4c1.9-.1 3.3-.6 4.3-1.4 1-1 1.6-2.3 1.7-4.6-2.7.1-4 1-4.9 2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square.rs b/packages/leptos/src/square.rs
new file mode 100644
index 0000000..eaeb0fc
--- /dev/null
+++ b/packages/leptos/src/square.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Square(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_activity.rs b/packages/leptos/src/square_activity.rs
new file mode 100644
index 0000000..f86a559
--- /dev/null
+++ b/packages/leptos/src/square_activity.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareActivity(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M17 12h-2l-2 5-2-10-2 5H7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_down.rs b/packages/leptos/src/square_arrow_down.rs
new file mode 100644
index 0000000..de00af7
--- /dev/null
+++ b/packages/leptos/src/square_arrow_down.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M12 8v8"></path>
+            <path d="m8 12 4 4 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_down_left.rs b/packages/leptos/src/square_arrow_down_left.rs
new file mode 100644
index 0000000..0390d33
--- /dev/null
+++ b/packages/leptos/src/square_arrow_down_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowDownLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m16 8-8 8"></path>
+            <path d="M16 16H8V8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_down_right.rs b/packages/leptos/src/square_arrow_down_right.rs
new file mode 100644
index 0000000..4184308
--- /dev/null
+++ b/packages/leptos/src/square_arrow_down_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowDownRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m8 8 8 8"></path>
+            <path d="M16 8v8H8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_left.rs b/packages/leptos/src/square_arrow_left.rs
new file mode 100644
index 0000000..3984964
--- /dev/null
+++ b/packages/leptos/src/square_arrow_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m12 8-4 4 4 4"></path>
+            <path d="M16 12H8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_out_down_left.rs b/packages/leptos/src/square_arrow_out_down_left.rs
new file mode 100644
index 0000000..b93ea2d
--- /dev/null
+++ b/packages/leptos/src/square_arrow_out_down_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowOutDownLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 21h6a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6"></path>
+            <path d="m3 21 9-9"></path>
+            <path d="M9 21H3v-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_out_down_right.rs b/packages/leptos/src/square_arrow_out_down_right.rs
new file mode 100644
index 0000000..9e8e60e
--- /dev/null
+++ b/packages/leptos/src/square_arrow_out_down_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowOutDownRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 11V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6"></path>
+            <path d="m21 21-9-9"></path>
+            <path d="M21 15v6h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_out_up_left.rs b/packages/leptos/src/square_arrow_out_up_left.rs
new file mode 100644
index 0000000..8060522
--- /dev/null
+++ b/packages/leptos/src/square_arrow_out_up_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowOutUpLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-6"></path>
+            <path d="m3 3 9 9"></path>
+            <path d="M3 9V3h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_out_up_right.rs b/packages/leptos/src/square_arrow_out_up_right.rs
new file mode 100644
index 0000000..f95bec3
--- /dev/null
+++ b/packages/leptos/src/square_arrow_out_up_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowOutUpRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h6"></path>
+            <path d="m21 3-9 9"></path>
+            <path d="M15 3h6v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_right.rs b/packages/leptos/src/square_arrow_right.rs
new file mode 100644
index 0000000..1e12130
--- /dev/null
+++ b/packages/leptos/src/square_arrow_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M8 12h8"></path>
+            <path d="m12 16 4-4-4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_up.rs b/packages/leptos/src/square_arrow_up.rs
new file mode 100644
index 0000000..b1d1d06
--- /dev/null
+++ b/packages/leptos/src/square_arrow_up.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m16 12-4-4-4 4"></path>
+            <path d="M12 16V8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_up_left.rs b/packages/leptos/src/square_arrow_up_left.rs
new file mode 100644
index 0000000..778b9d0
--- /dev/null
+++ b/packages/leptos/src/square_arrow_up_left.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowUpLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M8 16V8h8"></path>
+            <path d="M16 16 8 8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_arrow_up_right.rs b/packages/leptos/src/square_arrow_up_right.rs
new file mode 100644
index 0000000..20c7d93
--- /dev/null
+++ b/packages/leptos/src/square_arrow_up_right.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareArrowUpRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M8 8h8v8"></path>
+            <path d="m8 16 8-8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_asterisk.rs b/packages/leptos/src/square_asterisk.rs
new file mode 100644
index 0000000..d54b5e4
--- /dev/null
+++ b/packages/leptos/src/square_asterisk.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareAsterisk(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M12 8v8"></path>
+            <path d="m8.5 14 7-4"></path>
+            <path d="m8.5 10 7 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_bottom_dashed_scissors.rs b/packages/leptos/src/square_bottom_dashed_scissors.rs
new file mode 100644
index 0000000..ca3d160
--- /dev/null
+++ b/packages/leptos/src/square_bottom_dashed_scissors.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareBottomDashedScissors(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2"></path>
+            <path d="M10 22H8"></path>
+            <path d="M16 22h-2"></path>
+            <circle cx="8" cy="8" r="2"></circle>
+            <path d="M9.414 9.414 12 12"></path>
+            <path d="M14.8 14.8 18 18"></path>
+            <circle cx="8" cy="16" r="2"></circle>
+            <path d="m18 6-8.586 8.586"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_chart_gantt.rs b/packages/leptos/src/square_chart_gantt.rs
new file mode 100644
index 0000000..be8b153
--- /dev/null
+++ b/packages/leptos/src/square_chart_gantt.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareChartGantt(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M9 8h7"></path>
+            <path d="M8 12h6"></path>
+            <path d="M11 16h5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_check.rs b/packages/leptos/src/square_check.rs
new file mode 100644
index 0000000..9ee4a67
--- /dev/null
+++ b/packages/leptos/src/square_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m9 12 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_check_big.rs b/packages/leptos/src/square_check_big.rs
new file mode 100644
index 0000000..f5dc534
--- /dev/null
+++ b/packages/leptos/src/square_check_big.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareCheckBig(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 10.5V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h12.5"></path>
+            <path d="m9 11 3 3L22 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_chevron_down.rs b/packages/leptos/src/square_chevron_down.rs
new file mode 100644
index 0000000..4c952e8
--- /dev/null
+++ b/packages/leptos/src/square_chevron_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareChevronDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m16 10-4 4-4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_chevron_left.rs b/packages/leptos/src/square_chevron_left.rs
new file mode 100644
index 0000000..ff5189a
--- /dev/null
+++ b/packages/leptos/src/square_chevron_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareChevronLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m14 16-4-4 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_chevron_right.rs b/packages/leptos/src/square_chevron_right.rs
new file mode 100644
index 0000000..46a91a7
--- /dev/null
+++ b/packages/leptos/src/square_chevron_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareChevronRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m10 8 4 4-4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_chevron_up.rs b/packages/leptos/src/square_chevron_up.rs
new file mode 100644
index 0000000..2399f21
--- /dev/null
+++ b/packages/leptos/src/square_chevron_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareChevronUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m8 14 4-4 4 4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_code.rs b/packages/leptos/src/square_code.rs
new file mode 100644
index 0000000..d7dd5db
--- /dev/null
+++ b/packages/leptos/src/square_code.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9.5 8 12l2 2.5"></path>
+            <path d="m14 9.5 2 2.5-2 2.5"></path>
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_dashed.rs b/packages/leptos/src/square_dashed.rs
new file mode 100644
index 0000000..740fdf9
--- /dev/null
+++ b/packages/leptos/src/square_dashed.rs
@@ -0,0 +1,46 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareDashed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 3a2 2 0 0 0-2 2"></path>
+            <path d="M19 3a2 2 0 0 1 2 2"></path>
+            <path d="M21 19a2 2 0 0 1-2 2"></path>
+            <path d="M5 21a2 2 0 0 1-2-2"></path>
+            <path d="M9 3h1"></path>
+            <path d="M9 21h1"></path>
+            <path d="M14 3h1"></path>
+            <path d="M14 21h1"></path>
+            <path d="M3 9v1"></path>
+            <path d="M21 9v1"></path>
+            <path d="M3 14v1"></path>
+            <path d="M21 14v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_dashed_bottom.rs b/packages/leptos/src/square_dashed_bottom.rs
new file mode 100644
index 0000000..a09881c
--- /dev/null
+++ b/packages/leptos/src/square_dashed_bottom.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareDashedBottom(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 21a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2"></path>
+            <path d="M9 21h1"></path>
+            <path d="M14 21h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_dashed_bottom_code.rs b/packages/leptos/src/square_dashed_bottom_code.rs
new file mode 100644
index 0000000..98973c3
--- /dev/null
+++ b/packages/leptos/src/square_dashed_bottom_code.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareDashedBottomCode(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9.5 8 12l2 2.5"></path>
+            <path d="M14 21h1"></path>
+            <path d="m14 9.5 2 2.5-2 2.5"></path>
+            <path d="M5 21a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2"></path>
+            <path d="M9 21h1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_dashed_kanban.rs b/packages/leptos/src/square_dashed_kanban.rs
new file mode 100644
index 0000000..11e50ec
--- /dev/null
+++ b/packages/leptos/src/square_dashed_kanban.rs
@@ -0,0 +1,49 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareDashedKanban(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 7v7"></path>
+            <path d="M12 7v4"></path>
+            <path d="M16 7v9"></path>
+            <path d="M5 3a2 2 0 0 0-2 2"></path>
+            <path d="M9 3h1"></path>
+            <path d="M14 3h1"></path>
+            <path d="M19 3a2 2 0 0 1 2 2"></path>
+            <path d="M21 9v1"></path>
+            <path d="M21 14v1"></path>
+            <path d="M21 19a2 2 0 0 1-2 2"></path>
+            <path d="M14 21h1"></path>
+            <path d="M9 21h1"></path>
+            <path d="M5 21a2 2 0 0 1-2-2"></path>
+            <path d="M3 14v1"></path>
+            <path d="M3 9v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_dashed_mouse_pointer.rs b/packages/leptos/src/square_dashed_mouse_pointer.rs
new file mode 100644
index 0000000..3fb967f
--- /dev/null
+++ b/packages/leptos/src/square_dashed_mouse_pointer.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareDashedMousePointer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z"></path>
+            <path d="M5 3a2 2 0 0 0-2 2"></path>
+            <path d="M19 3a2 2 0 0 1 2 2"></path>
+            <path d="M5 21a2 2 0 0 1-2-2"></path>
+            <path d="M9 3h1"></path>
+            <path d="M9 21h2"></path>
+            <path d="M14 3h1"></path>
+            <path d="M3 9v1"></path>
+            <path d="M21 9v2"></path>
+            <path d="M3 14v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_divide.rs b/packages/leptos/src/square_divide.rs
new file mode 100644
index 0000000..54564f4
--- /dev/null
+++ b/packages/leptos/src/square_divide.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareDivide(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <line x1="8" x2="16" y1="12" y2="12"></line>
+            <line x1="12" x2="12" y1="16" y2="16"></line>
+            <line x1="12" x2="12" y1="8" y2="8"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_dot.rs b/packages/leptos/src/square_dot.rs
new file mode 100644
index 0000000..1dccc94
--- /dev/null
+++ b/packages/leptos/src/square_dot.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <circle cx="12" cy="12" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_equal.rs b/packages/leptos/src/square_equal.rs
new file mode 100644
index 0000000..e1b3724
--- /dev/null
+++ b/packages/leptos/src/square_equal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareEqual(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M7 10h10"></path>
+            <path d="M7 14h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_function.rs b/packages/leptos/src/square_function.rs
new file mode 100644
index 0000000..8344ee1
--- /dev/null
+++ b/packages/leptos/src/square_function.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareFunction(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <path d="M9 17c2 0 2.8-1 2.8-2.8V10c0-2 1-3.3 3.2-3"></path>
+            <path d="M9 11.2h5.7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_kanban.rs b/packages/leptos/src/square_kanban.rs
new file mode 100644
index 0000000..5a697e9
--- /dev/null
+++ b/packages/leptos/src/square_kanban.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareKanban(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M8 7v7"></path>
+            <path d="M12 7v4"></path>
+            <path d="M16 7v9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_library.rs b/packages/leptos/src/square_library.rs
new file mode 100644
index 0000000..4569011
--- /dev/null
+++ b/packages/leptos/src/square_library.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareLibrary(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M7 7v10"></path>
+            <path d="M11 7v10"></path>
+            <path d="m15 7 2 10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_m.rs b/packages/leptos/src/square_m.rs
new file mode 100644
index 0000000..54f68bf
--- /dev/null
+++ b/packages/leptos/src/square_m.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareM(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M8 16V8l4 4 4-4v8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_menu.rs b/packages/leptos/src/square_menu.rs
new file mode 100644
index 0000000..7c7ad8b
--- /dev/null
+++ b/packages/leptos/src/square_menu.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareMenu(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M7 8h10"></path>
+            <path d="M7 12h10"></path>
+            <path d="M7 16h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_minus.rs b/packages/leptos/src/square_minus.rs
new file mode 100644
index 0000000..8fb517d
--- /dev/null
+++ b/packages/leptos/src/square_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M8 12h8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_mouse_pointer.rs b/packages/leptos/src/square_mouse_pointer.rs
new file mode 100644
index 0000000..dfe0da6
--- /dev/null
+++ b/packages/leptos/src/square_mouse_pointer.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareMousePointer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z"></path>
+            <path d="M21 11V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_parking.rs b/packages/leptos/src/square_parking.rs
new file mode 100644
index 0000000..ec3cf0f
--- /dev/null
+++ b/packages/leptos/src/square_parking.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareParking(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M9 17V7h4a3 3 0 0 1 0 6H9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_parking_off.rs b/packages/leptos/src/square_parking_off.rs
new file mode 100644
index 0000000..41208a4
--- /dev/null
+++ b/packages/leptos/src/square_parking_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareParkingOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.6 3.6A2 2 0 0 1 5 3h14a2 2 0 0 1 2 2v14a2 2 0 0 1-.59 1.41"></path>
+            <path d="M3 8.7V19a2 2 0 0 0 2 2h10.3"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M13 13a3 3 0 1 0 0-6H9v2"></path>
+            <path d="M9 17v-2.3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_pen.rs b/packages/leptos/src/square_pen.rs
new file mode 100644
index 0000000..c29204b
--- /dev/null
+++ b/packages/leptos/src/square_pen.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquarePen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path>
+            <path d="M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_percent.rs b/packages/leptos/src/square_percent.rs
new file mode 100644
index 0000000..f6451f1
--- /dev/null
+++ b/packages/leptos/src/square_percent.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquarePercent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m15 9-6 6"></path>
+            <path d="M9 9h.01"></path>
+            <path d="M15 15h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_pi.rs b/packages/leptos/src/square_pi.rs
new file mode 100644
index 0000000..0e55522
--- /dev/null
+++ b/packages/leptos/src/square_pi.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquarePi(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M7 7h10"></path>
+            <path d="M10 7v10"></path>
+            <path d="M16 17a2 2 0 0 1-2-2V7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_pilcrow.rs b/packages/leptos/src/square_pilcrow.rs
new file mode 100644
index 0000000..78d15cb
--- /dev/null
+++ b/packages/leptos/src/square_pilcrow.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquarePilcrow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M12 12H9.5a2.5 2.5 0 0 1 0-5H17"></path>
+            <path d="M12 7v10"></path>
+            <path d="M16 7v10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_play.rs b/packages/leptos/src/square_play.rs
new file mode 100644
index 0000000..bb93555
--- /dev/null
+++ b/packages/leptos/src/square_play.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquarePlay(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="m9 8 6 4-6 4Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_plus.rs b/packages/leptos/src/square_plus.rs
new file mode 100644
index 0000000..bf7b846
--- /dev/null
+++ b/packages/leptos/src/square_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquarePlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M8 12h8"></path>
+            <path d="M12 8v8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_power.rs b/packages/leptos/src/square_power.rs
new file mode 100644
index 0000000..0cd7423
--- /dev/null
+++ b/packages/leptos/src/square_power.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquarePower(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v4"></path>
+            <path d="M7.998 9.003a5 5 0 1 0 8-.005"></path>
+            <rect x="3" y="3" width="18" height="18" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_radical.rs b/packages/leptos/src/square_radical.rs
new file mode 100644
index 0000000..95f189e
--- /dev/null
+++ b/packages/leptos/src/square_radical.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareRadical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 12h2l2 5 2-10h4"></path>
+            <rect x="3" y="3" width="18" height="18" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_scissors.rs b/packages/leptos/src/square_scissors.rs
new file mode 100644
index 0000000..0abfccb
--- /dev/null
+++ b/packages/leptos/src/square_scissors.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareScissors(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="20" x="2" y="2" rx="2"></rect>
+            <circle cx="8" cy="8" r="2"></circle>
+            <path d="M9.414 9.414 12 12"></path>
+            <path d="M14.8 14.8 18 18"></path>
+            <circle cx="8" cy="16" r="2"></circle>
+            <path d="m18 6-8.586 8.586"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_sigma.rs b/packages/leptos/src/square_sigma.rs
new file mode 100644
index 0000000..84b66e4
--- /dev/null
+++ b/packages/leptos/src/square_sigma.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareSigma(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M16 8.9V7H8l4 5-4 5h8v-1.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_slash.rs b/packages/leptos/src/square_slash.rs
new file mode 100644
index 0000000..760028c
--- /dev/null
+++ b/packages/leptos/src/square_slash.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareSlash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <line x1="9" x2="15" y1="15" y2="9"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_split_horizontal.rs b/packages/leptos/src/square_split_horizontal.rs
new file mode 100644
index 0000000..b7dc6af
--- /dev/null
+++ b/packages/leptos/src/square_split_horizontal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareSplitHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 19H5c-1 0-2-1-2-2V7c0-1 1-2 2-2h3"></path>
+            <path d="M16 5h3c1 0 2 1 2 2v10c0 1-1 2-2 2h-3"></path>
+            <line x1="12" x2="12" y1="4" y2="20"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_split_vertical.rs b/packages/leptos/src/square_split_vertical.rs
new file mode 100644
index 0000000..74ecc0e
--- /dev/null
+++ b/packages/leptos/src/square_split_vertical.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareSplitVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 8V5c0-1 1-2 2-2h10c1 0 2 1 2 2v3"></path>
+            <path d="M19 16v3c0 1-1 2-2 2H7c-1 0-2-1-2-2v-3"></path>
+            <line x1="4" x2="20" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_square.rs b/packages/leptos/src/square_square.rs
new file mode 100644
index 0000000..70e2e2c
--- /dev/null
+++ b/packages/leptos/src/square_square.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareSquare(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="3" y="3" width="18" height="18" rx="2"></rect>
+            <rect x="8" y="8" width="8" height="8" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_stack.rs b/packages/leptos/src/square_stack.rs
new file mode 100644
index 0000000..d8ca85c
--- /dev/null
+++ b/packages/leptos/src/square_stack.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareStack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h4c1.1 0 2 .9 2 2"></path>
+            <path d="M10 16c-1.1 0-2-.9-2-2v-4c0-1.1.9-2 2-2h4c1.1 0 2 .9 2 2"></path>
+            <rect width="8" height="8" x="14" y="14" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_terminal.rs b/packages/leptos/src/square_terminal.rs
new file mode 100644
index 0000000..a04cd72
--- /dev/null
+++ b/packages/leptos/src/square_terminal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareTerminal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 11 2-2-2-2"></path>
+            <path d="M11 13h4"></path>
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_user.rs b/packages/leptos/src/square_user.rs
new file mode 100644
index 0000000..d51e367
--- /dev/null
+++ b/packages/leptos/src/square_user.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareUser(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <circle cx="12" cy="10" r="3"></circle>
+            <path d="M7 21v-2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_user_round.rs b/packages/leptos/src/square_user_round.rs
new file mode 100644
index 0000000..a30921f
--- /dev/null
+++ b/packages/leptos/src/square_user_round.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareUserRound(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 21a6 6 0 0 0-12 0"></path>
+            <circle cx="12" cy="11" r="4"></circle>
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/square_x.rs b/packages/leptos/src/square_x.rs
new file mode 100644
index 0000000..8fdc1c3
--- /dev/null
+++ b/packages/leptos/src/square_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SquareX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <path d="m15 9-6 6"></path>
+            <path d="m9 9 6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/squircle.rs b/packages/leptos/src/squircle.rs
new file mode 100644
index 0000000..225c9ef
--- /dev/null
+++ b/packages/leptos/src/squircle.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Squircle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3c7.2 0 9 1.8 9 9s-1.8 9-9 9-9-1.8-9-9 1.8-9 9-9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/squirrel.rs b/packages/leptos/src/squirrel.rs
new file mode 100644
index 0000000..c43d98a
--- /dev/null
+++ b/packages/leptos/src/squirrel.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Squirrel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.236 22a3 3 0 0 0-2.2-5"></path>
+            <path d="M16 20a3 3 0 0 1 3-3h1a2 2 0 0 0 2-2v-2a4 4 0 0 0-4-4V4"></path>
+            <path d="M18 13h.01"></path>
+            <path d="M18 6a4 4 0 0 0-4 4 7 7 0 0 0-7 7c0-5 4-5 4-10.5a4.5 4.5 0 1 0-9 0 2.5 2.5 0 0 0 5 0C7 10 3 11 3 17c0 2.8 2.2 5 5 5h10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/stamp.rs b/packages/leptos/src/stamp.rs
new file mode 100644
index 0000000..ba549ef
--- /dev/null
+++ b/packages/leptos/src/stamp.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Stamp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 22h14"></path>
+            <path d="M19.27 13.73A2.5 2.5 0 0 0 17.5 13h-11A2.5 2.5 0 0 0 4 15.5V17a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1v-1.5c0-.66-.26-1.3-.73-1.77Z"></path>
+            <path d="M14 13V8.5C14 7 15 7 15 5a3 3 0 0 0-3-3c-1.66 0-3 1-3 3s1 2 1 3.5V13"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/star.rs b/packages/leptos/src/star.rs
new file mode 100644
index 0000000..014c54e
--- /dev/null
+++ b/packages/leptos/src/star.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Star(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.525 2.295a.53.53 0 0 1 .95 0l2.31 4.679a2.123 2.123 0 0 0 1.595 1.16l5.166.756a.53.53 0 0 1 .294.904l-3.736 3.638a2.123 2.123 0 0 0-.611 1.878l.882 5.14a.53.53 0 0 1-.771.56l-4.618-2.428a2.122 2.122 0 0 0-1.973 0L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.122 2.122 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.122 2.122 0 0 0 1.597-1.16z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/star_half.rs b/packages/leptos/src/star_half.rs
new file mode 100644
index 0000000..5cae75d
--- /dev/null
+++ b/packages/leptos/src/star_half.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn StarHalf(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 18.338a2.1 2.1 0 0 0-.987.244L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.12 2.12 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.12 2.12 0 0 0 1.597-1.16l2.309-4.679A.53.53 0 0 1 12 2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/star_off.rs b/packages/leptos/src/star_off.rs
new file mode 100644
index 0000000..5780ed0
--- /dev/null
+++ b/packages/leptos/src/star_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn StarOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.34 8.34 2 9.27l5 4.87L5.82 21 12 17.77 18.18 21l-.59-3.43"></path>
+            <path d="M18.42 12.76 22 9.27l-6.91-1L12 2l-1.44 2.91"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/step_back.rs b/packages/leptos/src/step_back.rs
new file mode 100644
index 0000000..42dd970
--- /dev/null
+++ b/packages/leptos/src/step_back.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn StepBack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="18" x2="18" y1="20" y2="4"></line>
+            <polygon points="14,20 4,12 14,4"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/step_forward.rs b/packages/leptos/src/step_forward.rs
new file mode 100644
index 0000000..e8e46fe
--- /dev/null
+++ b/packages/leptos/src/step_forward.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn StepForward(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="6" x2="6" y1="4" y2="20"></line>
+            <polygon points="10,4 20,12 10,20"></polygon>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/stethoscope.rs b/packages/leptos/src/stethoscope.rs
new file mode 100644
index 0000000..4950a50
--- /dev/null
+++ b/packages/leptos/src/stethoscope.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Stethoscope(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 2v2"></path>
+            <path d="M5 2v2"></path>
+            <path d="M5 3H4a2 2 0 0 0-2 2v4a6 6 0 0 0 12 0V5a2 2 0 0 0-2-2h-1"></path>
+            <path d="M8 15a6 6 0 0 0 12 0v-3"></path>
+            <circle cx="20" cy="10" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sticker.rs b/packages/leptos/src/sticker.rs
new file mode 100644
index 0000000..1e58934
--- /dev/null
+++ b/packages/leptos/src/sticker.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sticker(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.5 3H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h14a2 2 0 0 0 2-2V8.5L15.5 3Z"></path>
+            <path d="M14 3v4a2 2 0 0 0 2 2h4"></path>
+            <path d="M8 13h.01"></path>
+            <path d="M16 13h.01"></path>
+            <path d="M10 16s.8 1 2 1c1.3 0 2-1 2-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sticky_note.rs b/packages/leptos/src/sticky_note.rs
new file mode 100644
index 0000000..aeb9906
--- /dev/null
+++ b/packages/leptos/src/sticky_note.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn StickyNote(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V8Z"></path>
+            <path d="M15 3v4a2 2 0 0 0 2 2h4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/store.rs b/packages/leptos/src/store.rs
new file mode 100644
index 0000000..a0fee5a
--- /dev/null
+++ b/packages/leptos/src/store.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Store(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 7 4.41-4.41A2 2 0 0 1 7.83 2h8.34a2 2 0 0 1 1.42.59L22 7"></path>
+            <path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8"></path>
+            <path d="M15 22v-4a2 2 0 0 0-2-2h-2a2 2 0 0 0-2 2v4"></path>
+            <path d="M2 7h20"></path>
+            <path d="M22 7v3a2 2 0 0 1-2 2a2.7 2.7 0 0 1-1.59-.63.7.7 0 0 0-.82 0A2.7 2.7 0 0 1 16 12a2.7 2.7 0 0 1-1.59-.63.7.7 0 0 0-.82 0A2.7 2.7 0 0 1 12 12a2.7 2.7 0 0 1-1.59-.63.7.7 0 0 0-.82 0A2.7 2.7 0 0 1 8 12a2.7 2.7 0 0 1-1.59-.63.7.7 0 0 0-.82 0A2.7 2.7 0 0 1 4 12a2 2 0 0 1-2-2V7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/stretch_horizontal.rs b/packages/leptos/src/stretch_horizontal.rs
new file mode 100644
index 0000000..6da51d9
--- /dev/null
+++ b/packages/leptos/src/stretch_horizontal.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn StretchHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="6" x="2" y="4" rx="2"></rect>
+            <rect width="20" height="6" x="2" y="14" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/stretch_vertical.rs b/packages/leptos/src/stretch_vertical.rs
new file mode 100644
index 0000000..72e2354
--- /dev/null
+++ b/packages/leptos/src/stretch_vertical.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn StretchVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="20" x="4" y="2" rx="2"></rect>
+            <rect width="6" height="20" x="14" y="2" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/strikethrough.rs b/packages/leptos/src/strikethrough.rs
new file mode 100644
index 0000000..d59c824
--- /dev/null
+++ b/packages/leptos/src/strikethrough.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Strikethrough(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 4H9a3 3 0 0 0-2.83 4"></path>
+            <path d="M14 12a4 4 0 0 1 0 8H6"></path>
+            <line x1="4" x2="20" y1="12" y2="12"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/subscript.rs b/packages/leptos/src/subscript.rs
new file mode 100644
index 0000000..28b50bf
--- /dev/null
+++ b/packages/leptos/src/subscript.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Subscript(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4 5 8 8"></path>
+            <path d="m12 5-8 8"></path>
+            <path d="M20 19h-4c0-1.5.44-2 1.5-2.5S20 15.33 20 14c0-.47-.17-.93-.48-1.29a2.11 2.11 0 0 0-2.62-.44c-.42.24-.74.62-.9 1.07"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sun.rs b/packages/leptos/src/sun.rs
new file mode 100644
index 0000000..0e31fc6
--- /dev/null
+++ b/packages/leptos/src/sun.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sun(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="4"></circle>
+            <path d="M12 2v2"></path>
+            <path d="M12 20v2"></path>
+            <path d="m4.93 4.93 1.41 1.41"></path>
+            <path d="m17.66 17.66 1.41 1.41"></path>
+            <path d="M2 12h2"></path>
+            <path d="M20 12h2"></path>
+            <path d="m6.34 17.66-1.41 1.41"></path>
+            <path d="m19.07 4.93-1.41 1.41"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sun_dim.rs b/packages/leptos/src/sun_dim.rs
new file mode 100644
index 0000000..db22124
--- /dev/null
+++ b/packages/leptos/src/sun_dim.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SunDim(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="4"></circle>
+            <path d="M12 4h.01"></path>
+            <path d="M20 12h.01"></path>
+            <path d="M12 20h.01"></path>
+            <path d="M4 12h.01"></path>
+            <path d="M17.657 6.343h.01"></path>
+            <path d="M17.657 17.657h.01"></path>
+            <path d="M6.343 17.657h.01"></path>
+            <path d="M6.343 6.343h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sun_medium.rs b/packages/leptos/src/sun_medium.rs
new file mode 100644
index 0000000..d1f0f79
--- /dev/null
+++ b/packages/leptos/src/sun_medium.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SunMedium(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="4"></circle>
+            <path d="M12 3v1"></path>
+            <path d="M12 20v1"></path>
+            <path d="M3 12h1"></path>
+            <path d="M20 12h1"></path>
+            <path d="m18.364 5.636-.707.707"></path>
+            <path d="m6.343 17.657-.707.707"></path>
+            <path d="m5.636 5.636.707.707"></path>
+            <path d="m17.657 17.657.707.707"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sun_moon.rs b/packages/leptos/src/sun_moon.rs
new file mode 100644
index 0000000..5450c92
--- /dev/null
+++ b/packages/leptos/src/sun_moon.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SunMoon(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 8a2.83 2.83 0 0 0 4 4 4 4 0 1 1-4-4"></path>
+            <path d="M12 2v2"></path>
+            <path d="M12 20v2"></path>
+            <path d="m4.9 4.9 1.4 1.4"></path>
+            <path d="m17.7 17.7 1.4 1.4"></path>
+            <path d="M2 12h2"></path>
+            <path d="M20 12h2"></path>
+            <path d="m6.3 17.7-1.4 1.4"></path>
+            <path d="m19.1 4.9-1.4 1.4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sun_snow.rs b/packages/leptos/src/sun_snow.rs
new file mode 100644
index 0000000..2f8d31a
--- /dev/null
+++ b/packages/leptos/src/sun_snow.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SunSnow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9a3 3 0 1 0 0 6"></path>
+            <path d="M2 12h1"></path>
+            <path d="M14 21V3"></path>
+            <path d="M10 4V3"></path>
+            <path d="M10 21v-1"></path>
+            <path d="m3.64 18.36.7-.7"></path>
+            <path d="m4.34 6.34-.7-.7"></path>
+            <path d="M14 12h8"></path>
+            <path d="m17 4-3 3"></path>
+            <path d="m14 17 3 3"></path>
+            <path d="m21 15-3-3 3-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sunrise.rs b/packages/leptos/src/sunrise.rs
new file mode 100644
index 0000000..e662b8b
--- /dev/null
+++ b/packages/leptos/src/sunrise.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sunrise(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v8"></path>
+            <path d="m4.93 10.93 1.41 1.41"></path>
+            <path d="M2 18h2"></path>
+            <path d="M20 18h2"></path>
+            <path d="m19.07 10.93-1.41 1.41"></path>
+            <path d="M22 22H2"></path>
+            <path d="m8 6 4-4 4 4"></path>
+            <path d="M16 18a4 4 0 0 0-8 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sunset.rs b/packages/leptos/src/sunset.rs
new file mode 100644
index 0000000..9250876
--- /dev/null
+++ b/packages/leptos/src/sunset.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sunset(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 10V2"></path>
+            <path d="m4.93 10.93 1.41 1.41"></path>
+            <path d="M2 18h2"></path>
+            <path d="M20 18h2"></path>
+            <path d="m19.07 10.93-1.41 1.41"></path>
+            <path d="M22 22H2"></path>
+            <path d="m16 6-4 4-4-4"></path>
+            <path d="M16 18a4 4 0 0 0-8 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/superscript.rs b/packages/leptos/src/superscript.rs
new file mode 100644
index 0000000..2e36a52
--- /dev/null
+++ b/packages/leptos/src/superscript.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Superscript(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4 19 8-8"></path>
+            <path d="m12 19-8-8"></path>
+            <path d="M20 12h-4c0-1.5.442-2 1.5-2.5S20 8.334 20 7.002c0-.472-.17-.93-.484-1.29a2.105 2.105 0 0 0-2.617-.436c-.42.239-.738.614-.899 1.06"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/swatch_book.rs b/packages/leptos/src/swatch_book.rs
new file mode 100644
index 0000000..c9362a8
--- /dev/null
+++ b/packages/leptos/src/swatch_book.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SwatchBook(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 17a4 4 0 0 1-8 0V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2Z"></path>
+            <path d="M16.7 13H19a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H7"></path>
+            <path d="M 7 17h.01"></path>
+            <path d="m11 8 2.3-2.3a2.4 2.4 0 0 1 3.404.004L18.6 7.6a2.4 2.4 0 0 1 .026 3.434L9.9 19.8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/swiss_franc.rs b/packages/leptos/src/swiss_franc.rs
new file mode 100644
index 0000000..be8b0c3
--- /dev/null
+++ b/packages/leptos/src/swiss_franc.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SwissFranc(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 21V3h8"></path>
+            <path d="M6 16h9"></path>
+            <path d="M10 9.5h7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/switch_camera.rs b/packages/leptos/src/switch_camera.rs
new file mode 100644
index 0000000..2a0674a
--- /dev/null
+++ b/packages/leptos/src/switch_camera.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn SwitchCamera(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 19H4a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h5"></path>
+            <path d="M13 5h7a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-5"></path>
+            <circle cx="12" cy="12" r="3"></circle>
+            <path d="m18 22-3-3 3-3"></path>
+            <path d="m6 2 3 3-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/sword.rs b/packages/leptos/src/sword.rs
new file mode 100644
index 0000000..1c2351b
--- /dev/null
+++ b/packages/leptos/src/sword.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Sword(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="14.5 17.5 3 6 3 3 6 3 17.5 14.5"></polyline>
+            <line x1="13" x2="19" y1="19" y2="13"></line>
+            <line x1="16" x2="20" y1="16" y2="20"></line>
+            <line x1="19" x2="21" y1="21" y2="19"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/swords.rs b/packages/leptos/src/swords.rs
new file mode 100644
index 0000000..0e9a3d6
--- /dev/null
+++ b/packages/leptos/src/swords.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Swords(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="14.5 17.5 3 6 3 3 6 3 17.5 14.5"></polyline>
+            <line x1="13" x2="19" y1="19" y2="13"></line>
+            <line x1="16" x2="20" y1="16" y2="20"></line>
+            <line x1="19" x2="21" y1="21" y2="19"></line>
+            <polyline points="14.5 6.5 18 3 21 3 21 6 17.5 9.5"></polyline>
+            <line x1="5" x2="9" y1="14" y2="18"></line>
+            <line x1="7" x2="4" y1="17" y2="20"></line>
+            <line x1="3" x2="5" y1="19" y2="21"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/syringe.rs b/packages/leptos/src/syringe.rs
new file mode 100644
index 0000000..14ea528
--- /dev/null
+++ b/packages/leptos/src/syringe.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Syringe(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 2 4 4"></path>
+            <path d="m17 7 3-3"></path>
+            <path d="M19 9 8.7 19.3c-1 1-2.5 1-3.4 0l-.6-.6c-1-1-1-2.5 0-3.4L15 5"></path>
+            <path d="m9 11 4 4"></path>
+            <path d="m5 19-3 3"></path>
+            <path d="m14 4 6 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/table.rs b/packages/leptos/src/table.rs
new file mode 100644
index 0000000..5f08c7b
--- /dev/null
+++ b/packages/leptos/src/table.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Table(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v18"></path>
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 9h18"></path>
+            <path d="M3 15h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/table_2.rs b/packages/leptos/src/table_2.rs
new file mode 100644
index 0000000..5e34733
--- /dev/null
+++ b/packages/leptos/src/table_2.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Table2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/table_cells_merge.rs b/packages/leptos/src/table_cells_merge.rs
new file mode 100644
index 0000000..7e202a3
--- /dev/null
+++ b/packages/leptos/src/table_cells_merge.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TableCellsMerge(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 21v-6"></path>
+            <path d="M12 9V3"></path>
+            <path d="M3 15h18"></path>
+            <path d="M3 9h18"></path>
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/table_cells_split.rs b/packages/leptos/src/table_cells_split.rs
new file mode 100644
index 0000000..30ca6e8
--- /dev/null
+++ b/packages/leptos/src/table_cells_split.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TableCellsSplit(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 15V9"></path>
+            <path d="M3 15h18"></path>
+            <path d="M3 9h18"></path>
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/table_columns_split.rs b/packages/leptos/src/table_columns_split.rs
new file mode 100644
index 0000000..c1d47c6
--- /dev/null
+++ b/packages/leptos/src/table_columns_split.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TableColumnsSplit(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 14v2"></path>
+            <path d="M14 20v2"></path>
+            <path d="M14 2v2"></path>
+            <path d="M14 8v2"></path>
+            <path d="M2 15h8"></path>
+            <path d="M2 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H2"></path>
+            <path d="M2 9h8"></path>
+            <path d="M22 15h-4"></path>
+            <path d="M22 3h-2a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h2"></path>
+            <path d="M22 9h-4"></path>
+            <path d="M5 3v18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/table_of_contents.rs b/packages/leptos/src/table_of_contents.rs
new file mode 100644
index 0000000..1ce834b
--- /dev/null
+++ b/packages/leptos/src/table_of_contents.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TableOfContents(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12H3"></path>
+            <path d="M16 18H3"></path>
+            <path d="M16 6H3"></path>
+            <path d="M21 12h.01"></path>
+            <path d="M21 18h.01"></path>
+            <path d="M21 6h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/table_properties.rs b/packages/leptos/src/table_properties.rs
new file mode 100644
index 0000000..02579de
--- /dev/null
+++ b/packages/leptos/src/table_properties.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TableProperties(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 3v18"></path>
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M21 9H3"></path>
+            <path d="M21 15H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/table_rows_split.rs b/packages/leptos/src/table_rows_split.rs
new file mode 100644
index 0000000..a50d01b
--- /dev/null
+++ b/packages/leptos/src/table_rows_split.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TableRowsSplit(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 10h2"></path>
+            <path d="M15 22v-8"></path>
+            <path d="M15 2v4"></path>
+            <path d="M2 10h2"></path>
+            <path d="M20 10h2"></path>
+            <path d="M3 19h18"></path>
+            <path d="M3 22v-6a2 2 135 0 1 2-2h14a2 2 45 0 1 2 2v6"></path>
+            <path d="M3 2v2a2 2 45 0 0 2 2h14a2 2 135 0 0 2-2V2"></path>
+            <path d="M8 10h2"></path>
+            <path d="M9 22v-8"></path>
+            <path d="M9 2v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tablet.rs b/packages/leptos/src/tablet.rs
new file mode 100644
index 0000000..803aa38
--- /dev/null
+++ b/packages/leptos/src/tablet.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tablet(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="20" x="4" y="2" rx="2" ry="2"></rect>
+            <line x1="12" x2="12.01" y1="18" y2="18"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tablet_smartphone.rs b/packages/leptos/src/tablet_smartphone.rs
new file mode 100644
index 0000000..7f504eb
--- /dev/null
+++ b/packages/leptos/src/tablet_smartphone.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TabletSmartphone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="10" height="14" x="3" y="8" rx="2"></rect>
+            <path d="M5 4a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2h-2.4"></path>
+            <path d="M8 18h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tablets.rs b/packages/leptos/src/tablets.rs
new file mode 100644
index 0000000..e6b2d50
--- /dev/null
+++ b/packages/leptos/src/tablets.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tablets(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="7" cy="7" r="5"></circle>
+            <circle cx="17" cy="17" r="5"></circle>
+            <path d="M12 17h10"></path>
+            <path d="m3.46 10.54 7.08-7.08"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tag.rs b/packages/leptos/src/tag.rs
new file mode 100644
index 0000000..d03b914
--- /dev/null
+++ b/packages/leptos/src/tag.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tag(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.586 2.586A2 2 0 0 0 11.172 2H4a2 2 0 0 0-2 2v7.172a2 2 0 0 0 .586 1.414l8.704 8.704a2.426 2.426 0 0 0 3.42 0l6.58-6.58a2.426 2.426 0 0 0 0-3.42z"></path>
+            <circle cx="7.5" cy="7.5" r=".5" fill="currentColor"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tags.rs b/packages/leptos/src/tags.rs
new file mode 100644
index 0000000..7dc0fab
--- /dev/null
+++ b/packages/leptos/src/tags.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tags(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 5 6.3 6.3a2.4 2.4 0 0 1 0 3.4L17 19"></path>
+            <path d="M9.586 5.586A2 2 0 0 0 8.172 5H3a1 1 0 0 0-1 1v5.172a2 2 0 0 0 .586 1.414L8.29 18.29a2.426 2.426 0 0 0 3.42 0l3.58-3.58a2.426 2.426 0 0 0 0-3.42z"></path>
+            <circle cx="6.5" cy="9.5" r=".5" fill="currentColor"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tally_1.rs b/packages/leptos/src/tally_1.rs
new file mode 100644
index 0000000..58fe1db
--- /dev/null
+++ b/packages/leptos/src/tally_1.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tally1(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tally_2.rs b/packages/leptos/src/tally_2.rs
new file mode 100644
index 0000000..c9e2510
--- /dev/null
+++ b/packages/leptos/src/tally_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tally2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16"></path>
+            <path d="M9 4v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tally_3.rs b/packages/leptos/src/tally_3.rs
new file mode 100644
index 0000000..da7f975
--- /dev/null
+++ b/packages/leptos/src/tally_3.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tally3(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16"></path>
+            <path d="M9 4v16"></path>
+            <path d="M14 4v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tally_4.rs b/packages/leptos/src/tally_4.rs
new file mode 100644
index 0000000..534257b
--- /dev/null
+++ b/packages/leptos/src/tally_4.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tally4(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16"></path>
+            <path d="M9 4v16"></path>
+            <path d="M14 4v16"></path>
+            <path d="M19 4v16"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tally_5.rs b/packages/leptos/src/tally_5.rs
new file mode 100644
index 0000000..16a95b1
--- /dev/null
+++ b/packages/leptos/src/tally_5.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tally5(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16"></path>
+            <path d="M9 4v16"></path>
+            <path d="M14 4v16"></path>
+            <path d="M19 4v16"></path>
+            <path d="M22 6 2 18"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tangent.rs b/packages/leptos/src/tangent.rs
new file mode 100644
index 0000000..8386e52
--- /dev/null
+++ b/packages/leptos/src/tangent.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tangent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="17" cy="4" r="2"></circle>
+            <path d="M15.59 5.41 5.41 15.59"></path>
+            <circle cx="4" cy="17" r="2"></circle>
+            <path d="M12 22s-4-9-1.5-11.5S22 12 22 12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/target.rs b/packages/leptos/src/target.rs
new file mode 100644
index 0000000..0ce67f1
--- /dev/null
+++ b/packages/leptos/src/target.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Target(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10"></circle>
+            <circle cx="12" cy="12" r="6"></circle>
+            <circle cx="12" cy="12" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/telescope.rs b/packages/leptos/src/telescope.rs
new file mode 100644
index 0000000..7cbf3eb
--- /dev/null
+++ b/packages/leptos/src/telescope.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Telescope(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10.065 12.493-6.18 1.318a.934.934 0 0 1-1.108-.702l-.537-2.15a1.07 1.07 0 0 1 .691-1.265l13.504-4.44"></path>
+            <path d="m13.56 11.747 4.332-.924"></path>
+            <path d="m16 21-3.105-6.21"></path>
+            <path d="M16.485 5.94a2 2 0 0 1 1.455-2.425l1.09-.272a1 1 0 0 1 1.212.727l1.515 6.06a1 1 0 0 1-.727 1.213l-1.09.272a2 2 0 0 1-2.425-1.455z"></path>
+            <path d="m6.158 8.633 1.114 4.456"></path>
+            <path d="m8 21 3.105-6.21"></path>
+            <circle cx="12" cy="13" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tent.rs b/packages/leptos/src/tent.rs
new file mode 100644
index 0000000..50ba142
--- /dev/null
+++ b/packages/leptos/src/tent.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.5 21 14 3"></path>
+            <path d="M20.5 21 10 3"></path>
+            <path d="M15.5 21 12 15l-3.5 6"></path>
+            <path d="M2 21h20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tent_tree.rs b/packages/leptos/src/tent_tree.rs
new file mode 100644
index 0000000..8ecf769
--- /dev/null
+++ b/packages/leptos/src/tent_tree.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TentTree(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="4" cy="4" r="2"></circle>
+            <path d="m14 5 3-3 3 3"></path>
+            <path d="m14 10 3-3 3 3"></path>
+            <path d="M17 14V2"></path>
+            <path d="M17 14H7l-5 8h20Z"></path>
+            <path d="M8 14v8"></path>
+            <path d="m9 14 5 8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/terminal.rs b/packages/leptos/src/terminal.rs
new file mode 100644
index 0000000..7b447dc
--- /dev/null
+++ b/packages/leptos/src/terminal.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Terminal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="4 17 10 11 4 5"></polyline>
+            <line x1="12" x2="20" y1="19" y2="19"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/test_tube.rs b/packages/leptos/src/test_tube.rs
new file mode 100644
index 0000000..74b042a
--- /dev/null
+++ b/packages/leptos/src/test_tube.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TestTube(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.5 2v17.5c0 1.4-1.1 2.5-2.5 2.5c-1.4 0-2.5-1.1-2.5-2.5V2"></path>
+            <path d="M8.5 2h7"></path>
+            <path d="M14.5 16h-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/test_tube_diagonal.rs b/packages/leptos/src/test_tube_diagonal.rs
new file mode 100644
index 0000000..f947f38
--- /dev/null
+++ b/packages/leptos/src/test_tube_diagonal.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TestTubeDiagonal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 7 6.82 21.18a2.83 2.83 0 0 1-3.99-.01a2.83 2.83 0 0 1 0-4L17 3"></path>
+            <path d="m16 2 6 6"></path>
+            <path d="M12 16H4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/test_tubes.rs b/packages/leptos/src/test_tubes.rs
new file mode 100644
index 0000000..018f40c
--- /dev/null
+++ b/packages/leptos/src/test_tubes.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TestTubes(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 2v17.5A2.5 2.5 0 0 1 6.5 22A2.5 2.5 0 0 1 4 19.5V2"></path>
+            <path d="M20 2v17.5a2.5 2.5 0 0 1-2.5 2.5a2.5 2.5 0 0 1-2.5-2.5V2"></path>
+            <path d="M3 2h7"></path>
+            <path d="M14 2h7"></path>
+            <path d="M9 16H4"></path>
+            <path d="M20 16h-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/text.rs b/packages/leptos/src/text.rs
new file mode 100644
index 0000000..596e13c
--- /dev/null
+++ b/packages/leptos/src/text.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Text(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 6.1H3"></path>
+            <path d="M21 12.1H3"></path>
+            <path d="M15.1 18H3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/text_cursor.rs b/packages/leptos/src/text_cursor.rs
new file mode 100644
index 0000000..0448a76
--- /dev/null
+++ b/packages/leptos/src/text_cursor.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TextCursor(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 22h-1a4 4 0 0 1-4-4V6a4 4 0 0 1 4-4h1"></path>
+            <path d="M7 22h1a4 4 0 0 0 4-4v-1"></path>
+            <path d="M7 2h1a4 4 0 0 1 4 4v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/text_cursor_input.rs b/packages/leptos/src/text_cursor_input.rs
new file mode 100644
index 0000000..08e2f8e
--- /dev/null
+++ b/packages/leptos/src/text_cursor_input.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TextCursorInput(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 4h1a3 3 0 0 1 3 3 3 3 0 0 1 3-3h1"></path>
+            <path d="M13 20h-1a3 3 0 0 1-3-3 3 3 0 0 1-3 3H5"></path>
+            <path d="M5 16H4a2 2 0 0 1-2-2v-4a2 2 0 0 1 2-2h1"></path>
+            <path d="M13 8h7a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-7"></path>
+            <path d="M9 7v10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/text_quote.rs b/packages/leptos/src/text_quote.rs
new file mode 100644
index 0000000..4c655d0
--- /dev/null
+++ b/packages/leptos/src/text_quote.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TextQuote(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 6H3"></path>
+            <path d="M21 12H8"></path>
+            <path d="M21 18H8"></path>
+            <path d="M3 12v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/text_search.rs b/packages/leptos/src/text_search.rs
new file mode 100644
index 0000000..1c564f1
--- /dev/null
+++ b/packages/leptos/src/text_search.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TextSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 6H3"></path>
+            <path d="M10 12H3"></path>
+            <path d="M10 18H3"></path>
+            <circle cx="17" cy="15" r="3"></circle>
+            <path d="m21 19-1.9-1.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/text_select.rs b/packages/leptos/src/text_select.rs
new file mode 100644
index 0000000..89bf383
--- /dev/null
+++ b/packages/leptos/src/text_select.rs
@@ -0,0 +1,49 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TextSelect(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 3a2 2 0 0 0-2 2"></path>
+            <path d="M19 3a2 2 0 0 1 2 2"></path>
+            <path d="M21 19a2 2 0 0 1-2 2"></path>
+            <path d="M5 21a2 2 0 0 1-2-2"></path>
+            <path d="M9 3h1"></path>
+            <path d="M9 21h1"></path>
+            <path d="M14 3h1"></path>
+            <path d="M14 21h1"></path>
+            <path d="M3 9v1"></path>
+            <path d="M21 9v1"></path>
+            <path d="M3 14v1"></path>
+            <path d="M21 14v1"></path>
+            <line x1="7" x2="15" y1="8" y2="8"></line>
+            <line x1="7" x2="17" y1="12" y2="12"></line>
+            <line x1="7" x2="13" y1="16" y2="16"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/theater.rs b/packages/leptos/src/theater.rs
new file mode 100644
index 0000000..406e661
--- /dev/null
+++ b/packages/leptos/src/theater.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Theater(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 10s3-3 3-8"></path>
+            <path d="M22 10s-3-3-3-8"></path>
+            <path d="M10 2c0 4.4-3.6 8-8 8"></path>
+            <path d="M14 2c0 4.4 3.6 8 8 8"></path>
+            <path d="M2 10s2 2 2 5"></path>
+            <path d="M22 10s-2 2-2 5"></path>
+            <path d="M8 15h8"></path>
+            <path d="M2 22v-1a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1"></path>
+            <path d="M14 22v-1a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/thermometer.rs b/packages/leptos/src/thermometer.rs
new file mode 100644
index 0000000..e9ecd1e
--- /dev/null
+++ b/packages/leptos/src/thermometer.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Thermometer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/thermometer_snowflake.rs b/packages/leptos/src/thermometer_snowflake.rs
new file mode 100644
index 0000000..a80d7d2
--- /dev/null
+++ b/packages/leptos/src/thermometer_snowflake.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ThermometerSnowflake(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12h10"></path>
+            <path d="M9 4v16"></path>
+            <path d="m3 9 3 3-3 3"></path>
+            <path d="M12 6 9 9 6 6"></path>
+            <path d="m6 18 3-3 1.5 1.5"></path>
+            <path d="M20 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/thermometer_sun.rs b/packages/leptos/src/thermometer_sun.rs
new file mode 100644
index 0000000..dcf9164
--- /dev/null
+++ b/packages/leptos/src/thermometer_sun.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ThermometerSun(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 9a4 4 0 0 0-2 7.5"></path>
+            <path d="M12 3v2"></path>
+            <path d="m6.6 18.4-1.4 1.4"></path>
+            <path d="M20 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z"></path>
+            <path d="M4 13H2"></path>
+            <path d="M6.34 7.34 4.93 5.93"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/thumbs_down.rs b/packages/leptos/src/thumbs_down.rs
new file mode 100644
index 0000000..73bc912
--- /dev/null
+++ b/packages/leptos/src/thumbs_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ThumbsDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 14V2"></path>
+            <path d="M9 18.12 10 14H4.17a2 2 0 0 1-1.92-2.56l2.33-8A2 2 0 0 1 6.5 2H20a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.76a2 2 0 0 0-1.79 1.11L12 22a3.13 3.13 0 0 1-3-3.88Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/thumbs_up.rs b/packages/leptos/src/thumbs_up.rs
new file mode 100644
index 0000000..88f0a77
--- /dev/null
+++ b/packages/leptos/src/thumbs_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ThumbsUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 10v12"></path>
+            <path d="M15 5.88 14 10h5.83a2 2 0 0 1 1.92 2.56l-2.33 8A2 2 0 0 1 17.5 22H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2h2.76a2 2 0 0 0 1.79-1.11L12 2a3.13 3.13 0 0 1 3 3.88Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ticket.rs b/packages/leptos/src/ticket.rs
new file mode 100644
index 0000000..32f22d8
--- /dev/null
+++ b/packages/leptos/src/ticket.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ticket(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"></path>
+            <path d="M13 5v2"></path>
+            <path d="M13 17v2"></path>
+            <path d="M13 11v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ticket_check.rs b/packages/leptos/src/ticket_check.rs
new file mode 100644
index 0000000..a32334b
--- /dev/null
+++ b/packages/leptos/src/ticket_check.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TicketCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"></path>
+            <path d="m9 12 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ticket_minus.rs b/packages/leptos/src/ticket_minus.rs
new file mode 100644
index 0000000..d348e64
--- /dev/null
+++ b/packages/leptos/src/ticket_minus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TicketMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"></path>
+            <path d="M9 12h6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ticket_percent.rs b/packages/leptos/src/ticket_percent.rs
new file mode 100644
index 0000000..1627f24
--- /dev/null
+++ b/packages/leptos/src/ticket_percent.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TicketPercent(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9a3 3 0 1 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 1 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"></path>
+            <path d="M9 9h.01"></path>
+            <path d="m15 9-6 6"></path>
+            <path d="M15 15h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ticket_plus.rs b/packages/leptos/src/ticket_plus.rs
new file mode 100644
index 0000000..03f9b3d
--- /dev/null
+++ b/packages/leptos/src/ticket_plus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TicketPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"></path>
+            <path d="M9 12h6"></path>
+            <path d="M12 9v6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ticket_slash.rs b/packages/leptos/src/ticket_slash.rs
new file mode 100644
index 0000000..c5614ea
--- /dev/null
+++ b/packages/leptos/src/ticket_slash.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TicketSlash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"></path>
+            <path d="m9.5 14.5 5-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ticket_x.rs b/packages/leptos/src/ticket_x.rs
new file mode 100644
index 0000000..1ad1fcd
--- /dev/null
+++ b/packages/leptos/src/ticket_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TicketX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"></path>
+            <path d="m9.5 14.5 5-5"></path>
+            <path d="m9.5 9.5 5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tickets.rs b/packages/leptos/src/tickets.rs
new file mode 100644
index 0000000..ce4385f
--- /dev/null
+++ b/packages/leptos/src/tickets.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tickets(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4.5 8 10.58-5.06a1 1 0 0 1 1.342.488L18.5 8"></path>
+            <path d="M6 10V8"></path>
+            <path d="M6 14v1"></path>
+            <path d="M6 19v2"></path>
+            <rect x="2" y="8" width="20" height="13" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tickets_plane.rs b/packages/leptos/src/tickets_plane.rs
new file mode 100644
index 0000000..eec204a
--- /dev/null
+++ b/packages/leptos/src/tickets_plane.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TicketsPlane(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.5 17h1.227a2 2 0 0 0 1.345-.52L18 12"></path>
+            <path d="m12 13.5 3.75.5"></path>
+            <path d="m4.5 8 10.58-5.06a1 1 0 0 1 1.342.488L18.5 8"></path>
+            <path d="M6 10V8"></path>
+            <path d="M6 14v1"></path>
+            <path d="M6 19v2"></path>
+            <rect x="2" y="8" width="20" height="13" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/timer.rs b/packages/leptos/src/timer.rs
new file mode 100644
index 0000000..8b1a729
--- /dev/null
+++ b/packages/leptos/src/timer.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Timer(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="10" x2="14" y1="2" y2="2"></line>
+            <line x1="12" x2="15" y1="14" y2="11"></line>
+            <circle cx="12" cy="14" r="8"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/timer_off.rs b/packages/leptos/src/timer_off.rs
new file mode 100644
index 0000000..80e59cb
--- /dev/null
+++ b/packages/leptos/src/timer_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TimerOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2h4"></path>
+            <path d="M4.6 11a8 8 0 0 0 1.7 8.7 8 8 0 0 0 8.7 1.7"></path>
+            <path d="M7.4 7.4a8 8 0 0 1 10.3 1 8 8 0 0 1 .9 10.2"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M12 12v-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/timer_reset.rs b/packages/leptos/src/timer_reset.rs
new file mode 100644
index 0000000..a9cd296
--- /dev/null
+++ b/packages/leptos/src/timer_reset.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TimerReset(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2h4"></path>
+            <path d="M12 14v-4"></path>
+            <path d="M4 13a8 8 0 0 1 8-7 8 8 0 1 1-5.3 14L4 17.6"></path>
+            <path d="M9 17H4v5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/toggle_left.rs b/packages/leptos/src/toggle_left.rs
new file mode 100644
index 0000000..194dff8
--- /dev/null
+++ b/packages/leptos/src/toggle_left.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ToggleLeft(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="6" ry="6"></rect>
+            <circle cx="8" cy="12" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/toggle_right.rs b/packages/leptos/src/toggle_right.rs
new file mode 100644
index 0000000..e5c9254
--- /dev/null
+++ b/packages/leptos/src/toggle_right.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ToggleRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="6" ry="6"></rect>
+            <circle cx="16" cy="12" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/toilet.rs b/packages/leptos/src/toilet.rs
new file mode 100644
index 0000000..ee45e04
--- /dev/null
+++ b/packages/leptos/src/toilet.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Toilet(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 12h13a1 1 0 0 1 1 1 5 5 0 0 1-5 5h-.598a.5.5 0 0 0-.424.765l1.544 2.47a.5.5 0 0 1-.424.765H5.402a.5.5 0 0 1-.424-.765L7 18"></path>
+            <path d="M8 18a5 5 0 0 1-5-5V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tornado.rs b/packages/leptos/src/tornado.rs
new file mode 100644
index 0000000..56d9e6d
--- /dev/null
+++ b/packages/leptos/src/tornado.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tornado(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 4H3"></path>
+            <path d="M18 8H6"></path>
+            <path d="M19 12H9"></path>
+            <path d="M16 16h-6"></path>
+            <path d="M11 20H9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/torus.rs b/packages/leptos/src/torus.rs
new file mode 100644
index 0000000..8d7a1f9
--- /dev/null
+++ b/packages/leptos/src/torus.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Torus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="11" rx="3" ry="2"></ellipse>
+            <ellipse cx="12" cy="12.5" rx="10" ry="8.5"></ellipse>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/touchpad.rs b/packages/leptos/src/touchpad.rs
new file mode 100644
index 0000000..e098006
--- /dev/null
+++ b/packages/leptos/src/touchpad.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Touchpad(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+            <path d="M2 14h20"></path>
+            <path d="M12 20v-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/touchpad_off.rs b/packages/leptos/src/touchpad_off.rs
new file mode 100644
index 0000000..0cf0e48
--- /dev/null
+++ b/packages/leptos/src/touchpad_off.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TouchpadOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h16"></path>
+            <path d="M2 14h12"></path>
+            <path d="M22 14h-2"></path>
+            <path d="M12 20v-6"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="M22 16V6a2 2 0 0 0-2-2H10"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tower_control.rs b/packages/leptos/src/tower_control.rs
new file mode 100644
index 0000000..7c7d99d
--- /dev/null
+++ b/packages/leptos/src/tower_control.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TowerControl(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.2 12.27 20 6H4l1.8 6.27a1 1 0 0 0 .95.73h10.5a1 1 0 0 0 .96-.73Z"></path>
+            <path d="M8 13v9"></path>
+            <path d="M16 22v-9"></path>
+            <path d="m9 6 1 7"></path>
+            <path d="m15 6-1 7"></path>
+            <path d="M12 6V2"></path>
+            <path d="M13 2h-2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/toy_brick.rs b/packages/leptos/src/toy_brick.rs
new file mode 100644
index 0000000..ca5d58d
--- /dev/null
+++ b/packages/leptos/src/toy_brick.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ToyBrick(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="12" x="3" y="8" rx="1"></rect>
+            <path d="M10 8V5c0-.6-.4-1-1-1H6a1 1 0 0 0-1 1v3"></path>
+            <path d="M19 8V5c0-.6-.4-1-1-1h-3a1 1 0 0 0-1 1v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tractor.rs b/packages/leptos/src/tractor.rs
new file mode 100644
index 0000000..43a1078
--- /dev/null
+++ b/packages/leptos/src/tractor.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tractor(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10 11 11 .9a1 1 0 0 1 .8 1.1l-.665 4.158a1 1 0 0 1-.988.842H20"></path>
+            <path d="M16 18h-5"></path>
+            <path d="M18 5a1 1 0 0 0-1 1v5.573"></path>
+            <path d="M3 4h8.129a1 1 0 0 1 .99.863L13 11.246"></path>
+            <path d="M4 11V4"></path>
+            <path d="M7 15h.01"></path>
+            <path d="M8 10.1V4"></path>
+            <circle cx="18" cy="18" r="2"></circle>
+            <circle cx="7" cy="15" r="5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/traffic_cone.rs b/packages/leptos/src/traffic_cone.rs
new file mode 100644
index 0000000..c7d4f61
--- /dev/null
+++ b/packages/leptos/src/traffic_cone.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TrafficCone(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9.3 6.2a4.55 4.55 0 0 0 5.4 0"></path>
+            <path d="M7.9 10.7c.9.8 2.4 1.3 4.1 1.3s3.2-.5 4.1-1.3"></path>
+            <path d="M13.9 3.5a1.93 1.93 0 0 0-3.8-.1l-3 10c-.1.2-.1.4-.1.6 0 1.7 2.2 3 5 3s5-1.3 5-3c0-.2 0-.4-.1-.5Z"></path>
+            <path d="m7.5 12.2-4.7 2.7c-.5.3-.8.7-.8 1.1s.3.8.8 1.1l7.6 4.5c.9.5 2.1.5 3 0l7.6-4.5c.7-.3 1-.7 1-1.1s-.3-.8-.8-1.1l-4.7-2.8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/train_front.rs b/packages/leptos/src/train_front.rs
new file mode 100644
index 0000000..341f73c
--- /dev/null
+++ b/packages/leptos/src/train_front.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TrainFront(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3.1V7a4 4 0 0 0 8 0V3.1"></path>
+            <path d="m9 15-1-1"></path>
+            <path d="m15 15 1-1"></path>
+            <path d="M9 19c-2.8 0-5-2.2-5-5v-4a8 8 0 0 1 16 0v4c0 2.8-2.2 5-5 5Z"></path>
+            <path d="m8 19-2 3"></path>
+            <path d="m16 19 2 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/train_front_tunnel.rs b/packages/leptos/src/train_front_tunnel.rs
new file mode 100644
index 0000000..07ad02e
--- /dev/null
+++ b/packages/leptos/src/train_front_tunnel.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TrainFrontTunnel(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22V12a10 10 0 1 1 20 0v10"></path>
+            <path d="M15 6.8v1.4a3 2.8 0 1 1-6 0V6.8"></path>
+            <path d="M10 15h.01"></path>
+            <path d="M14 15h.01"></path>
+            <path d="M10 19a4 4 0 0 1-4-4v-3a6 6 0 1 1 12 0v3a4 4 0 0 1-4 4Z"></path>
+            <path d="m9 19-2 3"></path>
+            <path d="m15 19 2 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/train_track.rs b/packages/leptos/src/train_track.rs
new file mode 100644
index 0000000..c983e92
--- /dev/null
+++ b/packages/leptos/src/train_track.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TrainTrack(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 17 17 2"></path>
+            <path d="m2 14 8 8"></path>
+            <path d="m5 11 8 8"></path>
+            <path d="m8 8 8 8"></path>
+            <path d="m11 5 8 8"></path>
+            <path d="m14 2 8 8"></path>
+            <path d="M7 22 22 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tram_front.rs b/packages/leptos/src/tram_front.rs
new file mode 100644
index 0000000..690f8d5
--- /dev/null
+++ b/packages/leptos/src/tram_front.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TramFront(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="16" x="4" y="3" rx="2"></rect>
+            <path d="M4 11h16"></path>
+            <path d="M12 3v8"></path>
+            <path d="m8 19-2 3"></path>
+            <path d="m18 22-2-3"></path>
+            <path d="M8 15h.01"></path>
+            <path d="M16 15h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/trash.rs b/packages/leptos/src/trash.rs
new file mode 100644
index 0000000..5088482
--- /dev/null
+++ b/packages/leptos/src/trash.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Trash(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 6h18"></path>
+            <path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"></path>
+            <path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/trash_2.rs b/packages/leptos/src/trash_2.rs
new file mode 100644
index 0000000..db6e420
--- /dev/null
+++ b/packages/leptos/src/trash_2.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Trash2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 6h18"></path>
+            <path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"></path>
+            <path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"></path>
+            <line x1="10" x2="10" y1="11" y2="17"></line>
+            <line x1="14" x2="14" y1="11" y2="17"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tree_deciduous.rs b/packages/leptos/src/tree_deciduous.rs
new file mode 100644
index 0000000..f9a41cc
--- /dev/null
+++ b/packages/leptos/src/tree_deciduous.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TreeDeciduous(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 19a4 4 0 0 1-2.24-7.32A3.5 3.5 0 0 1 9 6.03V6a3 3 0 1 1 6 0v.04a3.5 3.5 0 0 1 3.24 5.65A4 4 0 0 1 16 19Z"></path>
+            <path d="M12 19v3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tree_palm.rs b/packages/leptos/src/tree_palm.rs
new file mode 100644
index 0000000..fae1765
--- /dev/null
+++ b/packages/leptos/src/tree_palm.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TreePalm(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 8c0-2.76-2.46-5-5.5-5S2 5.24 2 8h2l1-1 1 1h4"></path>
+            <path d="M13 7.14A5.82 5.82 0 0 1 16.5 6c3.04 0 5.5 2.24 5.5 5h-3l-1-1-1 1h-3"></path>
+            <path d="M5.89 9.71c-2.15 2.15-2.3 5.47-.35 7.43l4.24-4.25.7-.7.71-.71 2.12-2.12c-1.95-1.96-5.27-1.8-7.42.35"></path>
+            <path d="M11 15.5c.5 2.5-.17 4.5-1 6.5h4c2-5.5-.5-12-1-14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tree_pine.rs b/packages/leptos/src/tree_pine.rs
new file mode 100644
index 0000000..d2e6717
--- /dev/null
+++ b/packages/leptos/src/tree_pine.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TreePine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 14 3 3.3a1 1 0 0 1-.7 1.7H4.7a1 1 0 0 1-.7-1.7L7 14h-.3a1 1 0 0 1-.7-1.7L9 9h-.2A1 1 0 0 1 8 7.3L12 3l4 4.3a1 1 0 0 1-.8 1.7H15l3 3.3a1 1 0 0 1-.7 1.7H17Z"></path>
+            <path d="M12 22v-3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/trees.rs b/packages/leptos/src/trees.rs
new file mode 100644
index 0000000..3008656
--- /dev/null
+++ b/packages/leptos/src/trees.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Trees(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10v.2A3 3 0 0 1 8.9 16H5a3 3 0 0 1-1-5.8V10a3 3 0 0 1 6 0Z"></path>
+            <path d="M7 16v6"></path>
+            <path d="M13 19v3"></path>
+            <path d="M12 19h8.3a1 1 0 0 0 .7-1.7L18 14h.3a1 1 0 0 0 .7-1.7L16 9h.2a1 1 0 0 0 .8-1.7L13 3l-1.4 1.5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/trello.rs b/packages/leptos/src/trello.rs
new file mode 100644
index 0000000..dcb5959
--- /dev/null
+++ b/packages/leptos/src/trello.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Trello(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2"></rect>
+            <rect width="3" height="9" x="7" y="7"></rect>
+            <rect width="3" height="5" x="14" y="7"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/trending_down.rs b/packages/leptos/src/trending_down.rs
new file mode 100644
index 0000000..b9d1504
--- /dev/null
+++ b/packages/leptos/src/trending_down.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TrendingDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="22 17 13.5 8.5 8.5 13.5 2 7"></polyline>
+            <polyline points="16 17 22 17 22 11"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/trending_up.rs b/packages/leptos/src/trending_up.rs
new file mode 100644
index 0000000..cc4f7e6
--- /dev/null
+++ b/packages/leptos/src/trending_up.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TrendingUp(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="22 7 13.5 15.5 8.5 10.5 2 17"></polyline>
+            <polyline points="16 7 22 7 22 13"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/trending_up_down.rs b/packages/leptos/src/trending_up_down.rs
new file mode 100644
index 0000000..4ccd59a
--- /dev/null
+++ b/packages/leptos/src/trending_up_down.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TrendingUpDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.828 14.828 21 21"></path>
+            <path d="M21 16v5h-5"></path>
+            <path d="m21 3-9 9-4-4-6 6"></path>
+            <path d="M21 8V3h-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/triangle.rs b/packages/leptos/src/triangle.rs
new file mode 100644
index 0000000..48e7597
--- /dev/null
+++ b/packages/leptos/src/triangle.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Triangle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.73 4a2 2 0 0 0-3.46 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/triangle_alert.rs b/packages/leptos/src/triangle_alert.rs
new file mode 100644
index 0000000..d95ab6e
--- /dev/null
+++ b/packages/leptos/src/triangle_alert.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TriangleAlert(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"></path>
+            <path d="M12 9v4"></path>
+            <path d="M12 17h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/triangle_right.rs b/packages/leptos/src/triangle_right.rs
new file mode 100644
index 0000000..82be01d
--- /dev/null
+++ b/packages/leptos/src/triangle_right.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TriangleRight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 18a2 2 0 0 1-2 2H3c-1.1 0-1.3-.6-.4-1.3L20.4 4.3c.9-.7 1.6-.4 1.6.7Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/trophy.rs b/packages/leptos/src/trophy.rs
new file mode 100644
index 0000000..6120976
--- /dev/null
+++ b/packages/leptos/src/trophy.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Trophy(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 9H4.5a2.5 2.5 0 0 1 0-5H6"></path>
+            <path d="M18 9h1.5a2.5 2.5 0 0 0 0-5H18"></path>
+            <path d="M4 22h16"></path>
+            <path d="M10 14.66V17c0 .55-.47.98-.97 1.21C7.85 18.75 7 20.24 7 22"></path>
+            <path d="M14 14.66V17c0 .55.47.98.97 1.21C16.15 18.75 17 20.24 17 22"></path>
+            <path d="M18 2H6v7a6 6 0 0 0 12 0V2Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/truck.rs b/packages/leptos/src/truck.rs
new file mode 100644
index 0000000..2d30887
--- /dev/null
+++ b/packages/leptos/src/truck.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Truck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2"></path>
+            <path d="M15 18H9"></path>
+            <path d="M19 18h2a1 1 0 0 0 1-1v-3.65a1 1 0 0 0-.22-.624l-3.48-4.35A1 1 0 0 0 17.52 8H14"></path>
+            <circle cx="17" cy="18" r="2"></circle>
+            <circle cx="7" cy="18" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/turtle.rs b/packages/leptos/src/turtle.rs
new file mode 100644
index 0000000..8a15066
--- /dev/null
+++ b/packages/leptos/src/turtle.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Turtle(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 10 2 4v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3a8 8 0 1 0-16 0v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3l2-4h4Z"></path>
+            <path d="M4.82 7.9 8 10"></path>
+            <path d="M15.18 7.9 12 10"></path>
+            <path d="M16.93 10H20a2 2 0 0 1 0 4H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tv.rs b/packages/leptos/src/tv.rs
new file mode 100644
index 0000000..9f4ec62
--- /dev/null
+++ b/packages/leptos/src/tv.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Tv(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="15" x="2" y="7" rx="2" ry="2"></rect>
+            <polyline points="17 2 12 7 7 2"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tv_minimal.rs b/packages/leptos/src/tv_minimal.rs
new file mode 100644
index 0000000..a3b7608
--- /dev/null
+++ b/packages/leptos/src/tv_minimal.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TvMinimal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 21h10"></path>
+            <rect width="20" height="14" x="2" y="3" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/tv_minimal_play.rs b/packages/leptos/src/tv_minimal_play.rs
new file mode 100644
index 0000000..1df05a7
--- /dev/null
+++ b/packages/leptos/src/tv_minimal_play.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TvMinimalPlay(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 7.75a.75.75 0 0 1 1.142-.638l3.664 2.249a.75.75 0 0 1 0 1.278l-3.664 2.25a.75.75 0 0 1-1.142-.64z"></path>
+            <path d="M7 21h10"></path>
+            <rect width="20" height="14" x="2" y="3" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/twitch.rs b/packages/leptos/src/twitch.rs
new file mode 100644
index 0000000..0120e45
--- /dev/null
+++ b/packages/leptos/src/twitch.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Twitch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 2H3v16h5v4l4-4h5l4-4V2zm-10 9V7m5 4V7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/twitter.rs b/packages/leptos/src/twitter.rs
new file mode 100644
index 0000000..46f4dc4
--- /dev/null
+++ b/packages/leptos/src/twitter.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Twitter(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 4s-.7 2.1-2 3.4c1.6 10-9.4 17.3-18 11.6 2.2.1 4.4-.6 6-2C3 15.5.5 9.6 3 5c2.2 2.6 5.6 4.1 9 4-.9-4.2 4-6.6 7-3.8 1.1 0 3-1.2 3-1.2z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/type.rs b/packages/leptos/src/type.rs
new file mode 100644
index 0000000..e5f8bf3
--- /dev/null
+++ b/packages/leptos/src/type.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Type(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="4 7 4 4 20 4 20 7"></polyline>
+            <line x1="9" x2="15" y1="20" y2="20"></line>
+            <line x1="12" x2="12" y1="4" y2="20"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/type_outline.rs b/packages/leptos/src/type_outline.rs
new file mode 100644
index 0000000..aed8343
--- /dev/null
+++ b/packages/leptos/src/type_outline.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn TypeOutline(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 16.5a.5.5 0 0 0 .5.5h.5a2 2 0 0 1 0 4H9a2 2 0 0 1 0-4h.5a.5.5 0 0 0 .5-.5v-9a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5V8a2 2 0 0 1-4 0V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v3a2 2 0 0 1-4 0v-.5a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/umbrella.rs b/packages/leptos/src/umbrella.rs
new file mode 100644
index 0000000..c0b6f8c
--- /dev/null
+++ b/packages/leptos/src/umbrella.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Umbrella(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12a10.06 10.06 1 0 0-20 0Z"></path>
+            <path d="M12 12v8a2 2 0 0 0 4 0"></path>
+            <path d="M12 2v1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/umbrella_off.rs b/packages/leptos/src/umbrella_off.rs
new file mode 100644
index 0000000..deb735d
--- /dev/null
+++ b/packages/leptos/src/umbrella_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UmbrellaOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v1"></path>
+            <path d="M15.5 21a1.85 1.85 0 0 1-3.5-1v-8H2a10 10 0 0 1 3.428-6.575"></path>
+            <path d="M17.5 12H22A10 10 0 0 0 9.004 3.455"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/underline.rs b/packages/leptos/src/underline.rs
new file mode 100644
index 0000000..c4aaf5c
--- /dev/null
+++ b/packages/leptos/src/underline.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Underline(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 4v6a6 6 0 0 0 12 0V4"></path>
+            <line x1="4" x2="20" y1="20" y2="20"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/undo.rs b/packages/leptos/src/undo.rs
new file mode 100644
index 0000000..1ea47fc
--- /dev/null
+++ b/packages/leptos/src/undo.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Undo(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7v6h6"></path>
+            <path d="M21 17a9 9 0 0 0-9-9 9 9 0 0 0-6 2.3L3 13"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/undo_2.rs b/packages/leptos/src/undo_2.rs
new file mode 100644
index 0000000..d54c99b
--- /dev/null
+++ b/packages/leptos/src/undo_2.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Undo2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 14 4 9l5-5"></path>
+            <path d="M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5a5.5 5.5 0 0 1-5.5 5.5H11"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/undo_dot.rs b/packages/leptos/src/undo_dot.rs
new file mode 100644
index 0000000..1fd4bbd
--- /dev/null
+++ b/packages/leptos/src/undo_dot.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UndoDot(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 17a9 9 0 0 0-15-6.7L3 13"></path>
+            <path d="M3 7v6h6"></path>
+            <circle cx="12" cy="17" r="1"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/unfold_horizontal.rs b/packages/leptos/src/unfold_horizontal.rs
new file mode 100644
index 0000000..62d9d7b
--- /dev/null
+++ b/packages/leptos/src/unfold_horizontal.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UnfoldHorizontal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12h6"></path>
+            <path d="M8 12H2"></path>
+            <path d="M12 2v2"></path>
+            <path d="M12 8v2"></path>
+            <path d="M12 14v2"></path>
+            <path d="M12 20v2"></path>
+            <path d="m19 15 3-3-3-3"></path>
+            <path d="m5 9-3 3 3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/unfold_vertical.rs b/packages/leptos/src/unfold_vertical.rs
new file mode 100644
index 0000000..c5128aa
--- /dev/null
+++ b/packages/leptos/src/unfold_vertical.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UnfoldVertical(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-6"></path>
+            <path d="M12 8V2"></path>
+            <path d="M4 12H2"></path>
+            <path d="M10 12H8"></path>
+            <path d="M16 12h-2"></path>
+            <path d="M22 12h-2"></path>
+            <path d="m15 19-3 3-3-3"></path>
+            <path d="m15 5-3-3-3 3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/ungroup.rs b/packages/leptos/src/ungroup.rs
new file mode 100644
index 0000000..9cd0472
--- /dev/null
+++ b/packages/leptos/src/ungroup.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Ungroup(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="6" x="5" y="4" rx="1"></rect>
+            <rect width="8" height="6" x="11" y="14" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/university.rs b/packages/leptos/src/university.rs
new file mode 100644
index 0000000..2c859e9
--- /dev/null
+++ b/packages/leptos/src/university.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn University(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="10" r="1"></circle>
+            <path d="M22 20V8h-4l-6-4-6 4H2v12a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2"></path>
+            <path d="M6 17v.01"></path>
+            <path d="M6 13v.01"></path>
+            <path d="M18 17v.01"></path>
+            <path d="M18 13v.01"></path>
+            <path d="M14 22v-5a2 2 0 0 0-2-2a2 2 0 0 0-2 2v5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/unlink.rs b/packages/leptos/src/unlink.rs
new file mode 100644
index 0000000..93e393f
--- /dev/null
+++ b/packages/leptos/src/unlink.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Unlink(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18.84 12.25 1.72-1.71h-.02a5.004 5.004 0 0 0-.12-7.07 5.006 5.006 0 0 0-6.95 0l-1.72 1.71"></path>
+            <path d="m5.17 11.75-1.71 1.71a5.004 5.004 0 0 0 .12 7.07 5.006 5.006 0 0 0 6.95 0l1.71-1.71"></path>
+            <line x1="8" x2="8" y1="2" y2="5"></line>
+            <line x1="2" x2="5" y1="8" y2="8"></line>
+            <line x1="16" x2="16" y1="19" y2="22"></line>
+            <line x1="19" x2="22" y1="16" y2="16"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/unlink_2.rs b/packages/leptos/src/unlink_2.rs
new file mode 100644
index 0000000..a8df728
--- /dev/null
+++ b/packages/leptos/src/unlink_2.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Unlink2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 7h2a5 5 0 0 1 0 10h-2m-6 0H7A5 5 0 0 1 7 7h2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/unplug.rs b/packages/leptos/src/unplug.rs
new file mode 100644
index 0000000..3bdf5d7
--- /dev/null
+++ b/packages/leptos/src/unplug.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Unplug(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 5 3-3"></path>
+            <path d="m2 22 3-3"></path>
+            <path d="M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z"></path>
+            <path d="M7.5 13.5 10 11"></path>
+            <path d="M10.5 16.5 13 14"></path>
+            <path d="m12 6 6 6 2.3-2.3a2.4 2.4 0 0 0 0-3.4l-2.6-2.6a2.4 2.4 0 0 0-3.4 0Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/upload.rs b/packages/leptos/src/upload.rs
new file mode 100644
index 0000000..a0aef98
--- /dev/null
+++ b/packages/leptos/src/upload.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Upload(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path>
+            <polyline points="17 8 12 3 7 8"></polyline>
+            <line x1="12" x2="12" y1="3" y2="15"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/usb.rs b/packages/leptos/src/usb.rs
new file mode 100644
index 0000000..7d8fe20
--- /dev/null
+++ b/packages/leptos/src/usb.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Usb(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="10" cy="7" r="1"></circle>
+            <circle cx="4" cy="20" r="1"></circle>
+            <path d="M4.7 19.3 19 5"></path>
+            <path d="m21 3-3 1 2 2Z"></path>
+            <path d="M9.26 7.68 5 12l2 5"></path>
+            <path d="m10 14 5 2 3.5-3.5"></path>
+            <path d="m18 12 1-1 1 1-1 1Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user.rs b/packages/leptos/src/user.rs
new file mode 100644
index 0000000..fe6bc6e
--- /dev/null
+++ b/packages/leptos/src/user.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn User(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 21v-2a4 4 0 0 0-4-4H9a4 4 0 0 0-4 4v2"></path>
+            <circle cx="12" cy="7" r="4"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_check.rs b/packages/leptos/src/user_check.rs
new file mode 100644
index 0000000..ff09ad4
--- /dev/null
+++ b/packages/leptos/src/user_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"></path>
+            <circle cx="9" cy="7" r="4"></circle>
+            <polyline points="16 11 18 13 22 9"></polyline>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_cog.rs b/packages/leptos/src/user_cog.rs
new file mode 100644
index 0000000..b1f6798
--- /dev/null
+++ b/packages/leptos/src/user_cog.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="15" r="3"></circle>
+            <circle cx="9" cy="7" r="4"></circle>
+            <path d="M10 15H6a4 4 0 0 0-4 4v2"></path>
+            <path d="m21.7 16.4-.9-.3"></path>
+            <path d="m15.2 13.9-.9-.3"></path>
+            <path d="m16.6 18.7.3-.9"></path>
+            <path d="m19.1 12.2.3-.9"></path>
+            <path d="m19.6 18.7-.4-1"></path>
+            <path d="m16.8 12.3-.4-1"></path>
+            <path d="m14.3 16.6 1-.4"></path>
+            <path d="m20.7 13.8 1-.4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_minus.rs b/packages/leptos/src/user_minus.rs
new file mode 100644
index 0000000..5098b8c
--- /dev/null
+++ b/packages/leptos/src/user_minus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"></path>
+            <circle cx="9" cy="7" r="4"></circle>
+            <line x1="22" x2="16" y1="11" y2="11"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_pen.rs b/packages/leptos/src/user_pen.rs
new file mode 100644
index 0000000..841481d
--- /dev/null
+++ b/packages/leptos/src/user_pen.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserPen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.5 15H7a4 4 0 0 0-4 4v2"></path>
+            <path d="M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"></path>
+            <circle cx="10" cy="7" r="4"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_plus.rs b/packages/leptos/src/user_plus.rs
new file mode 100644
index 0000000..9863051
--- /dev/null
+++ b/packages/leptos/src/user_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"></path>
+            <circle cx="9" cy="7" r="4"></circle>
+            <line x1="19" x2="19" y1="8" y2="14"></line>
+            <line x1="22" x2="16" y1="11" y2="11"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_round.rs b/packages/leptos/src/user_round.rs
new file mode 100644
index 0000000..0ed94ef
--- /dev/null
+++ b/packages/leptos/src/user_round.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserRound(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="8" r="5"></circle>
+            <path d="M20 21a8 8 0 0 0-16 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_round_check.rs b/packages/leptos/src/user_round_check.rs
new file mode 100644
index 0000000..405f192
--- /dev/null
+++ b/packages/leptos/src/user_round_check.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserRoundCheck(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 13.292-6"></path>
+            <circle cx="10" cy="8" r="5"></circle>
+            <path d="m16 19 2 2 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_round_cog.rs b/packages/leptos/src/user_round_cog.rs
new file mode 100644
index 0000000..1f6707c
--- /dev/null
+++ b/packages/leptos/src/user_round_cog.rs
@@ -0,0 +1,45 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserRoundCog(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 10.434-7.62"></path>
+            <circle cx="10" cy="8" r="5"></circle>
+            <circle cx="18" cy="18" r="3"></circle>
+            <path d="m19.5 14.3-.4.9"></path>
+            <path d="m16.9 20.8-.4.9"></path>
+            <path d="m21.7 19.5-.9-.4"></path>
+            <path d="m15.2 16.9-.9-.4"></path>
+            <path d="m21.7 16.5-.9.4"></path>
+            <path d="m15.2 19.1-.9.4"></path>
+            <path d="m19.5 21.7-.4-.9"></path>
+            <path d="m16.9 15.2-.4-.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_round_minus.rs b/packages/leptos/src/user_round_minus.rs
new file mode 100644
index 0000000..a683943
--- /dev/null
+++ b/packages/leptos/src/user_round_minus.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserRoundMinus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 13.292-6"></path>
+            <circle cx="10" cy="8" r="5"></circle>
+            <path d="M22 19h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_round_pen.rs b/packages/leptos/src/user_round_pen.rs
new file mode 100644
index 0000000..92ce824
--- /dev/null
+++ b/packages/leptos/src/user_round_pen.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserRoundPen(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 10.821-7.487"></path>
+            <path d="M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"></path>
+            <circle cx="10" cy="8" r="5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_round_plus.rs b/packages/leptos/src/user_round_plus.rs
new file mode 100644
index 0000000..61c6321
--- /dev/null
+++ b/packages/leptos/src/user_round_plus.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserRoundPlus(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 13.292-6"></path>
+            <circle cx="10" cy="8" r="5"></circle>
+            <path d="M19 16v6"></path>
+            <path d="M22 19h-6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_round_search.rs b/packages/leptos/src/user_round_search.rs
new file mode 100644
index 0000000..d500f52
--- /dev/null
+++ b/packages/leptos/src/user_round_search.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserRoundSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="10" cy="8" r="5"></circle>
+            <path d="M2 21a8 8 0 0 1 10.434-7.62"></path>
+            <circle cx="18" cy="18" r="3"></circle>
+            <path d="m22 22-1.9-1.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_round_x.rs b/packages/leptos/src/user_round_x.rs
new file mode 100644
index 0000000..c649439
--- /dev/null
+++ b/packages/leptos/src/user_round_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserRoundX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 11.873-7"></path>
+            <circle cx="10" cy="8" r="5"></circle>
+            <path d="m17 17 5 5"></path>
+            <path d="m22 17-5 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_search.rs b/packages/leptos/src/user_search.rs
new file mode 100644
index 0000000..65931df
--- /dev/null
+++ b/packages/leptos/src/user_search.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserSearch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="10" cy="7" r="4"></circle>
+            <path d="M10.3 15H7a4 4 0 0 0-4 4v2"></path>
+            <circle cx="17" cy="17" r="3"></circle>
+            <path d="m21 21-1.9-1.9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/user_x.rs b/packages/leptos/src/user_x.rs
new file mode 100644
index 0000000..caaa14f
--- /dev/null
+++ b/packages/leptos/src/user_x.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UserX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"></path>
+            <circle cx="9" cy="7" r="4"></circle>
+            <line x1="17" x2="22" y1="8" y2="13"></line>
+            <line x1="22" x2="17" y1="8" y2="13"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/users.rs b/packages/leptos/src/users.rs
new file mode 100644
index 0000000..83ddd3d
--- /dev/null
+++ b/packages/leptos/src/users.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Users(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"></path>
+            <circle cx="9" cy="7" r="4"></circle>
+            <path d="M22 21v-2a4 4 0 0 0-3-3.87"></path>
+            <path d="M16 3.13a4 4 0 0 1 0 7.75"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/users_round.rs b/packages/leptos/src/users_round.rs
new file mode 100644
index 0000000..276d606
--- /dev/null
+++ b/packages/leptos/src/users_round.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UsersRound(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 21a8 8 0 0 0-16 0"></path>
+            <circle cx="10" cy="8" r="5"></circle>
+            <path d="M22 20c0-3.37-2-6.5-4-8a5 5 0 0 0-.45-8.3"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/utensils.rs b/packages/leptos/src/utensils.rs
new file mode 100644
index 0000000..7fb888c
--- /dev/null
+++ b/packages/leptos/src/utensils.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Utensils(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 2v7c0 1.1.9 2 2 2h4a2 2 0 0 0 2-2V2"></path>
+            <path d="M7 2v20"></path>
+            <path d="M21 15V2a5 5 0 0 0-5 5v6c0 1.1.9 2 2 2h3Zm0 0v7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/utensils_crossed.rs b/packages/leptos/src/utensils_crossed.rs
new file mode 100644
index 0000000..eecebc1
--- /dev/null
+++ b/packages/leptos/src/utensils_crossed.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UtensilsCrossed(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 2-2.3 2.3a3 3 0 0 0 0 4.2l1.8 1.8a3 3 0 0 0 4.2 0L22 8"></path>
+            <path d="M15 15 3.3 3.3a4.2 4.2 0 0 0 0 6l7.3 7.3c.7.7 2 .7 2.8 0L15 15Zm0 0 7 7"></path>
+            <path d="m2.1 21.8 6.4-6.3"></path>
+            <path d="m19 5-7 7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/utility_pole.rs b/packages/leptos/src/utility_pole.rs
new file mode 100644
index 0000000..ee1abee
--- /dev/null
+++ b/packages/leptos/src/utility_pole.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn UtilityPole(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v20"></path>
+            <path d="M2 5h20"></path>
+            <path d="M3 3v2"></path>
+            <path d="M7 3v2"></path>
+            <path d="M17 3v2"></path>
+            <path d="M21 3v2"></path>
+            <path d="m19 5-7 7-7-7"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/variable.rs b/packages/leptos/src/variable.rs
new file mode 100644
index 0000000..db94a2f
--- /dev/null
+++ b/packages/leptos/src/variable.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Variable(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 21s-4-3-4-9 4-9 4-9"></path>
+            <path d="M16 3s4 3 4 9-4 9-4 9"></path>
+            <line x1="15" x2="9" y1="9" y2="15"></line>
+            <line x1="9" x2="15" y1="9" y2="15"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/vault.rs b/packages/leptos/src/vault.rs
new file mode 100644
index 0000000..466b4c4
--- /dev/null
+++ b/packages/leptos/src/vault.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Vault(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <circle cx="7.5" cy="7.5" r=".5" fill="currentColor"></circle>
+            <path d="m7.9 7.9 2.7 2.7"></path>
+            <circle cx="16.5" cy="7.5" r=".5" fill="currentColor"></circle>
+            <path d="m13.4 10.6 2.7-2.7"></path>
+            <circle cx="7.5" cy="16.5" r=".5" fill="currentColor"></circle>
+            <path d="m7.9 16.1 2.7-2.7"></path>
+            <circle cx="16.5" cy="16.5" r=".5" fill="currentColor"></circle>
+            <path d="m13.4 13.4 2.7 2.7"></path>
+            <circle cx="12" cy="12" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/vegan.rs b/packages/leptos/src/vegan.rs
new file mode 100644
index 0000000..684f533
--- /dev/null
+++ b/packages/leptos/src/vegan.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Vegan(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 8q6 0 6-6-6 0-6 6"></path>
+            <path d="M17.41 3.59a10 10 0 1 0 3 3"></path>
+            <path d="M2 2a26.6 26.6 0 0 1 10 20c.9-6.82 1.5-9.5 4-14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/venetian_mask.rs b/packages/leptos/src/venetian_mask.rs
new file mode 100644
index 0000000..c6d7660
--- /dev/null
+++ b/packages/leptos/src/venetian_mask.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn VenetianMask(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12a5 5 0 0 0 5 5 8 8 0 0 1 5 2 8 8 0 0 1 5-2 5 5 0 0 0 5-5V7h-5a8 8 0 0 0-5 2 8 8 0 0 0-5-2H2Z"></path>
+            <path d="M6 11c1.5 0 3 .5 3 2-2 0-3 0-3-2Z"></path>
+            <path d="M18 11c-1.5 0-3 .5-3 2 2 0 3 0 3-2Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/vibrate.rs b/packages/leptos/src/vibrate.rs
new file mode 100644
index 0000000..7b6028b
--- /dev/null
+++ b/packages/leptos/src/vibrate.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Vibrate(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 8 2 2-2 2 2 2-2 2"></path>
+            <path d="m22 8-2 2 2 2-2 2 2 2"></path>
+            <rect width="8" height="14" x="8" y="5" rx="1"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/vibrate_off.rs b/packages/leptos/src/vibrate_off.rs
new file mode 100644
index 0000000..aced9e0
--- /dev/null
+++ b/packages/leptos/src/vibrate_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn VibrateOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 8 2 2-2 2 2 2-2 2"></path>
+            <path d="m22 8-2 2 2 2-2 2 2 2"></path>
+            <path d="M8 8v10c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2"></path>
+            <path d="M16 10.34V6c0-.55-.45-1-1-1h-4.34"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/video.rs b/packages/leptos/src/video.rs
new file mode 100644
index 0000000..48316df
--- /dev/null
+++ b/packages/leptos/src/video.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Video(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 13 5.223 3.482a.5.5 0 0 0 .777-.416V7.87a.5.5 0 0 0-.752-.432L16 10.5"></path>
+            <rect x="2" y="6" width="14" height="12" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/video_off.rs b/packages/leptos/src/video_off.rs
new file mode 100644
index 0000000..8edcdb1
--- /dev/null
+++ b/packages/leptos/src/video_off.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn VideoOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.66 6H14a2 2 0 0 1 2 2v2.5l5.248-3.062A.5.5 0 0 1 22 7.87v8.196"></path>
+            <path d="M16 16a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h2"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/videotape.rs b/packages/leptos/src/videotape.rs
new file mode 100644
index 0000000..4c317c6
--- /dev/null
+++ b/packages/leptos/src/videotape.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Videotape(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+            <path d="M2 8h20"></path>
+            <circle cx="8" cy="14" r="2"></circle>
+            <path d="M8 12h8"></path>
+            <circle cx="16" cy="14" r="2"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/view.rs b/packages/leptos/src/view.rs
new file mode 100644
index 0000000..931cd27
--- /dev/null
+++ b/packages/leptos/src/view.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn View(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 17v2a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-2"></path>
+            <path d="M21 7V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2"></path>
+            <circle cx="12" cy="12" r="1"></circle>
+            <path d="M18.944 12.33a1 1 0 0 0 0-.66 7.5 7.5 0 0 0-13.888 0 1 1 0 0 0 0 .66 7.5 7.5 0 0 0 13.888 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/voicemail.rs b/packages/leptos/src/voicemail.rs
new file mode 100644
index 0000000..2799f66
--- /dev/null
+++ b/packages/leptos/src/voicemail.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Voicemail(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="12" r="4"></circle>
+            <circle cx="18" cy="12" r="4"></circle>
+            <line x1="6" x2="18" y1="16" y2="16"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/volleyball.rs b/packages/leptos/src/volleyball.rs
new file mode 100644
index 0000000..86f1463
--- /dev/null
+++ b/packages/leptos/src/volleyball.rs
@@ -0,0 +1,40 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Volleyball(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.1 7.1a16.55 16.55 0 0 1 10.9 4"></path>
+            <path d="M12 12a12.6 12.6 0 0 1-8.7 5"></path>
+            <path d="M16.8 13.6a16.55 16.55 0 0 1-9 7.5"></path>
+            <path d="M20.7 17a12.8 12.8 0 0 0-8.7-5 13.3 13.3 0 0 1 0-10"></path>
+            <path d="M6.3 3.8a16.55 16.55 0 0 0 1.9 11.5"></path>
+            <circle cx="12" cy="12" r="10"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/volume.rs b/packages/leptos/src/volume.rs
new file mode 100644
index 0000000..943e1d2
--- /dev/null
+++ b/packages/leptos/src/volume.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Volume(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/volume_1.rs b/packages/leptos/src/volume_1.rs
new file mode 100644
index 0000000..bcc89c5
--- /dev/null
+++ b/packages/leptos/src/volume_1.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Volume1(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"></path>
+            <path d="M16 9a5 5 0 0 1 0 6"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/volume_2.rs b/packages/leptos/src/volume_2.rs
new file mode 100644
index 0000000..00c4a4a
--- /dev/null
+++ b/packages/leptos/src/volume_2.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Volume2(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"></path>
+            <path d="M16 9a5 5 0 0 1 0 6"></path>
+            <path d="M19.364 18.364a9 9 0 0 0 0-12.728"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/volume_off.rs b/packages/leptos/src/volume_off.rs
new file mode 100644
index 0000000..dcd0310
--- /dev/null
+++ b/packages/leptos/src/volume_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn VolumeOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 9a5 5 0 0 1 .95 2.293"></path>
+            <path d="M19.364 5.636a9 9 0 0 1 1.889 9.96"></path>
+            <path d="m2 2 20 20"></path>
+            <path d="m7 7-.587.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298V11"></path>
+            <path d="M9.828 4.172A.686.686 0 0 1 11 4.657v.686"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/volume_x.rs b/packages/leptos/src/volume_x.rs
new file mode 100644
index 0000000..dc0f3af
--- /dev/null
+++ b/packages/leptos/src/volume_x.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn VolumeX(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"></path>
+            <line x1="22" x2="16" y1="9" y2="15"></line>
+            <line x1="16" x2="22" y1="9" y2="15"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/vote.rs b/packages/leptos/src/vote.rs
new file mode 100644
index 0000000..b039616
--- /dev/null
+++ b/packages/leptos/src/vote.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Vote(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 12 2 2 4-4"></path>
+            <path d="M5 7c0-1.1.9-2 2-2h10a2 2 0 0 1 2 2v12H5V7Z"></path>
+            <path d="M22 19H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wallet.rs b/packages/leptos/src/wallet.rs
new file mode 100644
index 0000000..be6f370
--- /dev/null
+++ b/packages/leptos/src/wallet.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Wallet(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 7V4a1 1 0 0 0-1-1H5a2 2 0 0 0 0 4h15a1 1 0 0 1 1 1v4h-3a2 2 0 0 0 0 4h3a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1"></path>
+            <path d="M3 5v14a2 2 0 0 0 2 2h15a1 1 0 0 0 1-1v-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wallet_cards.rs b/packages/leptos/src/wallet_cards.rs
new file mode 100644
index 0000000..07e4d24
--- /dev/null
+++ b/packages/leptos/src/wallet_cards.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WalletCards(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2"></rect>
+            <path d="M3 9a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2"></path>
+            <path d="M3 11h3c.8 0 1.6.3 2.1.9l1.1.9c1.6 1.6 4.1 1.6 5.7 0l1.1-.9c.5-.5 1.3-.9 2.1-.9H21"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wallet_minimal.rs b/packages/leptos/src/wallet_minimal.rs
new file mode 100644
index 0000000..04be629
--- /dev/null
+++ b/packages/leptos/src/wallet_minimal.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WalletMinimal(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 14h.01"></path>
+            <path d="M7 7h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wallpaper.rs b/packages/leptos/src/wallpaper.rs
new file mode 100644
index 0000000..dae963e
--- /dev/null
+++ b/packages/leptos/src/wallpaper.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Wallpaper(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="8" cy="9" r="2"></circle>
+            <path d="m9 17 6.1-6.1a2 2 0 0 1 2.81.01L22 15V5a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2"></path>
+            <path d="M8 21h8"></path>
+            <path d="M12 17v4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wand.rs b/packages/leptos/src/wand.rs
new file mode 100644
index 0000000..985341a
--- /dev/null
+++ b/packages/leptos/src/wand.rs
@@ -0,0 +1,43 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Wand(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 4V2"></path>
+            <path d="M15 16v-2"></path>
+            <path d="M8 9h2"></path>
+            <path d="M20 9h2"></path>
+            <path d="M17.8 11.8 19 13"></path>
+            <path d="M15 9h.01"></path>
+            <path d="M17.8 6.2 19 5"></path>
+            <path d="m3 21 9-9"></path>
+            <path d="M12.2 6.2 11 5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wand_sparkles.rs b/packages/leptos/src/wand_sparkles.rs
new file mode 100644
index 0000000..9566b9f
--- /dev/null
+++ b/packages/leptos/src/wand_sparkles.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WandSparkles(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21.64 3.64-1.28-1.28a1.21 1.21 0 0 0-1.72 0L2.36 18.64a1.21 1.21 0 0 0 0 1.72l1.28 1.28a1.2 1.2 0 0 0 1.72 0L21.64 5.36a1.2 1.2 0 0 0 0-1.72"></path>
+            <path d="m14 7 3 3"></path>
+            <path d="M5 6v4"></path>
+            <path d="M19 14v4"></path>
+            <path d="M10 2v2"></path>
+            <path d="M7 8H3"></path>
+            <path d="M21 16h-4"></path>
+            <path d="M11 3H9"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/warehouse.rs b/packages/leptos/src/warehouse.rs
new file mode 100644
index 0000000..9cefabf
--- /dev/null
+++ b/packages/leptos/src/warehouse.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Warehouse(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 8.35V20a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8.35A2 2 0 0 1 3.26 6.5l8-3.2a2 2 0 0 1 1.48 0l8 3.2A2 2 0 0 1 22 8.35Z"></path>
+            <path d="M6 18h12"></path>
+            <path d="M6 14h12"></path>
+            <rect width="12" height="12" x="6" y="10"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/washing_machine.rs b/packages/leptos/src/washing_machine.rs
new file mode 100644
index 0000000..75e3910
--- /dev/null
+++ b/packages/leptos/src/washing_machine.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WashingMachine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 6h3"></path>
+            <path d="M17 6h.01"></path>
+            <rect width="18" height="20" x="3" y="2" rx="2"></rect>
+            <circle cx="12" cy="13" r="5"></circle>
+            <path d="M12 18a2.5 2.5 0 0 0 0-5 2.5 2.5 0 0 1 0-5"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/watch.rs b/packages/leptos/src/watch.rs
new file mode 100644
index 0000000..ef64f0d
--- /dev/null
+++ b/packages/leptos/src/watch.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Watch(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="6"></circle>
+            <polyline points="12 10 12 12 13 13"></polyline>
+            <path d="m16.13 7.66-.81-4.05a2 2 0 0 0-2-1.61h-2.68a2 2 0 0 0-2 1.61l-.78 4.05"></path>
+            <path d="m7.88 16.36.8 4a2 2 0 0 0 2 1.61h2.72a2 2 0 0 0 2-1.61l.81-4.05"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/waves.rs b/packages/leptos/src/waves.rs
new file mode 100644
index 0000000..3abe140
--- /dev/null
+++ b/packages/leptos/src/waves.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Waves(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 6c.6.5 1.2 1 2.5 1C7 7 7 5 9.5 5c2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"></path>
+            <path d="M2 12c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"></path>
+            <path d="M2 18c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/waypoints.rs b/packages/leptos/src/waypoints.rs
new file mode 100644
index 0000000..e28422f
--- /dev/null
+++ b/packages/leptos/src/waypoints.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Waypoints(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="4.5" r="2.5"></circle>
+            <path d="m10.2 6.3-3.9 3.9"></path>
+            <circle cx="4.5" cy="12" r="2.5"></circle>
+            <path d="M7 12h10"></path>
+            <circle cx="19.5" cy="12" r="2.5"></circle>
+            <path d="m13.8 17.7 3.9-3.9"></path>
+            <circle cx="12" cy="19.5" r="2.5"></circle>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/webcam.rs b/packages/leptos/src/webcam.rs
new file mode 100644
index 0000000..7d4e190
--- /dev/null
+++ b/packages/leptos/src/webcam.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Webcam(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="10" r="8"></circle>
+            <circle cx="12" cy="10" r="3"></circle>
+            <path d="M7 22h10"></path>
+            <path d="M12 22v-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/webhook.rs b/packages/leptos/src/webhook.rs
new file mode 100644
index 0000000..e3335a9
--- /dev/null
+++ b/packages/leptos/src/webhook.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Webhook(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 16.98h-5.99c-1.1 0-1.95.94-2.48 1.9A4 4 0 0 1 2 17c.01-.7.2-1.4.57-2"></path>
+            <path d="m6 17 3.13-5.78c.53-.97.1-2.18-.5-3.1a4 4 0 1 1 6.89-4.06"></path>
+            <path d="m12 6 3.13 5.73C15.66 12.7 16.9 13 18 13a4 4 0 0 1 0 8"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/webhook_off.rs b/packages/leptos/src/webhook_off.rs
new file mode 100644
index 0000000..35af4de
--- /dev/null
+++ b/packages/leptos/src/webhook_off.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WebhookOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 17h-5c-1.09-.02-1.94.92-2.5 1.9A3 3 0 1 1 2.57 15"></path>
+            <path d="M9 3.4a4 4 0 0 1 6.52.66"></path>
+            <path d="m6 17 3.1-5.8a2.5 2.5 0 0 0 .057-2.05"></path>
+            <path d="M20.3 20.3a4 4 0 0 1-2.3.7"></path>
+            <path d="M18.6 13a4 4 0 0 1 3.357 3.414"></path>
+            <path d="m12 6 .6 1"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/weight.rs b/packages/leptos/src/weight.rs
new file mode 100644
index 0000000..4561fd0
--- /dev/null
+++ b/packages/leptos/src/weight.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Weight(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="5" r="3"></circle>
+            <path d="M6.5 8a2 2 0 0 0-1.905 1.46L2.1 18.5A2 2 0 0 0 4 21h16a2 2 0 0 0 1.925-2.54L19.4 9.5A2 2 0 0 0 17.48 8Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wheat.rs b/packages/leptos/src/wheat.rs
new file mode 100644
index 0000000..8348955
--- /dev/null
+++ b/packages/leptos/src/wheat.rs
@@ -0,0 +1,42 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Wheat(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22 16 8"></path>
+            <path d="M3.47 12.53 5 11l1.53 1.53a3.5 3.5 0 0 1 0 4.94L5 19l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"></path>
+            <path d="M7.47 8.53 9 7l1.53 1.53a3.5 3.5 0 0 1 0 4.94L9 15l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"></path>
+            <path d="M11.47 4.53 13 3l1.53 1.53a3.5 3.5 0 0 1 0 4.94L13 11l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"></path>
+            <path d="M20 2h2v2a4 4 0 0 1-4 4h-2V6a4 4 0 0 1 4-4Z"></path>
+            <path d="M11.47 17.47 13 19l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L5 19l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"></path>
+            <path d="M15.47 13.47 17 15l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L9 15l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"></path>
+            <path d="M19.47 9.47 21 11l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L13 11l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wheat_off.rs b/packages/leptos/src/wheat_off.rs
new file mode 100644
index 0000000..de4ede2
--- /dev/null
+++ b/packages/leptos/src/wheat_off.rs
@@ -0,0 +1,44 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WheatOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 22 10-10"></path>
+            <path d="m16 8-1.17 1.17"></path>
+            <path d="M3.47 12.53 5 11l1.53 1.53a3.5 3.5 0 0 1 0 4.94L5 19l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"></path>
+            <path d="m8 8-.53.53a3.5 3.5 0 0 0 0 4.94L9 15l1.53-1.53c.55-.55.88-1.25.98-1.97"></path>
+            <path d="M10.91 5.26c.15-.26.34-.51.56-.73L13 3l1.53 1.53a3.5 3.5 0 0 1 .28 4.62"></path>
+            <path d="M20 2h2v2a4 4 0 0 1-4 4h-2V6a4 4 0 0 1 4-4Z"></path>
+            <path d="M11.47 17.47 13 19l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L5 19l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"></path>
+            <path d="m16 16-.53.53a3.5 3.5 0 0 1-4.94 0L9 15l1.53-1.53a3.49 3.49 0 0 1 1.97-.98"></path>
+            <path d="M18.74 13.09c.26-.15.51-.34.73-.56L21 11l-1.53-1.53a3.5 3.5 0 0 0-4.62-.28"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/whole_word.rs b/packages/leptos/src/whole_word.rs
new file mode 100644
index 0000000..bf1e2cf
--- /dev/null
+++ b/packages/leptos/src/whole_word.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WholeWord(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="7" cy="12" r="3"></circle>
+            <path d="M10 9v6"></path>
+            <circle cx="17" cy="12" r="3"></circle>
+            <path d="M14 7v8"></path>
+            <path d="M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wifi.rs b/packages/leptos/src/wifi.rs
new file mode 100644
index 0000000..3455436
--- /dev/null
+++ b/packages/leptos/src/wifi.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Wifi(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01"></path>
+            <path d="M2 8.82a15 15 0 0 1 20 0"></path>
+            <path d="M5 12.859a10 10 0 0 1 14 0"></path>
+            <path d="M8.5 16.429a5 5 0 0 1 7 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wifi_high.rs b/packages/leptos/src/wifi_high.rs
new file mode 100644
index 0000000..f191aef
--- /dev/null
+++ b/packages/leptos/src/wifi_high.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WifiHigh(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01"></path>
+            <path d="M5 12.859a10 10 0 0 1 14 0"></path>
+            <path d="M8.5 16.429a5 5 0 0 1 7 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wifi_low.rs b/packages/leptos/src/wifi_low.rs
new file mode 100644
index 0000000..09563d4
--- /dev/null
+++ b/packages/leptos/src/wifi_low.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WifiLow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01"></path>
+            <path d="M8.5 16.429a5 5 0 0 1 7 0"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wifi_off.rs b/packages/leptos/src/wifi_off.rs
new file mode 100644
index 0000000..989f149
--- /dev/null
+++ b/packages/leptos/src/wifi_off.rs
@@ -0,0 +1,41 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WifiOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01"></path>
+            <path d="M8.5 16.429a5 5 0 0 1 7 0"></path>
+            <path d="M5 12.859a10 10 0 0 1 5.17-2.69"></path>
+            <path d="M19 12.859a10 10 0 0 0-2.007-1.523"></path>
+            <path d="M2 8.82a15 15 0 0 1 4.177-2.643"></path>
+            <path d="M22 8.82a15 15 0 0 0-11.288-3.764"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wifi_zero.rs b/packages/leptos/src/wifi_zero.rs
new file mode 100644
index 0000000..31c4181
--- /dev/null
+++ b/packages/leptos/src/wifi_zero.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WifiZero(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wind.rs b/packages/leptos/src/wind.rs
new file mode 100644
index 0000000..669dd7e
--- /dev/null
+++ b/packages/leptos/src/wind.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Wind(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.8 19.6A2 2 0 1 0 14 16H2"></path>
+            <path d="M17.5 8a2.5 2.5 0 1 1 2 4H2"></path>
+            <path d="M9.8 4.4A2 2 0 1 1 11 8H2"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wind_arrow_down.rs b/packages/leptos/src/wind_arrow_down.rs
new file mode 100644
index 0000000..68dc050
--- /dev/null
+++ b/packages/leptos/src/wind_arrow_down.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WindArrowDown(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v8"></path>
+            <path d="M12.8 21.6A2 2 0 1 0 14 18H2"></path>
+            <path d="M17.5 10a2.5 2.5 0 1 1 2 4H2"></path>
+            <path d="m6 6 4 4 4-4"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wine.rs b/packages/leptos/src/wine.rs
new file mode 100644
index 0000000..3329d3d
--- /dev/null
+++ b/packages/leptos/src/wine.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Wine(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 22h8"></path>
+            <path d="M7 10h10"></path>
+            <path d="M12 15v7"></path>
+            <path d="M12 15a5 5 0 0 0 5-5c0-2-.5-4-2-8H9c-1.5 4-2 6-2 8a5 5 0 0 0 5 5Z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wine_off.rs b/packages/leptos/src/wine_off.rs
new file mode 100644
index 0000000..c4b3c7b
--- /dev/null
+++ b/packages/leptos/src/wine_off.rs
@@ -0,0 +1,39 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WineOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 22h8"></path>
+            <path d="M7 10h3m7 0h-1.343"></path>
+            <path d="M12 15v7"></path>
+            <path d="M7.307 7.307A12.33 12.33 0 0 0 7 10a5 5 0 0 0 7.391 4.391M8.638 2.981C8.75 2.668 8.872 2.34 9 2h6c1.5 4 2 6 2 8 0 .407-.05.809-.145 1.198"></path>
+            <line x1="2" x2="22" y1="2" y2="22"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/workflow.rs b/packages/leptos/src/workflow.rs
new file mode 100644
index 0000000..11d9fba
--- /dev/null
+++ b/packages/leptos/src/workflow.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Workflow(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="8" x="3" y="3" rx="2"></rect>
+            <path d="M7 11v4a2 2 0 0 0 2 2h4"></path>
+            <rect width="8" height="8" x="13" y="13" rx="2"></rect>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/worm.rs b/packages/leptos/src/worm.rs
new file mode 100644
index 0000000..21ed33f
--- /dev/null
+++ b/packages/leptos/src/worm.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Worm(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 12-1.5 3"></path>
+            <path d="M19.63 18.81 22 20"></path>
+            <path d="M6.47 8.23a1.68 1.68 0 0 1 2.44 1.93l-.64 2.08a6.76 6.76 0 0 0 10.16 7.67l.42-.27a1 1 0 1 0-2.73-4.21l-.42.27a1.76 1.76 0 0 1-2.63-1.99l.64-2.08A6.66 6.66 0 0 0 3.94 3.9l-.7.4a1 1 0 1 0 2.55 4.34z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wrap_text.rs b/packages/leptos/src/wrap_text.rs
new file mode 100644
index 0000000..286cd77
--- /dev/null
+++ b/packages/leptos/src/wrap_text.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn WrapText(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="3" x2="21" y1="6" y2="6"></line>
+            <path d="M3 12h15a3 3 0 1 1 0 6h-4"></path>
+            <polyline points="16 16 14 18 16 20"></polyline>
+            <line x1="3" x2="10" y1="18" y2="18"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/wrench.rs b/packages/leptos/src/wrench.rs
new file mode 100644
index 0000000..4135508
--- /dev/null
+++ b/packages/leptos/src/wrench.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Wrench(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/x.rs b/packages/leptos/src/x.rs
new file mode 100644
index 0000000..d5972f7
--- /dev/null
+++ b/packages/leptos/src/x.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn X(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 6 6 18"></path>
+            <path d="m6 6 12 12"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/youtube.rs b/packages/leptos/src/youtube.rs
new file mode 100644
index 0000000..e6edb44
--- /dev/null
+++ b/packages/leptos/src/youtube.rs
@@ -0,0 +1,36 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Youtube(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2.5 17a24.12 24.12 0 0 1 0-10 2 2 0 0 1 1.4-1.4 49.56 49.56 0 0 1 16.2 0A2 2 0 0 1 21.5 7a24.12 24.12 0 0 1 0 10 2 2 0 0 1-1.4 1.4 49.55 49.55 0 0 1-16.2 0A2 2 0 0 1 2.5 17"></path>
+            <path d="m10 15 5-3-5-3z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/zap.rs b/packages/leptos/src/zap.rs
new file mode 100644
index 0000000..d3e7176
--- /dev/null
+++ b/packages/leptos/src/zap.rs
@@ -0,0 +1,35 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn Zap(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14a1 1 0 0 1-.78-1.63l9.9-10.2a.5.5 0 0 1 .86.46l-1.92 6.02A1 1 0 0 0 13 10h7a1 1 0 0 1 .78 1.63l-9.9 10.2a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14z"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/zap_off.rs b/packages/leptos/src/zap_off.rs
new file mode 100644
index 0000000..e6052f0
--- /dev/null
+++ b/packages/leptos/src/zap_off.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ZapOff(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.513 4.856 13.12 2.17a.5.5 0 0 1 .86.46l-1.377 4.317"></path>
+            <path d="M15.656 10H20a1 1 0 0 1 .78 1.63l-1.72 1.773"></path>
+            <path d="M16.273 16.273 10.88 21.83a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14H4a1 1 0 0 1-.78-1.63l4.507-4.643"></path>
+            <path d="m2 2 20 20"></path>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/zoom_in.rs b/packages/leptos/src/zoom_in.rs
new file mode 100644
index 0000000..d5275e5
--- /dev/null
+++ b/packages/leptos/src/zoom_in.rs
@@ -0,0 +1,38 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ZoomIn(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="11" r="8"></circle>
+            <line x1="21" x2="16.65" y1="21" y2="16.65"></line>
+            <line x1="11" x2="11" y1="8" y2="14"></line>
+            <line x1="8" x2="14" y1="11" y2="11"></line>
+        </svg>
+    }
+}
diff --git a/packages/leptos/src/zoom_out.rs b/packages/leptos/src/zoom_out.rs
new file mode 100644
index 0000000..324110f
--- /dev/null
+++ b/packages/leptos/src/zoom_out.rs
@@ -0,0 +1,37 @@
+use leptos::{prelude::*, svg::Svg};
+#[component]
+pub fn ZoomOut(
+    #[prop(default = 24.into(), into)] size: Signal<usize>,
+    #[prop(default = "currentColor".into(), into)] color: Signal<String>,
+    #[prop(default = "none".into(), into)] fill: Signal<String>,
+    #[prop(default = 2.into(), into)] stroke_width: Signal<usize>,
+    #[prop(default = false.into(), into)] absolute_stroke_width: Signal<bool>,
+    #[prop(optional)] node_ref: NodeRef<Svg>,
+) -> impl IntoView {
+    let stroke_width = Signal::derive(move || {
+        if absolute_stroke_width.get() {
+            stroke_width.get() * 24 / size.get()
+        } else {
+            stroke_width.get()
+        }
+    });
+    view! {
+        <svg
+            node_ref=node_ref
+            class:lucide=true
+            xmlns="http://www.w3.org/2000/svg"
+            width=size
+            height=size
+            viewBox="0 0 24 24"
+            fill=fill
+            stroke=color
+            stroke-width=stroke_width
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="11" r="8"></circle>
+            <line x1="21" x2="16.65" y1="21" y2="16.65"></line>
+            <line x1="8" x2="14" y1="11" y2="11"></line>
+        </svg>
+    }
+}
diff --git a/packages/yew/Cargo.toml b/packages/yew/Cargo.toml
index 03fa2f4..115b1e9 100644
--- a/packages/yew/Cargo.toml
+++ b/packages/yew/Cargo.toml
@@ -14,4 +14,3083 @@ yew.workspace = true
 
 [features]
 default = []
-full = []
+a-arrow-down = []
+a-arrow-up = []
+a-large-small = []
+accessibility = []
+activity = []
+air-vent = []
+airplay = []
+alarm-clock-check = []
+alarm-clock-minus = []
+alarm-clock-off = []
+alarm-clock-plus = []
+alarm-clock = []
+alarm-smoke = []
+album = []
+align-center-horizontal = []
+align-center-vertical = []
+align-center = []
+align-end-horizontal = []
+align-end-vertical = []
+align-horizontal-distribute-center = []
+align-horizontal-distribute-end = []
+align-horizontal-distribute-start = []
+align-horizontal-justify-center = []
+align-horizontal-justify-end = []
+align-horizontal-justify-start = []
+align-horizontal-space-around = []
+align-horizontal-space-between = []
+align-justify = []
+align-left = []
+align-right = []
+align-start-horizontal = []
+align-start-vertical = []
+align-vertical-distribute-center = []
+align-vertical-distribute-end = []
+align-vertical-distribute-start = []
+align-vertical-justify-center = []
+align-vertical-justify-end = []
+align-vertical-justify-start = []
+align-vertical-space-around = []
+align-vertical-space-between = []
+ambulance = []
+ampersand = []
+ampersands = []
+amphora = []
+anchor = []
+angry = []
+annoyed = []
+antenna = []
+anvil = []
+aperture = []
+app-window-mac = []
+app-window = []
+apple = []
+archive-restore = []
+archive-x = []
+archive = []
+armchair = []
+arrow-big-down-dash = []
+arrow-big-down = []
+arrow-big-left-dash = []
+arrow-big-left = []
+arrow-big-right-dash = []
+arrow-big-right = []
+arrow-big-up-dash = []
+arrow-big-up = []
+arrow-down-0-1 = []
+arrow-down-1-0 = []
+arrow-down-a-z = []
+arrow-down-from-line = []
+arrow-down-left = []
+arrow-down-narrow-wide = []
+arrow-down-right = []
+arrow-down-to-dot = []
+arrow-down-to-line = []
+arrow-down-up = []
+arrow-down-wide-narrow = []
+arrow-down-z-a = []
+arrow-down = []
+arrow-left-from-line = []
+arrow-left-right = []
+arrow-left-to-line = []
+arrow-left = []
+arrow-right-from-line = []
+arrow-right-left = []
+arrow-right-to-line = []
+arrow-right = []
+arrow-up-0-1 = []
+arrow-up-1-0 = []
+arrow-up-a-z = []
+arrow-up-down = []
+arrow-up-from-dot = []
+arrow-up-from-line = []
+arrow-up-left = []
+arrow-up-narrow-wide = []
+arrow-up-right = []
+arrow-up-to-line = []
+arrow-up-wide-narrow = []
+arrow-up-z-a = []
+arrow-up = []
+arrows-up-from-line = []
+asterisk = []
+at-sign = []
+atom = []
+audio-lines = []
+audio-waveform = []
+award = []
+axe = []
+axis-3-d = []
+baby = []
+backpack = []
+badge-alert = []
+badge-cent = []
+badge-check = []
+badge-dollar-sign = []
+badge-euro = []
+badge-help = []
+badge-indian-rupee = []
+badge-info = []
+badge-japanese-yen = []
+badge-minus = []
+badge-percent = []
+badge-plus = []
+badge-pound-sterling = []
+badge-russian-ruble = []
+badge-swiss-franc = []
+badge-x = []
+badge = []
+baggage-claim = []
+ban = []
+banana = []
+bandage = []
+banknote = []
+barcode = []
+baseline = []
+bath = []
+battery-charging = []
+battery-full = []
+battery-low = []
+battery-medium = []
+battery-warning = []
+battery = []
+beaker = []
+bean-off = []
+bean = []
+bed-double = []
+bed-single = []
+bed = []
+beef = []
+beer-off = []
+beer = []
+bell-dot = []
+bell-electric = []
+bell-minus = []
+bell-off = []
+bell-plus = []
+bell-ring = []
+bell = []
+between-horizontal-end = []
+between-horizontal-start = []
+between-vertical-end = []
+between-vertical-start = []
+biceps-flexed = []
+bike = []
+binary = []
+binoculars = []
+biohazard = []
+bird = []
+bitcoin = []
+blend = []
+blinds = []
+blocks = []
+bluetooth-connected = []
+bluetooth-off = []
+bluetooth-searching = []
+bluetooth = []
+bold = []
+bolt = []
+bomb = []
+bone = []
+book-a = []
+book-audio = []
+book-check = []
+book-copy = []
+book-dashed = []
+book-down = []
+book-headphones = []
+book-heart = []
+book-image = []
+book-key = []
+book-lock = []
+book-marked = []
+book-minus = []
+book-open-check = []
+book-open-text = []
+book-open = []
+book-plus = []
+book-text = []
+book-type = []
+book-up-2 = []
+book-up = []
+book-user = []
+book-x = []
+book = []
+bookmark-check = []
+bookmark-minus = []
+bookmark-plus = []
+bookmark-x = []
+bookmark = []
+boom-box = []
+bot-message-square = []
+bot-off = []
+bot = []
+box = []
+boxes = []
+braces = []
+brackets = []
+brain-circuit = []
+brain-cog = []
+brain = []
+brick-wall = []
+briefcase-business = []
+briefcase-conveyor-belt = []
+briefcase-medical = []
+briefcase = []
+bring-to-front = []
+brush = []
+bug-off = []
+bug-play = []
+bug = []
+building-2 = []
+building = []
+bus-front = []
+bus = []
+cable-car = []
+cable = []
+cake-slice = []
+cake = []
+calculator = []
+calendar-1 = []
+calendar-arrow-down = []
+calendar-arrow-up = []
+calendar-check-2 = []
+calendar-check = []
+calendar-clock = []
+calendar-cog = []
+calendar-days = []
+calendar-fold = []
+calendar-heart = []
+calendar-minus-2 = []
+calendar-minus = []
+calendar-off = []
+calendar-plus-2 = []
+calendar-plus = []
+calendar-range = []
+calendar-search = []
+calendar-x-2 = []
+calendar-x = []
+calendar = []
+camera-off = []
+camera = []
+candy-cane = []
+candy-off = []
+candy = []
+cannabis = []
+captions-off = []
+captions = []
+car-front = []
+car-taxi-front = []
+car = []
+caravan = []
+carrot = []
+case-lower = []
+case-sensitive = []
+case-upper = []
+cassette-tape = []
+cast = []
+castle = []
+cat = []
+cctv = []
+chart-area = []
+chart-bar-big = []
+chart-bar-decreasing = []
+chart-bar-increasing = []
+chart-bar-stacked = []
+chart-bar = []
+chart-candlestick = []
+chart-column-big = []
+chart-column-decreasing = []
+chart-column-increasing = []
+chart-column-stacked = []
+chart-column = []
+chart-gantt = []
+chart-line = []
+chart-network = []
+chart-no-axes-column-decreasing = []
+chart-no-axes-column-increasing = []
+chart-no-axes-column = []
+chart-no-axes-combined = []
+chart-no-axes-gantt = []
+chart-pie = []
+chart-scatter = []
+chart-spline = []
+check-check = []
+check = []
+chef-hat = []
+cherry = []
+chevron-down = []
+chevron-first = []
+chevron-last = []
+chevron-left = []
+chevron-right = []
+chevron-up = []
+chevrons-down-up = []
+chevrons-down = []
+chevrons-left-right-ellipsis = []
+chevrons-left-right = []
+chevrons-left = []
+chevrons-right-left = []
+chevrons-right = []
+chevrons-up-down = []
+chevrons-up = []
+chrome = []
+church = []
+cigarette-off = []
+cigarette = []
+circle-alert = []
+circle-arrow-down = []
+circle-arrow-left = []
+circle-arrow-out-down-left = []
+circle-arrow-out-down-right = []
+circle-arrow-out-up-left = []
+circle-arrow-out-up-right = []
+circle-arrow-right = []
+circle-arrow-up = []
+circle-check-big = []
+circle-check = []
+circle-chevron-down = []
+circle-chevron-left = []
+circle-chevron-right = []
+circle-chevron-up = []
+circle-dashed = []
+circle-divide = []
+circle-dollar-sign = []
+circle-dot-dashed = []
+circle-dot = []
+circle-ellipsis = []
+circle-equal = []
+circle-fading-arrow-up = []
+circle-fading-plus = []
+circle-gauge = []
+circle-help = []
+circle-minus = []
+circle-off = []
+circle-parking-off = []
+circle-parking = []
+circle-pause = []
+circle-percent = []
+circle-play = []
+circle-plus = []
+circle-power = []
+circle-slash-2 = []
+circle-slash = []
+circle-stop = []
+circle-user-round = []
+circle-user = []
+circle-x = []
+circle = []
+circuit-board = []
+citrus = []
+clapperboard = []
+clipboard-check = []
+clipboard-copy = []
+clipboard-list = []
+clipboard-minus = []
+clipboard-paste = []
+clipboard-pen-line = []
+clipboard-pen = []
+clipboard-plus = []
+clipboard-type = []
+clipboard-x = []
+clipboard = []
+clock-1 = []
+clock-10 = []
+clock-11 = []
+clock-12 = []
+clock-2 = []
+clock-3 = []
+clock-4 = []
+clock-5 = []
+clock-6 = []
+clock-7 = []
+clock-8 = []
+clock-9 = []
+clock-alert = []
+clock-arrow-down = []
+clock-arrow-up = []
+clock = []
+cloud-alert = []
+cloud-cog = []
+cloud-download = []
+cloud-drizzle = []
+cloud-fog = []
+cloud-hail = []
+cloud-lightning = []
+cloud-moon-rain = []
+cloud-moon = []
+cloud-off = []
+cloud-rain-wind = []
+cloud-rain = []
+cloud-snow = []
+cloud-sun-rain = []
+cloud-sun = []
+cloud-upload = []
+cloud = []
+cloudy = []
+clover = []
+club = []
+code-xml = []
+code = []
+codepen = []
+codesandbox = []
+coffee = []
+cog = []
+coins = []
+columns-2 = []
+columns-3 = []
+columns-4 = []
+combine = []
+command = []
+compass = []
+component = []
+computer = []
+concierge-bell = []
+cone = []
+construction = []
+contact-round = []
+contact = []
+container = []
+contrast = []
+cookie = []
+cooking-pot = []
+copy-check = []
+copy-minus = []
+copy-plus = []
+copy-slash = []
+copy-x = []
+copy = []
+copyleft = []
+copyright = []
+corner-down-left = []
+corner-down-right = []
+corner-left-down = []
+corner-left-up = []
+corner-right-down = []
+corner-right-up = []
+corner-up-left = []
+corner-up-right = []
+cpu = []
+creative-commons = []
+credit-card = []
+croissant = []
+crop = []
+cross = []
+crosshair = []
+crown = []
+cuboid = []
+cup-soda = []
+currency = []
+cylinder = []
+dam = []
+database-backup = []
+database-zap = []
+database = []
+delete = []
+dessert = []
+diameter = []
+diamond-minus = []
+diamond-percent = []
+diamond-plus = []
+diamond = []
+dice-1 = []
+dice-2 = []
+dice-3 = []
+dice-4 = []
+dice-5 = []
+dice-6 = []
+dices = []
+diff = []
+disc-2 = []
+disc-3 = []
+disc-album = []
+disc = []
+divide = []
+dna-off = []
+dna = []
+dock = []
+dog = []
+dollar-sign = []
+donut = []
+door-closed = []
+door-open = []
+dot = []
+download = []
+drafting-compass = []
+drama = []
+dribbble = []
+drill = []
+droplet = []
+droplets = []
+drum = []
+drumstick = []
+dumbbell = []
+ear-off = []
+ear = []
+earth-lock = []
+earth = []
+eclipse = []
+egg-fried = []
+egg-off = []
+egg = []
+ellipsis-vertical = []
+ellipsis = []
+equal-approximately = []
+equal-not = []
+equal = []
+eraser = []
+ethernet-port = []
+euro = []
+expand = []
+external-link = []
+eye-closed = []
+eye-off = []
+eye = []
+facebook = []
+factory = []
+fan = []
+fast-forward = []
+feather = []
+fence = []
+ferris-wheel = []
+figma = []
+file-archive = []
+file-audio-2 = []
+file-audio = []
+file-axis-3-d = []
+file-badge-2 = []
+file-badge = []
+file-box = []
+file-chart-column-increasing = []
+file-chart-column = []
+file-chart-line = []
+file-chart-pie = []
+file-check-2 = []
+file-check = []
+file-clock = []
+file-code-2 = []
+file-code = []
+file-cog = []
+file-diff = []
+file-digit = []
+file-down = []
+file-heart = []
+file-image = []
+file-input = []
+file-json-2 = []
+file-json = []
+file-key-2 = []
+file-key = []
+file-lock-2 = []
+file-lock = []
+file-minus-2 = []
+file-minus = []
+file-music = []
+file-output = []
+file-pen-line = []
+file-pen = []
+file-plus-2 = []
+file-plus = []
+file-question = []
+file-scan = []
+file-search-2 = []
+file-search = []
+file-sliders = []
+file-spreadsheet = []
+file-stack = []
+file-symlink = []
+file-terminal = []
+file-text = []
+file-type-2 = []
+file-type = []
+file-up = []
+file-user = []
+file-video-2 = []
+file-video = []
+file-volume-2 = []
+file-volume = []
+file-warning = []
+file-x-2 = []
+file-x = []
+file = []
+files = []
+film = []
+filter-x = []
+filter = []
+fingerprint = []
+fire-extinguisher = []
+fish-off = []
+fish-symbol = []
+fish = []
+flag-off = []
+flag-triangle-left = []
+flag-triangle-right = []
+flag = []
+flame-kindling = []
+flame = []
+flashlight-off = []
+flashlight = []
+flask-conical-off = []
+flask-conical = []
+flask-round = []
+flip-horizontal-2 = []
+flip-horizontal = []
+flip-vertical-2 = []
+flip-vertical = []
+flower-2 = []
+flower = []
+focus = []
+fold-horizontal = []
+fold-vertical = []
+folder-archive = []
+folder-check = []
+folder-clock = []
+folder-closed = []
+folder-code = []
+folder-cog = []
+folder-dot = []
+folder-down = []
+folder-git-2 = []
+folder-git = []
+folder-heart = []
+folder-input = []
+folder-kanban = []
+folder-key = []
+folder-lock = []
+folder-minus = []
+folder-open-dot = []
+folder-open = []
+folder-output = []
+folder-pen = []
+folder-plus = []
+folder-root = []
+folder-search-2 = []
+folder-search = []
+folder-symlink = []
+folder-sync = []
+folder-tree = []
+folder-up = []
+folder-x = []
+folder = []
+folders = []
+footprints = []
+forklift = []
+forward = []
+frame = []
+framer = []
+frown = []
+fuel = []
+fullscreen = []
+gallery-horizontal-end = []
+gallery-horizontal = []
+gallery-thumbnails = []
+gallery-vertical-end = []
+gallery-vertical = []
+gamepad-2 = []
+gamepad = []
+gauge = []
+gavel = []
+gem = []
+ghost = []
+gift = []
+git-branch-plus = []
+git-branch = []
+git-commit-horizontal = []
+git-commit-vertical = []
+git-compare-arrows = []
+git-compare = []
+git-fork = []
+git-graph = []
+git-merge = []
+git-pull-request-arrow = []
+git-pull-request-closed = []
+git-pull-request-create-arrow = []
+git-pull-request-create = []
+git-pull-request-draft = []
+git-pull-request = []
+github = []
+gitlab = []
+glass-water = []
+glasses = []
+globe-lock = []
+globe = []
+goal = []
+grab = []
+graduation-cap = []
+grape = []
+grid-2-x-2-check = []
+grid-2-x-2-plus = []
+grid-2-x-2-x = []
+grid-2-x-2 = []
+grid-3-x-3 = []
+grip-horizontal = []
+grip-vertical = []
+grip = []
+group = []
+guitar = []
+ham = []
+hammer = []
+hand-coins = []
+hand-heart = []
+hand-helping = []
+hand-metal = []
+hand-platter = []
+hand = []
+handshake = []
+hard-drive-download = []
+hard-drive-upload = []
+hard-drive = []
+hard-hat = []
+hash = []
+haze = []
+hdmi-port = []
+heading-1 = []
+heading-2 = []
+heading-3 = []
+heading-4 = []
+heading-5 = []
+heading-6 = []
+heading = []
+headphone-off = []
+headphones = []
+headset = []
+heart-crack = []
+heart-handshake = []
+heart-off = []
+heart-pulse = []
+heart = []
+heater = []
+hexagon = []
+highlighter = []
+history = []
+hop-off = []
+hop = []
+hospital = []
+hotel = []
+hourglass = []
+house-plug = []
+house-plus = []
+house = []
+ice-cream-bowl = []
+ice-cream-cone = []
+id-card = []
+image-down = []
+image-minus = []
+image-off = []
+image-play = []
+image-plus = []
+image-up = []
+image = []
+images = []
+import = []
+inbox = []
+indent-decrease = []
+indent-increase = []
+indian-rupee = []
+infinity = []
+info = []
+inspection-panel = []
+instagram = []
+italic = []
+iteration-ccw = []
+iteration-cw = []
+japanese-yen = []
+joystick = []
+kanban = []
+key-round = []
+key-square = []
+key = []
+keyboard-music = []
+keyboard-off = []
+keyboard = []
+lamp-ceiling = []
+lamp-desk = []
+lamp-floor = []
+lamp-wall-down = []
+lamp-wall-up = []
+lamp = []
+land-plot = []
+landmark = []
+languages = []
+laptop-minimal-check = []
+laptop-minimal = []
+laptop = []
+lasso-select = []
+lasso = []
+laugh = []
+layers-2 = []
+layers-3 = []
+layers = []
+layout-dashboard = []
+layout-grid = []
+layout-list = []
+layout-panel-left = []
+layout-panel-top = []
+layout-template = []
+leaf = []
+leafy-green = []
+lectern = []
+letter-text = []
+library-big = []
+library = []
+life-buoy = []
+ligature = []
+lightbulb-off = []
+lightbulb = []
+link-2-off = []
+link-2 = []
+link = []
+linkedin = []
+list-check = []
+list-checks = []
+list-collapse = []
+list-end = []
+list-filter = []
+list-minus = []
+list-music = []
+list-ordered = []
+list-plus = []
+list-restart = []
+list-start = []
+list-todo = []
+list-tree = []
+list-video = []
+list-x = []
+list = []
+loader-circle = []
+loader-pinwheel = []
+loader = []
+locate-fixed = []
+locate-off = []
+locate = []
+lock-keyhole-open = []
+lock-keyhole = []
+lock-open = []
+lock = []
+log-in = []
+log-out = []
+logs = []
+lollipop = []
+luggage = []
+magnet = []
+mail-check = []
+mail-minus = []
+mail-open = []
+mail-plus = []
+mail-question = []
+mail-search = []
+mail-warning = []
+mail-x = []
+mail = []
+mailbox = []
+mails = []
+map-pin-check-inside = []
+map-pin-check = []
+map-pin-house = []
+map-pin-minus-inside = []
+map-pin-minus = []
+map-pin-off = []
+map-pin-plus-inside = []
+map-pin-plus = []
+map-pin-x-inside = []
+map-pin-x = []
+map-pin = []
+map-pinned = []
+map = []
+martini = []
+maximize-2 = []
+maximize = []
+medal = []
+megaphone-off = []
+megaphone = []
+meh = []
+memory-stick = []
+menu = []
+merge = []
+message-circle-code = []
+message-circle-dashed = []
+message-circle-heart = []
+message-circle-more = []
+message-circle-off = []
+message-circle-plus = []
+message-circle-question = []
+message-circle-reply = []
+message-circle-warning = []
+message-circle-x = []
+message-circle = []
+message-square-code = []
+message-square-dashed = []
+message-square-diff = []
+message-square-dot = []
+message-square-heart = []
+message-square-lock = []
+message-square-more = []
+message-square-off = []
+message-square-plus = []
+message-square-quote = []
+message-square-reply = []
+message-square-share = []
+message-square-text = []
+message-square-warning = []
+message-square-x = []
+message-square = []
+messages-square = []
+mic-off = []
+mic-vocal = []
+mic = []
+microchip = []
+microscope = []
+microwave = []
+milestone = []
+milk-off = []
+milk = []
+minimize-2 = []
+minimize = []
+minus = []
+monitor-check = []
+monitor-cog = []
+monitor-dot = []
+monitor-down = []
+monitor-off = []
+monitor-pause = []
+monitor-play = []
+monitor-smartphone = []
+monitor-speaker = []
+monitor-stop = []
+monitor-up = []
+monitor-x = []
+monitor = []
+moon-star = []
+moon = []
+mountain-snow = []
+mountain = []
+mouse-off = []
+mouse-pointer-2 = []
+mouse-pointer-ban = []
+mouse-pointer-click = []
+mouse-pointer = []
+mouse = []
+move-3-d = []
+move-diagonal-2 = []
+move-diagonal = []
+move-down-left = []
+move-down-right = []
+move-down = []
+move-horizontal = []
+move-left = []
+move-right = []
+move-up-left = []
+move-up-right = []
+move-up = []
+move-vertical = []
+move = []
+music-2 = []
+music-3 = []
+music-4 = []
+music = []
+navigation-2-off = []
+navigation-2 = []
+navigation-off = []
+navigation = []
+network = []
+newspaper = []
+nfc = []
+notebook-pen = []
+notebook-tabs = []
+notebook-text = []
+notebook = []
+notepad-text-dashed = []
+notepad-text = []
+nut-off = []
+nut = []
+octagon-alert = []
+octagon-minus = []
+octagon-pause = []
+octagon-x = []
+octagon = []
+omega = []
+option = []
+orbit = []
+origami = []
+package-2 = []
+package-check = []
+package-minus = []
+package-open = []
+package-plus = []
+package-search = []
+package-x = []
+package = []
+paint-bucket = []
+paint-roller = []
+paintbrush-vertical = []
+paintbrush = []
+palette = []
+panel-bottom-close = []
+panel-bottom-dashed = []
+panel-bottom-open = []
+panel-bottom = []
+panel-left-close = []
+panel-left-dashed = []
+panel-left-open = []
+panel-left = []
+panel-right-close = []
+panel-right-dashed = []
+panel-right-open = []
+panel-right = []
+panel-top-close = []
+panel-top-dashed = []
+panel-top-open = []
+panel-top = []
+panels-left-bottom = []
+panels-right-bottom = []
+panels-top-left = []
+paperclip = []
+parentheses = []
+parking-meter = []
+party-popper = []
+pause = []
+paw-print = []
+pc-case = []
+pen-line = []
+pen-off = []
+pen-tool = []
+pen = []
+pencil-line = []
+pencil-off = []
+pencil-ruler = []
+pencil = []
+pentagon = []
+percent = []
+person-standing = []
+philippine-peso = []
+phone-call = []
+phone-forwarded = []
+phone-incoming = []
+phone-missed = []
+phone-off = []
+phone-outgoing = []
+phone = []
+pi = []
+piano = []
+pickaxe = []
+picture-in-picture-2 = []
+picture-in-picture = []
+piggy-bank = []
+pilcrow-left = []
+pilcrow-right = []
+pilcrow = []
+pill-bottle = []
+pill = []
+pin-off = []
+pin = []
+pipette = []
+pizza = []
+plane-landing = []
+plane-takeoff = []
+plane = []
+play = []
+plug-2 = []
+plug-zap = []
+plug = []
+plus = []
+pocket-knife = []
+pocket = []
+podcast = []
+pointer-off = []
+pointer = []
+popcorn = []
+popsicle = []
+pound-sterling = []
+power-off = []
+power = []
+presentation = []
+printer-check = []
+printer = []
+projector = []
+proportions = []
+puzzle = []
+pyramid = []
+qr-code = []
+quote = []
+rabbit = []
+radar = []
+radiation = []
+radical = []
+radio-receiver = []
+radio-tower = []
+radio = []
+radius = []
+rail-symbol = []
+rainbow = []
+rat = []
+ratio = []
+receipt-cent = []
+receipt-euro = []
+receipt-indian-rupee = []
+receipt-japanese-yen = []
+receipt-pound-sterling = []
+receipt-russian-ruble = []
+receipt-swiss-franc = []
+receipt-text = []
+receipt = []
+rectangle-ellipsis = []
+rectangle-horizontal = []
+rectangle-vertical = []
+recycle = []
+redo-2 = []
+redo-dot = []
+redo = []
+refresh-ccw-dot = []
+refresh-ccw = []
+refresh-cw-off = []
+refresh-cw = []
+refrigerator = []
+regex = []
+remove-formatting = []
+repeat-1 = []
+repeat-2 = []
+repeat = []
+replace-all = []
+replace = []
+reply-all = []
+reply = []
+rewind = []
+ribbon = []
+rocket = []
+rocking-chair = []
+roller-coaster = []
+rotate-3-d = []
+rotate-ccw-square = []
+rotate-ccw = []
+rotate-cw-square = []
+rotate-cw = []
+route-off = []
+route = []
+router = []
+rows-2 = []
+rows-3 = []
+rows-4 = []
+rss = []
+ruler = []
+russian-ruble = []
+sailboat = []
+salad = []
+sandwich = []
+satellite-dish = []
+satellite = []
+save-all = []
+save-off = []
+save = []
+scale-3-d = []
+scale = []
+scaling = []
+scan-barcode = []
+scan-eye = []
+scan-face = []
+scan-line = []
+scan-qr-code = []
+scan-search = []
+scan-text = []
+scan = []
+school = []
+scissors-line-dashed = []
+scissors = []
+screen-share-off = []
+screen-share = []
+scroll-text = []
+scroll = []
+search-check = []
+search-code = []
+search-slash = []
+search-x = []
+search = []
+section = []
+send-horizontal = []
+send-to-back = []
+send = []
+separator-horizontal = []
+separator-vertical = []
+server-cog = []
+server-crash = []
+server-off = []
+server = []
+settings-2 = []
+settings = []
+shapes = []
+share-2 = []
+share = []
+sheet = []
+shell = []
+shield-alert = []
+shield-ban = []
+shield-check = []
+shield-ellipsis = []
+shield-half = []
+shield-minus = []
+shield-off = []
+shield-plus = []
+shield-question = []
+shield-x = []
+shield = []
+ship-wheel = []
+ship = []
+shirt = []
+shopping-bag = []
+shopping-basket = []
+shopping-cart = []
+shovel = []
+shower-head = []
+shrink = []
+shrub = []
+shuffle = []
+sigma = []
+signal-high = []
+signal-low = []
+signal-medium = []
+signal-zero = []
+signal = []
+signature = []
+signpost-big = []
+signpost = []
+siren = []
+skip-back = []
+skip-forward = []
+skull = []
+slack = []
+slash = []
+slice = []
+sliders-horizontal = []
+sliders-vertical = []
+smartphone-charging = []
+smartphone-nfc = []
+smartphone = []
+smile-plus = []
+smile = []
+snail = []
+snowflake = []
+sofa = []
+soup = []
+space = []
+spade = []
+sparkle = []
+sparkles = []
+speaker = []
+speech = []
+spell-check-2 = []
+spell-check = []
+spline = []
+split = []
+spray-can = []
+sprout = []
+square-activity = []
+square-arrow-down-left = []
+square-arrow-down-right = []
+square-arrow-down = []
+square-arrow-left = []
+square-arrow-out-down-left = []
+square-arrow-out-down-right = []
+square-arrow-out-up-left = []
+square-arrow-out-up-right = []
+square-arrow-right = []
+square-arrow-up-left = []
+square-arrow-up-right = []
+square-arrow-up = []
+square-asterisk = []
+square-bottom-dashed-scissors = []
+square-chart-gantt = []
+square-check-big = []
+square-check = []
+square-chevron-down = []
+square-chevron-left = []
+square-chevron-right = []
+square-chevron-up = []
+square-code = []
+square-dashed-bottom-code = []
+square-dashed-bottom = []
+square-dashed-kanban = []
+square-dashed-mouse-pointer = []
+square-dashed = []
+square-divide = []
+square-dot = []
+square-equal = []
+square-function = []
+square-kanban = []
+square-library = []
+square-m = []
+square-menu = []
+square-minus = []
+square-mouse-pointer = []
+square-parking-off = []
+square-parking = []
+square-pen = []
+square-percent = []
+square-pi = []
+square-pilcrow = []
+square-play = []
+square-plus = []
+square-power = []
+square-radical = []
+square-scissors = []
+square-sigma = []
+square-slash = []
+square-split-horizontal = []
+square-split-vertical = []
+square-square = []
+square-stack = []
+square-terminal = []
+square-user-round = []
+square-user = []
+square-x = []
+square = []
+squircle = []
+squirrel = []
+stamp = []
+star-half = []
+star-off = []
+star = []
+step-back = []
+step-forward = []
+stethoscope = []
+sticker = []
+sticky-note = []
+store = []
+stretch-horizontal = []
+stretch-vertical = []
+strikethrough = []
+subscript = []
+sun-dim = []
+sun-medium = []
+sun-moon = []
+sun-snow = []
+sun = []
+sunrise = []
+sunset = []
+superscript = []
+swatch-book = []
+swiss-franc = []
+switch-camera = []
+sword = []
+swords = []
+syringe = []
+table-2 = []
+table-cells-merge = []
+table-cells-split = []
+table-columns-split = []
+table-of-contents = []
+table-properties = []
+table-rows-split = []
+table = []
+tablet-smartphone = []
+tablet = []
+tablets = []
+tag = []
+tags = []
+tally-1 = []
+tally-2 = []
+tally-3 = []
+tally-4 = []
+tally-5 = []
+tangent = []
+target = []
+telescope = []
+tent-tree = []
+tent = []
+terminal = []
+test-tube-diagonal = []
+test-tube = []
+test-tubes = []
+text-cursor-input = []
+text-cursor = []
+text-quote = []
+text-search = []
+text-select = []
+text = []
+theater = []
+thermometer-snowflake = []
+thermometer-sun = []
+thermometer = []
+thumbs-down = []
+thumbs-up = []
+ticket-check = []
+ticket-minus = []
+ticket-percent = []
+ticket-plus = []
+ticket-slash = []
+ticket-x = []
+ticket = []
+tickets-plane = []
+tickets = []
+timer-off = []
+timer-reset = []
+timer = []
+toggle-left = []
+toggle-right = []
+toilet = []
+tornado = []
+torus = []
+touchpad-off = []
+touchpad = []
+tower-control = []
+toy-brick = []
+tractor = []
+traffic-cone = []
+train-front-tunnel = []
+train-front = []
+train-track = []
+tram-front = []
+trash-2 = []
+trash = []
+tree-deciduous = []
+tree-palm = []
+tree-pine = []
+trees = []
+trello = []
+trending-down = []
+trending-up-down = []
+trending-up = []
+triangle-alert = []
+triangle-right = []
+triangle = []
+trophy = []
+truck = []
+turtle = []
+tv-minimal-play = []
+tv-minimal = []
+tv = []
+twitch = []
+twitter = []
+type-outline = []
+type = []
+umbrella-off = []
+umbrella = []
+underline = []
+undo-2 = []
+undo-dot = []
+undo = []
+unfold-horizontal = []
+unfold-vertical = []
+ungroup = []
+university = []
+unlink-2 = []
+unlink = []
+unplug = []
+upload = []
+usb = []
+user-check = []
+user-cog = []
+user-minus = []
+user-pen = []
+user-plus = []
+user-round-check = []
+user-round-cog = []
+user-round-minus = []
+user-round-pen = []
+user-round-plus = []
+user-round-search = []
+user-round-x = []
+user-round = []
+user-search = []
+user-x = []
+user = []
+users-round = []
+users = []
+utensils-crossed = []
+utensils = []
+utility-pole = []
+variable = []
+vault = []
+vegan = []
+venetian-mask = []
+vibrate-off = []
+vibrate = []
+video-off = []
+video = []
+videotape = []
+view = []
+voicemail = []
+volleyball = []
+volume-1 = []
+volume-2 = []
+volume-off = []
+volume-x = []
+volume = []
+vote = []
+wallet-cards = []
+wallet-minimal = []
+wallet = []
+wallpaper = []
+wand-sparkles = []
+wand = []
+warehouse = []
+washing-machine = []
+watch = []
+waves = []
+waypoints = []
+webcam = []
+webhook-off = []
+webhook = []
+weight = []
+wheat-off = []
+wheat = []
+whole-word = []
+wifi-high = []
+wifi-low = []
+wifi-off = []
+wifi-zero = []
+wifi = []
+wind-arrow-down = []
+wind = []
+wine-off = []
+wine = []
+workflow = []
+worm = []
+wrap-text = []
+wrench = []
+x = []
+youtube = []
+zap-off = []
+zap = []
+zoom-in = []
+zoom-out = []
+full = [
+    "a-arrow-down",
+    "a-arrow-up",
+    "a-large-small",
+    "accessibility",
+    "activity",
+    "air-vent",
+    "airplay",
+    "alarm-clock-check",
+    "alarm-clock-minus",
+    "alarm-clock-off",
+    "alarm-clock-plus",
+    "alarm-clock",
+    "alarm-smoke",
+    "album",
+    "align-center-horizontal",
+    "align-center-vertical",
+    "align-center",
+    "align-end-horizontal",
+    "align-end-vertical",
+    "align-horizontal-distribute-center",
+    "align-horizontal-distribute-end",
+    "align-horizontal-distribute-start",
+    "align-horizontal-justify-center",
+    "align-horizontal-justify-end",
+    "align-horizontal-justify-start",
+    "align-horizontal-space-around",
+    "align-horizontal-space-between",
+    "align-justify",
+    "align-left",
+    "align-right",
+    "align-start-horizontal",
+    "align-start-vertical",
+    "align-vertical-distribute-center",
+    "align-vertical-distribute-end",
+    "align-vertical-distribute-start",
+    "align-vertical-justify-center",
+    "align-vertical-justify-end",
+    "align-vertical-justify-start",
+    "align-vertical-space-around",
+    "align-vertical-space-between",
+    "ambulance",
+    "ampersand",
+    "ampersands",
+    "amphora",
+    "anchor",
+    "angry",
+    "annoyed",
+    "antenna",
+    "anvil",
+    "aperture",
+    "app-window-mac",
+    "app-window",
+    "apple",
+    "archive-restore",
+    "archive-x",
+    "archive",
+    "armchair",
+    "arrow-big-down-dash",
+    "arrow-big-down",
+    "arrow-big-left-dash",
+    "arrow-big-left",
+    "arrow-big-right-dash",
+    "arrow-big-right",
+    "arrow-big-up-dash",
+    "arrow-big-up",
+    "arrow-down-0-1",
+    "arrow-down-1-0",
+    "arrow-down-a-z",
+    "arrow-down-from-line",
+    "arrow-down-left",
+    "arrow-down-narrow-wide",
+    "arrow-down-right",
+    "arrow-down-to-dot",
+    "arrow-down-to-line",
+    "arrow-down-up",
+    "arrow-down-wide-narrow",
+    "arrow-down-z-a",
+    "arrow-down",
+    "arrow-left-from-line",
+    "arrow-left-right",
+    "arrow-left-to-line",
+    "arrow-left",
+    "arrow-right-from-line",
+    "arrow-right-left",
+    "arrow-right-to-line",
+    "arrow-right",
+    "arrow-up-0-1",
+    "arrow-up-1-0",
+    "arrow-up-a-z",
+    "arrow-up-down",
+    "arrow-up-from-dot",
+    "arrow-up-from-line",
+    "arrow-up-left",
+    "arrow-up-narrow-wide",
+    "arrow-up-right",
+    "arrow-up-to-line",
+    "arrow-up-wide-narrow",
+    "arrow-up-z-a",
+    "arrow-up",
+    "arrows-up-from-line",
+    "asterisk",
+    "at-sign",
+    "atom",
+    "audio-lines",
+    "audio-waveform",
+    "award",
+    "axe",
+    "axis-3-d",
+    "baby",
+    "backpack",
+    "badge-alert",
+    "badge-cent",
+    "badge-check",
+    "badge-dollar-sign",
+    "badge-euro",
+    "badge-help",
+    "badge-indian-rupee",
+    "badge-info",
+    "badge-japanese-yen",
+    "badge-minus",
+    "badge-percent",
+    "badge-plus",
+    "badge-pound-sterling",
+    "badge-russian-ruble",
+    "badge-swiss-franc",
+    "badge-x",
+    "badge",
+    "baggage-claim",
+    "ban",
+    "banana",
+    "bandage",
+    "banknote",
+    "barcode",
+    "baseline",
+    "bath",
+    "battery-charging",
+    "battery-full",
+    "battery-low",
+    "battery-medium",
+    "battery-warning",
+    "battery",
+    "beaker",
+    "bean-off",
+    "bean",
+    "bed-double",
+    "bed-single",
+    "bed",
+    "beef",
+    "beer-off",
+    "beer",
+    "bell-dot",
+    "bell-electric",
+    "bell-minus",
+    "bell-off",
+    "bell-plus",
+    "bell-ring",
+    "bell",
+    "between-horizontal-end",
+    "between-horizontal-start",
+    "between-vertical-end",
+    "between-vertical-start",
+    "biceps-flexed",
+    "bike",
+    "binary",
+    "binoculars",
+    "biohazard",
+    "bird",
+    "bitcoin",
+    "blend",
+    "blinds",
+    "blocks",
+    "bluetooth-connected",
+    "bluetooth-off",
+    "bluetooth-searching",
+    "bluetooth",
+    "bold",
+    "bolt",
+    "bomb",
+    "bone",
+    "book-a",
+    "book-audio",
+    "book-check",
+    "book-copy",
+    "book-dashed",
+    "book-down",
+    "book-headphones",
+    "book-heart",
+    "book-image",
+    "book-key",
+    "book-lock",
+    "book-marked",
+    "book-minus",
+    "book-open-check",
+    "book-open-text",
+    "book-open",
+    "book-plus",
+    "book-text",
+    "book-type",
+    "book-up-2",
+    "book-up",
+    "book-user",
+    "book-x",
+    "book",
+    "bookmark-check",
+    "bookmark-minus",
+    "bookmark-plus",
+    "bookmark-x",
+    "bookmark",
+    "boom-box",
+    "bot-message-square",
+    "bot-off",
+    "bot",
+    "box",
+    "boxes",
+    "braces",
+    "brackets",
+    "brain-circuit",
+    "brain-cog",
+    "brain",
+    "brick-wall",
+    "briefcase-business",
+    "briefcase-conveyor-belt",
+    "briefcase-medical",
+    "briefcase",
+    "bring-to-front",
+    "brush",
+    "bug-off",
+    "bug-play",
+    "bug",
+    "building-2",
+    "building",
+    "bus-front",
+    "bus",
+    "cable-car",
+    "cable",
+    "cake-slice",
+    "cake",
+    "calculator",
+    "calendar-1",
+    "calendar-arrow-down",
+    "calendar-arrow-up",
+    "calendar-check-2",
+    "calendar-check",
+    "calendar-clock",
+    "calendar-cog",
+    "calendar-days",
+    "calendar-fold",
+    "calendar-heart",
+    "calendar-minus-2",
+    "calendar-minus",
+    "calendar-off",
+    "calendar-plus-2",
+    "calendar-plus",
+    "calendar-range",
+    "calendar-search",
+    "calendar-x-2",
+    "calendar-x",
+    "calendar",
+    "camera-off",
+    "camera",
+    "candy-cane",
+    "candy-off",
+    "candy",
+    "cannabis",
+    "captions-off",
+    "captions",
+    "car-front",
+    "car-taxi-front",
+    "car",
+    "caravan",
+    "carrot",
+    "case-lower",
+    "case-sensitive",
+    "case-upper",
+    "cassette-tape",
+    "cast",
+    "castle",
+    "cat",
+    "cctv",
+    "chart-area",
+    "chart-bar-big",
+    "chart-bar-decreasing",
+    "chart-bar-increasing",
+    "chart-bar-stacked",
+    "chart-bar",
+    "chart-candlestick",
+    "chart-column-big",
+    "chart-column-decreasing",
+    "chart-column-increasing",
+    "chart-column-stacked",
+    "chart-column",
+    "chart-gantt",
+    "chart-line",
+    "chart-network",
+    "chart-no-axes-column-decreasing",
+    "chart-no-axes-column-increasing",
+    "chart-no-axes-column",
+    "chart-no-axes-combined",
+    "chart-no-axes-gantt",
+    "chart-pie",
+    "chart-scatter",
+    "chart-spline",
+    "check-check",
+    "check",
+    "chef-hat",
+    "cherry",
+    "chevron-down",
+    "chevron-first",
+    "chevron-last",
+    "chevron-left",
+    "chevron-right",
+    "chevron-up",
+    "chevrons-down-up",
+    "chevrons-down",
+    "chevrons-left-right-ellipsis",
+    "chevrons-left-right",
+    "chevrons-left",
+    "chevrons-right-left",
+    "chevrons-right",
+    "chevrons-up-down",
+    "chevrons-up",
+    "chrome",
+    "church",
+    "cigarette-off",
+    "cigarette",
+    "circle-alert",
+    "circle-arrow-down",
+    "circle-arrow-left",
+    "circle-arrow-out-down-left",
+    "circle-arrow-out-down-right",
+    "circle-arrow-out-up-left",
+    "circle-arrow-out-up-right",
+    "circle-arrow-right",
+    "circle-arrow-up",
+    "circle-check-big",
+    "circle-check",
+    "circle-chevron-down",
+    "circle-chevron-left",
+    "circle-chevron-right",
+    "circle-chevron-up",
+    "circle-dashed",
+    "circle-divide",
+    "circle-dollar-sign",
+    "circle-dot-dashed",
+    "circle-dot",
+    "circle-ellipsis",
+    "circle-equal",
+    "circle-fading-arrow-up",
+    "circle-fading-plus",
+    "circle-gauge",
+    "circle-help",
+    "circle-minus",
+    "circle-off",
+    "circle-parking-off",
+    "circle-parking",
+    "circle-pause",
+    "circle-percent",
+    "circle-play",
+    "circle-plus",
+    "circle-power",
+    "circle-slash-2",
+    "circle-slash",
+    "circle-stop",
+    "circle-user-round",
+    "circle-user",
+    "circle-x",
+    "circle",
+    "circuit-board",
+    "citrus",
+    "clapperboard",
+    "clipboard-check",
+    "clipboard-copy",
+    "clipboard-list",
+    "clipboard-minus",
+    "clipboard-paste",
+    "clipboard-pen-line",
+    "clipboard-pen",
+    "clipboard-plus",
+    "clipboard-type",
+    "clipboard-x",
+    "clipboard",
+    "clock-1",
+    "clock-10",
+    "clock-11",
+    "clock-12",
+    "clock-2",
+    "clock-3",
+    "clock-4",
+    "clock-5",
+    "clock-6",
+    "clock-7",
+    "clock-8",
+    "clock-9",
+    "clock-alert",
+    "clock-arrow-down",
+    "clock-arrow-up",
+    "clock",
+    "cloud-alert",
+    "cloud-cog",
+    "cloud-download",
+    "cloud-drizzle",
+    "cloud-fog",
+    "cloud-hail",
+    "cloud-lightning",
+    "cloud-moon-rain",
+    "cloud-moon",
+    "cloud-off",
+    "cloud-rain-wind",
+    "cloud-rain",
+    "cloud-snow",
+    "cloud-sun-rain",
+    "cloud-sun",
+    "cloud-upload",
+    "cloud",
+    "cloudy",
+    "clover",
+    "club",
+    "code-xml",
+    "code",
+    "codepen",
+    "codesandbox",
+    "coffee",
+    "cog",
+    "coins",
+    "columns-2",
+    "columns-3",
+    "columns-4",
+    "combine",
+    "command",
+    "compass",
+    "component",
+    "computer",
+    "concierge-bell",
+    "cone",
+    "construction",
+    "contact-round",
+    "contact",
+    "container",
+    "contrast",
+    "cookie",
+    "cooking-pot",
+    "copy-check",
+    "copy-minus",
+    "copy-plus",
+    "copy-slash",
+    "copy-x",
+    "copy",
+    "copyleft",
+    "copyright",
+    "corner-down-left",
+    "corner-down-right",
+    "corner-left-down",
+    "corner-left-up",
+    "corner-right-down",
+    "corner-right-up",
+    "corner-up-left",
+    "corner-up-right",
+    "cpu",
+    "creative-commons",
+    "credit-card",
+    "croissant",
+    "crop",
+    "cross",
+    "crosshair",
+    "crown",
+    "cuboid",
+    "cup-soda",
+    "currency",
+    "cylinder",
+    "dam",
+    "database-backup",
+    "database-zap",
+    "database",
+    "delete",
+    "dessert",
+    "diameter",
+    "diamond-minus",
+    "diamond-percent",
+    "diamond-plus",
+    "diamond",
+    "dice-1",
+    "dice-2",
+    "dice-3",
+    "dice-4",
+    "dice-5",
+    "dice-6",
+    "dices",
+    "diff",
+    "disc-2",
+    "disc-3",
+    "disc-album",
+    "disc",
+    "divide",
+    "dna-off",
+    "dna",
+    "dock",
+    "dog",
+    "dollar-sign",
+    "donut",
+    "door-closed",
+    "door-open",
+    "dot",
+    "download",
+    "drafting-compass",
+    "drama",
+    "dribbble",
+    "drill",
+    "droplet",
+    "droplets",
+    "drum",
+    "drumstick",
+    "dumbbell",
+    "ear-off",
+    "ear",
+    "earth-lock",
+    "earth",
+    "eclipse",
+    "egg-fried",
+    "egg-off",
+    "egg",
+    "ellipsis-vertical",
+    "ellipsis",
+    "equal-approximately",
+    "equal-not",
+    "equal",
+    "eraser",
+    "ethernet-port",
+    "euro",
+    "expand",
+    "external-link",
+    "eye-closed",
+    "eye-off",
+    "eye",
+    "facebook",
+    "factory",
+    "fan",
+    "fast-forward",
+    "feather",
+    "fence",
+    "ferris-wheel",
+    "figma",
+    "file-archive",
+    "file-audio-2",
+    "file-audio",
+    "file-axis-3-d",
+    "file-badge-2",
+    "file-badge",
+    "file-box",
+    "file-chart-column-increasing",
+    "file-chart-column",
+    "file-chart-line",
+    "file-chart-pie",
+    "file-check-2",
+    "file-check",
+    "file-clock",
+    "file-code-2",
+    "file-code",
+    "file-cog",
+    "file-diff",
+    "file-digit",
+    "file-down",
+    "file-heart",
+    "file-image",
+    "file-input",
+    "file-json-2",
+    "file-json",
+    "file-key-2",
+    "file-key",
+    "file-lock-2",
+    "file-lock",
+    "file-minus-2",
+    "file-minus",
+    "file-music",
+    "file-output",
+    "file-pen-line",
+    "file-pen",
+    "file-plus-2",
+    "file-plus",
+    "file-question",
+    "file-scan",
+    "file-search-2",
+    "file-search",
+    "file-sliders",
+    "file-spreadsheet",
+    "file-stack",
+    "file-symlink",
+    "file-terminal",
+    "file-text",
+    "file-type-2",
+    "file-type",
+    "file-up",
+    "file-user",
+    "file-video-2",
+    "file-video",
+    "file-volume-2",
+    "file-volume",
+    "file-warning",
+    "file-x-2",
+    "file-x",
+    "file",
+    "files",
+    "film",
+    "filter-x",
+    "filter",
+    "fingerprint",
+    "fire-extinguisher",
+    "fish-off",
+    "fish-symbol",
+    "fish",
+    "flag-off",
+    "flag-triangle-left",
+    "flag-triangle-right",
+    "flag",
+    "flame-kindling",
+    "flame",
+    "flashlight-off",
+    "flashlight",
+    "flask-conical-off",
+    "flask-conical",
+    "flask-round",
+    "flip-horizontal-2",
+    "flip-horizontal",
+    "flip-vertical-2",
+    "flip-vertical",
+    "flower-2",
+    "flower",
+    "focus",
+    "fold-horizontal",
+    "fold-vertical",
+    "folder-archive",
+    "folder-check",
+    "folder-clock",
+    "folder-closed",
+    "folder-code",
+    "folder-cog",
+    "folder-dot",
+    "folder-down",
+    "folder-git-2",
+    "folder-git",
+    "folder-heart",
+    "folder-input",
+    "folder-kanban",
+    "folder-key",
+    "folder-lock",
+    "folder-minus",
+    "folder-open-dot",
+    "folder-open",
+    "folder-output",
+    "folder-pen",
+    "folder-plus",
+    "folder-root",
+    "folder-search-2",
+    "folder-search",
+    "folder-symlink",
+    "folder-sync",
+    "folder-tree",
+    "folder-up",
+    "folder-x",
+    "folder",
+    "folders",
+    "footprints",
+    "forklift",
+    "forward",
+    "frame",
+    "framer",
+    "frown",
+    "fuel",
+    "fullscreen",
+    "gallery-horizontal-end",
+    "gallery-horizontal",
+    "gallery-thumbnails",
+    "gallery-vertical-end",
+    "gallery-vertical",
+    "gamepad-2",
+    "gamepad",
+    "gauge",
+    "gavel",
+    "gem",
+    "ghost",
+    "gift",
+    "git-branch-plus",
+    "git-branch",
+    "git-commit-horizontal",
+    "git-commit-vertical",
+    "git-compare-arrows",
+    "git-compare",
+    "git-fork",
+    "git-graph",
+    "git-merge",
+    "git-pull-request-arrow",
+    "git-pull-request-closed",
+    "git-pull-request-create-arrow",
+    "git-pull-request-create",
+    "git-pull-request-draft",
+    "git-pull-request",
+    "github",
+    "gitlab",
+    "glass-water",
+    "glasses",
+    "globe-lock",
+    "globe",
+    "goal",
+    "grab",
+    "graduation-cap",
+    "grape",
+    "grid-2-x-2-check",
+    "grid-2-x-2-plus",
+    "grid-2-x-2-x",
+    "grid-2-x-2",
+    "grid-3-x-3",
+    "grip-horizontal",
+    "grip-vertical",
+    "grip",
+    "group",
+    "guitar",
+    "ham",
+    "hammer",
+    "hand-coins",
+    "hand-heart",
+    "hand-helping",
+    "hand-metal",
+    "hand-platter",
+    "hand",
+    "handshake",
+    "hard-drive-download",
+    "hard-drive-upload",
+    "hard-drive",
+    "hard-hat",
+    "hash",
+    "haze",
+    "hdmi-port",
+    "heading-1",
+    "heading-2",
+    "heading-3",
+    "heading-4",
+    "heading-5",
+    "heading-6",
+    "heading",
+    "headphone-off",
+    "headphones",
+    "headset",
+    "heart-crack",
+    "heart-handshake",
+    "heart-off",
+    "heart-pulse",
+    "heart",
+    "heater",
+    "hexagon",
+    "highlighter",
+    "history",
+    "hop-off",
+    "hop",
+    "hospital",
+    "hotel",
+    "hourglass",
+    "house-plug",
+    "house-plus",
+    "house",
+    "ice-cream-bowl",
+    "ice-cream-cone",
+    "id-card",
+    "image-down",
+    "image-minus",
+    "image-off",
+    "image-play",
+    "image-plus",
+    "image-up",
+    "image",
+    "images",
+    "import",
+    "inbox",
+    "indent-decrease",
+    "indent-increase",
+    "indian-rupee",
+    "infinity",
+    "info",
+    "inspection-panel",
+    "instagram",
+    "italic",
+    "iteration-ccw",
+    "iteration-cw",
+    "japanese-yen",
+    "joystick",
+    "kanban",
+    "key-round",
+    "key-square",
+    "key",
+    "keyboard-music",
+    "keyboard-off",
+    "keyboard",
+    "lamp-ceiling",
+    "lamp-desk",
+    "lamp-floor",
+    "lamp-wall-down",
+    "lamp-wall-up",
+    "lamp",
+    "land-plot",
+    "landmark",
+    "languages",
+    "laptop-minimal-check",
+    "laptop-minimal",
+    "laptop",
+    "lasso-select",
+    "lasso",
+    "laugh",
+    "layers-2",
+    "layers-3",
+    "layers",
+    "layout-dashboard",
+    "layout-grid",
+    "layout-list",
+    "layout-panel-left",
+    "layout-panel-top",
+    "layout-template",
+    "leaf",
+    "leafy-green",
+    "lectern",
+    "letter-text",
+    "library-big",
+    "library",
+    "life-buoy",
+    "ligature",
+    "lightbulb-off",
+    "lightbulb",
+    "link-2-off",
+    "link-2",
+    "link",
+    "linkedin",
+    "list-check",
+    "list-checks",
+    "list-collapse",
+    "list-end",
+    "list-filter",
+    "list-minus",
+    "list-music",
+    "list-ordered",
+    "list-plus",
+    "list-restart",
+    "list-start",
+    "list-todo",
+    "list-tree",
+    "list-video",
+    "list-x",
+    "list",
+    "loader-circle",
+    "loader-pinwheel",
+    "loader",
+    "locate-fixed",
+    "locate-off",
+    "locate",
+    "lock-keyhole-open",
+    "lock-keyhole",
+    "lock-open",
+    "lock",
+    "log-in",
+    "log-out",
+    "logs",
+    "lollipop",
+    "luggage",
+    "magnet",
+    "mail-check",
+    "mail-minus",
+    "mail-open",
+    "mail-plus",
+    "mail-question",
+    "mail-search",
+    "mail-warning",
+    "mail-x",
+    "mail",
+    "mailbox",
+    "mails",
+    "map-pin-check-inside",
+    "map-pin-check",
+    "map-pin-house",
+    "map-pin-minus-inside",
+    "map-pin-minus",
+    "map-pin-off",
+    "map-pin-plus-inside",
+    "map-pin-plus",
+    "map-pin-x-inside",
+    "map-pin-x",
+    "map-pin",
+    "map-pinned",
+    "map",
+    "martini",
+    "maximize-2",
+    "maximize",
+    "medal",
+    "megaphone-off",
+    "megaphone",
+    "meh",
+    "memory-stick",
+    "menu",
+    "merge",
+    "message-circle-code",
+    "message-circle-dashed",
+    "message-circle-heart",
+    "message-circle-more",
+    "message-circle-off",
+    "message-circle-plus",
+    "message-circle-question",
+    "message-circle-reply",
+    "message-circle-warning",
+    "message-circle-x",
+    "message-circle",
+    "message-square-code",
+    "message-square-dashed",
+    "message-square-diff",
+    "message-square-dot",
+    "message-square-heart",
+    "message-square-lock",
+    "message-square-more",
+    "message-square-off",
+    "message-square-plus",
+    "message-square-quote",
+    "message-square-reply",
+    "message-square-share",
+    "message-square-text",
+    "message-square-warning",
+    "message-square-x",
+    "message-square",
+    "messages-square",
+    "mic-off",
+    "mic-vocal",
+    "mic",
+    "microchip",
+    "microscope",
+    "microwave",
+    "milestone",
+    "milk-off",
+    "milk",
+    "minimize-2",
+    "minimize",
+    "minus",
+    "monitor-check",
+    "monitor-cog",
+    "monitor-dot",
+    "monitor-down",
+    "monitor-off",
+    "monitor-pause",
+    "monitor-play",
+    "monitor-smartphone",
+    "monitor-speaker",
+    "monitor-stop",
+    "monitor-up",
+    "monitor-x",
+    "monitor",
+    "moon-star",
+    "moon",
+    "mountain-snow",
+    "mountain",
+    "mouse-off",
+    "mouse-pointer-2",
+    "mouse-pointer-ban",
+    "mouse-pointer-click",
+    "mouse-pointer",
+    "mouse",
+    "move-3-d",
+    "move-diagonal-2",
+    "move-diagonal",
+    "move-down-left",
+    "move-down-right",
+    "move-down",
+    "move-horizontal",
+    "move-left",
+    "move-right",
+    "move-up-left",
+    "move-up-right",
+    "move-up",
+    "move-vertical",
+    "move",
+    "music-2",
+    "music-3",
+    "music-4",
+    "music",
+    "navigation-2-off",
+    "navigation-2",
+    "navigation-off",
+    "navigation",
+    "network",
+    "newspaper",
+    "nfc",
+    "notebook-pen",
+    "notebook-tabs",
+    "notebook-text",
+    "notebook",
+    "notepad-text-dashed",
+    "notepad-text",
+    "nut-off",
+    "nut",
+    "octagon-alert",
+    "octagon-minus",
+    "octagon-pause",
+    "octagon-x",
+    "octagon",
+    "omega",
+    "option",
+    "orbit",
+    "origami",
+    "package-2",
+    "package-check",
+    "package-minus",
+    "package-open",
+    "package-plus",
+    "package-search",
+    "package-x",
+    "package",
+    "paint-bucket",
+    "paint-roller",
+    "paintbrush-vertical",
+    "paintbrush",
+    "palette",
+    "panel-bottom-close",
+    "panel-bottom-dashed",
+    "panel-bottom-open",
+    "panel-bottom",
+    "panel-left-close",
+    "panel-left-dashed",
+    "panel-left-open",
+    "panel-left",
+    "panel-right-close",
+    "panel-right-dashed",
+    "panel-right-open",
+    "panel-right",
+    "panel-top-close",
+    "panel-top-dashed",
+    "panel-top-open",
+    "panel-top",
+    "panels-left-bottom",
+    "panels-right-bottom",
+    "panels-top-left",
+    "paperclip",
+    "parentheses",
+    "parking-meter",
+    "party-popper",
+    "pause",
+    "paw-print",
+    "pc-case",
+    "pen-line",
+    "pen-off",
+    "pen-tool",
+    "pen",
+    "pencil-line",
+    "pencil-off",
+    "pencil-ruler",
+    "pencil",
+    "pentagon",
+    "percent",
+    "person-standing",
+    "philippine-peso",
+    "phone-call",
+    "phone-forwarded",
+    "phone-incoming",
+    "phone-missed",
+    "phone-off",
+    "phone-outgoing",
+    "phone",
+    "pi",
+    "piano",
+    "pickaxe",
+    "picture-in-picture-2",
+    "picture-in-picture",
+    "piggy-bank",
+    "pilcrow-left",
+    "pilcrow-right",
+    "pilcrow",
+    "pill-bottle",
+    "pill",
+    "pin-off",
+    "pin",
+    "pipette",
+    "pizza",
+    "plane-landing",
+    "plane-takeoff",
+    "plane",
+    "play",
+    "plug-2",
+    "plug-zap",
+    "plug",
+    "plus",
+    "pocket-knife",
+    "pocket",
+    "podcast",
+    "pointer-off",
+    "pointer",
+    "popcorn",
+    "popsicle",
+    "pound-sterling",
+    "power-off",
+    "power",
+    "presentation",
+    "printer-check",
+    "printer",
+    "projector",
+    "proportions",
+    "puzzle",
+    "pyramid",
+    "qr-code",
+    "quote",
+    "rabbit",
+    "radar",
+    "radiation",
+    "radical",
+    "radio-receiver",
+    "radio-tower",
+    "radio",
+    "radius",
+    "rail-symbol",
+    "rainbow",
+    "rat",
+    "ratio",
+    "receipt-cent",
+    "receipt-euro",
+    "receipt-indian-rupee",
+    "receipt-japanese-yen",
+    "receipt-pound-sterling",
+    "receipt-russian-ruble",
+    "receipt-swiss-franc",
+    "receipt-text",
+    "receipt",
+    "rectangle-ellipsis",
+    "rectangle-horizontal",
+    "rectangle-vertical",
+    "recycle",
+    "redo-2",
+    "redo-dot",
+    "redo",
+    "refresh-ccw-dot",
+    "refresh-ccw",
+    "refresh-cw-off",
+    "refresh-cw",
+    "refrigerator",
+    "regex",
+    "remove-formatting",
+    "repeat-1",
+    "repeat-2",
+    "repeat",
+    "replace-all",
+    "replace",
+    "reply-all",
+    "reply",
+    "rewind",
+    "ribbon",
+    "rocket",
+    "rocking-chair",
+    "roller-coaster",
+    "rotate-3-d",
+    "rotate-ccw-square",
+    "rotate-ccw",
+    "rotate-cw-square",
+    "rotate-cw",
+    "route-off",
+    "route",
+    "router",
+    "rows-2",
+    "rows-3",
+    "rows-4",
+    "rss",
+    "ruler",
+    "russian-ruble",
+    "sailboat",
+    "salad",
+    "sandwich",
+    "satellite-dish",
+    "satellite",
+    "save-all",
+    "save-off",
+    "save",
+    "scale-3-d",
+    "scale",
+    "scaling",
+    "scan-barcode",
+    "scan-eye",
+    "scan-face",
+    "scan-line",
+    "scan-qr-code",
+    "scan-search",
+    "scan-text",
+    "scan",
+    "school",
+    "scissors-line-dashed",
+    "scissors",
+    "screen-share-off",
+    "screen-share",
+    "scroll-text",
+    "scroll",
+    "search-check",
+    "search-code",
+    "search-slash",
+    "search-x",
+    "search",
+    "section",
+    "send-horizontal",
+    "send-to-back",
+    "send",
+    "separator-horizontal",
+    "separator-vertical",
+    "server-cog",
+    "server-crash",
+    "server-off",
+    "server",
+    "settings-2",
+    "settings",
+    "shapes",
+    "share-2",
+    "share",
+    "sheet",
+    "shell",
+    "shield-alert",
+    "shield-ban",
+    "shield-check",
+    "shield-ellipsis",
+    "shield-half",
+    "shield-minus",
+    "shield-off",
+    "shield-plus",
+    "shield-question",
+    "shield-x",
+    "shield",
+    "ship-wheel",
+    "ship",
+    "shirt",
+    "shopping-bag",
+    "shopping-basket",
+    "shopping-cart",
+    "shovel",
+    "shower-head",
+    "shrink",
+    "shrub",
+    "shuffle",
+    "sigma",
+    "signal-high",
+    "signal-low",
+    "signal-medium",
+    "signal-zero",
+    "signal",
+    "signature",
+    "signpost-big",
+    "signpost",
+    "siren",
+    "skip-back",
+    "skip-forward",
+    "skull",
+    "slack",
+    "slash",
+    "slice",
+    "sliders-horizontal",
+    "sliders-vertical",
+    "smartphone-charging",
+    "smartphone-nfc",
+    "smartphone",
+    "smile-plus",
+    "smile",
+    "snail",
+    "snowflake",
+    "sofa",
+    "soup",
+    "space",
+    "spade",
+    "sparkle",
+    "sparkles",
+    "speaker",
+    "speech",
+    "spell-check-2",
+    "spell-check",
+    "spline",
+    "split",
+    "spray-can",
+    "sprout",
+    "square-activity",
+    "square-arrow-down-left",
+    "square-arrow-down-right",
+    "square-arrow-down",
+    "square-arrow-left",
+    "square-arrow-out-down-left",
+    "square-arrow-out-down-right",
+    "square-arrow-out-up-left",
+    "square-arrow-out-up-right",
+    "square-arrow-right",
+    "square-arrow-up-left",
+    "square-arrow-up-right",
+    "square-arrow-up",
+    "square-asterisk",
+    "square-bottom-dashed-scissors",
+    "square-chart-gantt",
+    "square-check-big",
+    "square-check",
+    "square-chevron-down",
+    "square-chevron-left",
+    "square-chevron-right",
+    "square-chevron-up",
+    "square-code",
+    "square-dashed-bottom-code",
+    "square-dashed-bottom",
+    "square-dashed-kanban",
+    "square-dashed-mouse-pointer",
+    "square-dashed",
+    "square-divide",
+    "square-dot",
+    "square-equal",
+    "square-function",
+    "square-kanban",
+    "square-library",
+    "square-m",
+    "square-menu",
+    "square-minus",
+    "square-mouse-pointer",
+    "square-parking-off",
+    "square-parking",
+    "square-pen",
+    "square-percent",
+    "square-pi",
+    "square-pilcrow",
+    "square-play",
+    "square-plus",
+    "square-power",
+    "square-radical",
+    "square-scissors",
+    "square-sigma",
+    "square-slash",
+    "square-split-horizontal",
+    "square-split-vertical",
+    "square-square",
+    "square-stack",
+    "square-terminal",
+    "square-user-round",
+    "square-user",
+    "square-x",
+    "square",
+    "squircle",
+    "squirrel",
+    "stamp",
+    "star-half",
+    "star-off",
+    "star",
+    "step-back",
+    "step-forward",
+    "stethoscope",
+    "sticker",
+    "sticky-note",
+    "store",
+    "stretch-horizontal",
+    "stretch-vertical",
+    "strikethrough",
+    "subscript",
+    "sun-dim",
+    "sun-medium",
+    "sun-moon",
+    "sun-snow",
+    "sun",
+    "sunrise",
+    "sunset",
+    "superscript",
+    "swatch-book",
+    "swiss-franc",
+    "switch-camera",
+    "sword",
+    "swords",
+    "syringe",
+    "table-2",
+    "table-cells-merge",
+    "table-cells-split",
+    "table-columns-split",
+    "table-of-contents",
+    "table-properties",
+    "table-rows-split",
+    "table",
+    "tablet-smartphone",
+    "tablet",
+    "tablets",
+    "tag",
+    "tags",
+    "tally-1",
+    "tally-2",
+    "tally-3",
+    "tally-4",
+    "tally-5",
+    "tangent",
+    "target",
+    "telescope",
+    "tent-tree",
+    "tent",
+    "terminal",
+    "test-tube-diagonal",
+    "test-tube",
+    "test-tubes",
+    "text-cursor-input",
+    "text-cursor",
+    "text-quote",
+    "text-search",
+    "text-select",
+    "text",
+    "theater",
+    "thermometer-snowflake",
+    "thermometer-sun",
+    "thermometer",
+    "thumbs-down",
+    "thumbs-up",
+    "ticket-check",
+    "ticket-minus",
+    "ticket-percent",
+    "ticket-plus",
+    "ticket-slash",
+    "ticket-x",
+    "ticket",
+    "tickets-plane",
+    "tickets",
+    "timer-off",
+    "timer-reset",
+    "timer",
+    "toggle-left",
+    "toggle-right",
+    "toilet",
+    "tornado",
+    "torus",
+    "touchpad-off",
+    "touchpad",
+    "tower-control",
+    "toy-brick",
+    "tractor",
+    "traffic-cone",
+    "train-front-tunnel",
+    "train-front",
+    "train-track",
+    "tram-front",
+    "trash-2",
+    "trash",
+    "tree-deciduous",
+    "tree-palm",
+    "tree-pine",
+    "trees",
+    "trello",
+    "trending-down",
+    "trending-up-down",
+    "trending-up",
+    "triangle-alert",
+    "triangle-right",
+    "triangle",
+    "trophy",
+    "truck",
+    "turtle",
+    "tv-minimal-play",
+    "tv-minimal",
+    "tv",
+    "twitch",
+    "twitter",
+    "type-outline",
+    "type",
+    "umbrella-off",
+    "umbrella",
+    "underline",
+    "undo-2",
+    "undo-dot",
+    "undo",
+    "unfold-horizontal",
+    "unfold-vertical",
+    "ungroup",
+    "university",
+    "unlink-2",
+    "unlink",
+    "unplug",
+    "upload",
+    "usb",
+    "user-check",
+    "user-cog",
+    "user-minus",
+    "user-pen",
+    "user-plus",
+    "user-round-check",
+    "user-round-cog",
+    "user-round-minus",
+    "user-round-pen",
+    "user-round-plus",
+    "user-round-search",
+    "user-round-x",
+    "user-round",
+    "user-search",
+    "user-x",
+    "user",
+    "users-round",
+    "users",
+    "utensils-crossed",
+    "utensils",
+    "utility-pole",
+    "variable",
+    "vault",
+    "vegan",
+    "venetian-mask",
+    "vibrate-off",
+    "vibrate",
+    "video-off",
+    "video",
+    "videotape",
+    "view",
+    "voicemail",
+    "volleyball",
+    "volume-1",
+    "volume-2",
+    "volume-off",
+    "volume-x",
+    "volume",
+    "vote",
+    "wallet-cards",
+    "wallet-minimal",
+    "wallet",
+    "wallpaper",
+    "wand-sparkles",
+    "wand",
+    "warehouse",
+    "washing-machine",
+    "watch",
+    "waves",
+    "waypoints",
+    "webcam",
+    "webhook-off",
+    "webhook",
+    "weight",
+    "wheat-off",
+    "wheat",
+    "whole-word",
+    "wifi-high",
+    "wifi-low",
+    "wifi-off",
+    "wifi-zero",
+    "wifi",
+    "wind-arrow-down",
+    "wind",
+    "wine-off",
+    "wine",
+    "workflow",
+    "worm",
+    "wrap-text",
+    "wrench",
+    "x",
+    "youtube",
+    "zap-off",
+    "zap",
+    "zoom-in",
+    "zoom-out",
+]
diff --git a/packages/yew/src/a_arrow_down.rs b/packages/yew/src/a_arrow_down.rs
new file mode 100644
index 0000000..c601ad3
--- /dev/null
+++ b/packages/yew/src/a_arrow_down.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AArrowDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AArrowDown(props: &AArrowDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.5 13h6" />
+            <path d="m2 16 4.5-9 4.5 9" />
+            <path d="M18 7v9" />
+            <path d="m14 12 4 4 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/a_arrow_up.rs b/packages/yew/src/a_arrow_up.rs
new file mode 100644
index 0000000..2269768
--- /dev/null
+++ b/packages/yew/src/a_arrow_up.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AArrowUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AArrowUp(props: &AArrowUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.5 13h6" />
+            <path d="m2 16 4.5-9 4.5 9" />
+            <path d="M18 16V7" />
+            <path d="m14 11 4-4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/a_large_small.rs b/packages/yew/src/a_large_small.rs
new file mode 100644
index 0000000..cfdbfa6
--- /dev/null
+++ b/packages/yew/src/a_large_small.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ALargeSmallProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ALargeSmall(props: &ALargeSmallProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 14h-5" />
+            <path d="M16 16v-3.5a2.5 2.5 0 0 1 5 0V16" />
+            <path d="M4.5 13h6" />
+            <path d="m3 16 4.5-9 4.5 9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/accessibility.rs b/packages/yew/src/accessibility.rs
new file mode 100644
index 0000000..226a125
--- /dev/null
+++ b/packages/yew/src/accessibility.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AccessibilityProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Accessibility(props: &AccessibilityProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="16" cy="4" r="1" />
+            <path d="m18 19 1-7-6 1" />
+            <path d="m5 8 3-3 5.5 3-2.36 3.5" />
+            <path d="M4.24 14.5a5 5 0 0 0 6.88 6" />
+            <path d="M13.76 17.5a5 5 0 0 0-6.88-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/activity.rs b/packages/yew/src/activity.rs
new file mode 100644
index 0000000..cfe7578
--- /dev/null
+++ b/packages/yew/src/activity.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ActivityProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Activity(props: &ActivityProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M22 12h-2.48a2 2 0 0 0-1.93 1.46l-2.35 8.36a.25.25 0 0 1-.48 0L9.24 2.18a.25.25 0 0 0-.48 0l-2.35 8.36A2 2 0 0 1 4.49 12H2"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/air_vent.rs b/packages/yew/src/air_vent.rs
new file mode 100644
index 0000000..e0eb841
--- /dev/null
+++ b/packages/yew/src/air_vent.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AirVentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AirVent(props: &AirVentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 12H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2" />
+            <path d="M6 8h12" />
+            <path d="M18.3 17.7a2.5 2.5 0 0 1-3.16 3.83 2.53 2.53 0 0 1-1.14-2V12" />
+            <path d="M6.6 15.6A2 2 0 1 0 10 17v-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/airplay.rs b/packages/yew/src/airplay.rs
new file mode 100644
index 0000000..74f1147
--- /dev/null
+++ b/packages/yew/src/airplay.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AirplayProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Airplay(props: &AirplayProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1" />
+            <path d="m12 15 5 6H7Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/alarm_clock.rs b/packages/yew/src/alarm_clock.rs
new file mode 100644
index 0000000..d47ccf2
--- /dev/null
+++ b/packages/yew/src/alarm_clock.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlarmClockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlarmClock(props: &AlarmClockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="8" />
+            <path d="M12 9v4l2 2" />
+            <path d="M5 3 2 6" />
+            <path d="m22 6-3-3" />
+            <path d="M6.38 18.7 4 21" />
+            <path d="M17.64 18.67 20 21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/alarm_clock_check.rs b/packages/yew/src/alarm_clock_check.rs
new file mode 100644
index 0000000..99cd552
--- /dev/null
+++ b/packages/yew/src/alarm_clock_check.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlarmClockCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlarmClockCheck(props: &AlarmClockCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="8" />
+            <path d="M5 3 2 6" />
+            <path d="m22 6-3-3" />
+            <path d="M6.38 18.7 4 21" />
+            <path d="M17.64 18.67 20 21" />
+            <path d="m9 13 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/alarm_clock_minus.rs b/packages/yew/src/alarm_clock_minus.rs
new file mode 100644
index 0000000..d8321d5
--- /dev/null
+++ b/packages/yew/src/alarm_clock_minus.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlarmClockMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlarmClockMinus(props: &AlarmClockMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="8" />
+            <path d="M5 3 2 6" />
+            <path d="m22 6-3-3" />
+            <path d="M6.38 18.7 4 21" />
+            <path d="M17.64 18.67 20 21" />
+            <path d="M9 13h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/alarm_clock_off.rs b/packages/yew/src/alarm_clock_off.rs
new file mode 100644
index 0000000..a4b0541
--- /dev/null
+++ b/packages/yew/src/alarm_clock_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlarmClockOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlarmClockOff(props: &AlarmClockOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6.87 6.87a8 8 0 1 0 11.26 11.26" />
+            <path d="M19.9 14.25a8 8 0 0 0-9.15-9.15" />
+            <path d="m22 6-3-3" />
+            <path d="M6.26 18.67 4 21" />
+            <path d="m2 2 20 20" />
+            <path d="M4 4 2 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/alarm_clock_plus.rs b/packages/yew/src/alarm_clock_plus.rs
new file mode 100644
index 0000000..0dca45d
--- /dev/null
+++ b/packages/yew/src/alarm_clock_plus.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlarmClockPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlarmClockPlus(props: &AlarmClockPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="8" />
+            <path d="M5 3 2 6" />
+            <path d="m22 6-3-3" />
+            <path d="M6.38 18.7 4 21" />
+            <path d="M17.64 18.67 20 21" />
+            <path d="M12 10v6" />
+            <path d="M9 13h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/alarm_smoke.rs b/packages/yew/src/alarm_smoke.rs
new file mode 100644
index 0000000..055a3b5
--- /dev/null
+++ b/packages/yew/src/alarm_smoke.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlarmSmokeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlarmSmoke(props: &AlarmSmokeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 21c0-2.5 2-2.5 2-5" />
+            <path d="M16 21c0-2.5 2-2.5 2-5" />
+            <path d="m19 8-.8 3a1.25 1.25 0 0 1-1.2 1H7a1.25 1.25 0 0 1-1.2-1L5 8" />
+            <path d="M21 3a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V4a1 1 0 0 1 1-1z" />
+            <path d="M6 21c0-2.5 2-2.5 2-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/album.rs b/packages/yew/src/album.rs
new file mode 100644
index 0000000..ed0b774
--- /dev/null
+++ b/packages/yew/src/album.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlbumProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Album(props: &AlbumProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <polyline points="11 3 11 11 14 8 17 11 17 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_center.rs b/packages/yew/src/align_center.rs
new file mode 100644
index 0000000..3c0d1f4
--- /dev/null
+++ b/packages/yew/src/align_center.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignCenterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignCenter(props: &AlignCenterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 12H7" />
+            <path d="M19 18H5" />
+            <path d="M21 6H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_center_horizontal.rs b/packages/yew/src/align_center_horizontal.rs
new file mode 100644
index 0000000..2f7ae2d
--- /dev/null
+++ b/packages/yew/src/align_center_horizontal.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignCenterHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignCenterHorizontal(props: &AlignCenterHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12h20" />
+            <path d="M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4" />
+            <path d="M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4" />
+            <path d="M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1" />
+            <path d="M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_center_vertical.rs b/packages/yew/src/align_center_vertical.rs
new file mode 100644
index 0000000..b0b7012
--- /dev/null
+++ b/packages/yew/src/align_center_vertical.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignCenterVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignCenterVertical(props: &AlignCenterVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v20" />
+            <path d="M8 10H4a2 2 0 0 1-2-2V6c0-1.1.9-2 2-2h4" />
+            <path d="M16 10h4a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-4" />
+            <path d="M8 20H7a2 2 0 0 1-2-2v-2c0-1.1.9-2 2-2h1" />
+            <path d="M16 14h1a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2h-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_end_horizontal.rs b/packages/yew/src/align_end_horizontal.rs
new file mode 100644
index 0000000..791a602
--- /dev/null
+++ b/packages/yew/src/align_end_horizontal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignEndHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignEndHorizontal(props: &AlignEndHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="16" x="4" y="2" rx="2" />
+            <rect width="6" height="9" x="14" y="9" rx="2" />
+            <path d="M22 22H2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_end_vertical.rs b/packages/yew/src/align_end_vertical.rs
new file mode 100644
index 0000000..ef42f48
--- /dev/null
+++ b/packages/yew/src/align_end_vertical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignEndVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignEndVertical(props: &AlignEndVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="6" x="2" y="4" rx="2" />
+            <rect width="9" height="6" x="9" y="14" rx="2" />
+            <path d="M22 22V2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_horizontal_distribute_center.rs b/packages/yew/src/align_horizontal_distribute_center.rs
new file mode 100644
index 0000000..d8f6099
--- /dev/null
+++ b/packages/yew/src/align_horizontal_distribute_center.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignHorizontalDistributeCenterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignHorizontalDistributeCenter(props: &AlignHorizontalDistributeCenterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="4" y="5" rx="2" />
+            <rect width="6" height="10" x="14" y="7" rx="2" />
+            <path d="M17 22v-5" />
+            <path d="M17 7V2" />
+            <path d="M7 22v-3" />
+            <path d="M7 5V2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_horizontal_distribute_end.rs b/packages/yew/src/align_horizontal_distribute_end.rs
new file mode 100644
index 0000000..8e858f6
--- /dev/null
+++ b/packages/yew/src/align_horizontal_distribute_end.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignHorizontalDistributeEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignHorizontalDistributeEnd(props: &AlignHorizontalDistributeEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="4" y="5" rx="2" />
+            <rect width="6" height="10" x="14" y="7" rx="2" />
+            <path d="M10 2v20" />
+            <path d="M20 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_horizontal_distribute_start.rs b/packages/yew/src/align_horizontal_distribute_start.rs
new file mode 100644
index 0000000..038553a
--- /dev/null
+++ b/packages/yew/src/align_horizontal_distribute_start.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignHorizontalDistributeStartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignHorizontalDistributeStart(props: &AlignHorizontalDistributeStartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="4" y="5" rx="2" />
+            <rect width="6" height="10" x="14" y="7" rx="2" />
+            <path d="M4 2v20" />
+            <path d="M14 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_horizontal_justify_center.rs b/packages/yew/src/align_horizontal_justify_center.rs
new file mode 100644
index 0000000..16da425
--- /dev/null
+++ b/packages/yew/src/align_horizontal_justify_center.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignHorizontalJustifyCenterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignHorizontalJustifyCenter(props: &AlignHorizontalJustifyCenterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="2" y="5" rx="2" />
+            <rect width="6" height="10" x="16" y="7" rx="2" />
+            <path d="M12 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_horizontal_justify_end.rs b/packages/yew/src/align_horizontal_justify_end.rs
new file mode 100644
index 0000000..a4e42e1
--- /dev/null
+++ b/packages/yew/src/align_horizontal_justify_end.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignHorizontalJustifyEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignHorizontalJustifyEnd(props: &AlignHorizontalJustifyEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="2" y="5" rx="2" />
+            <rect width="6" height="10" x="12" y="7" rx="2" />
+            <path d="M22 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_horizontal_justify_start.rs b/packages/yew/src/align_horizontal_justify_start.rs
new file mode 100644
index 0000000..8fc07a2
--- /dev/null
+++ b/packages/yew/src/align_horizontal_justify_start.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignHorizontalJustifyStartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignHorizontalJustifyStart(props: &AlignHorizontalJustifyStartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="6" y="5" rx="2" />
+            <rect width="6" height="10" x="16" y="7" rx="2" />
+            <path d="M2 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_horizontal_space_around.rs b/packages/yew/src/align_horizontal_space_around.rs
new file mode 100644
index 0000000..c36beff
--- /dev/null
+++ b/packages/yew/src/align_horizontal_space_around.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignHorizontalSpaceAroundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignHorizontalSpaceAround(props: &AlignHorizontalSpaceAroundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="10" x="9" y="7" rx="2" />
+            <path d="M4 22V2" />
+            <path d="M20 22V2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_horizontal_space_between.rs b/packages/yew/src/align_horizontal_space_between.rs
new file mode 100644
index 0000000..3ef6f4e
--- /dev/null
+++ b/packages/yew/src/align_horizontal_space_between.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignHorizontalSpaceBetweenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignHorizontalSpaceBetween(props: &AlignHorizontalSpaceBetweenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="14" x="3" y="5" rx="2" />
+            <rect width="6" height="10" x="15" y="7" rx="2" />
+            <path d="M3 2v20" />
+            <path d="M21 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_justify.rs b/packages/yew/src/align_justify.rs
new file mode 100644
index 0000000..c72df99
--- /dev/null
+++ b/packages/yew/src/align_justify.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignJustifyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignJustify(props: &AlignJustifyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12h18" />
+            <path d="M3 18h18" />
+            <path d="M3 6h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_left.rs b/packages/yew/src/align_left.rs
new file mode 100644
index 0000000..3f4aa74
--- /dev/null
+++ b/packages/yew/src/align_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignLeft(props: &AlignLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 12H3" />
+            <path d="M17 18H3" />
+            <path d="M21 6H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_right.rs b/packages/yew/src/align_right.rs
new file mode 100644
index 0000000..ac4a4d2
--- /dev/null
+++ b/packages/yew/src/align_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignRight(props: &AlignRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12H9" />
+            <path d="M21 18H7" />
+            <path d="M21 6H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_start_horizontal.rs b/packages/yew/src/align_start_horizontal.rs
new file mode 100644
index 0000000..a284b83
--- /dev/null
+++ b/packages/yew/src/align_start_horizontal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignStartHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignStartHorizontal(props: &AlignStartHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="16" x="4" y="6" rx="2" />
+            <rect width="6" height="9" x="14" y="6" rx="2" />
+            <path d="M22 2H2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_start_vertical.rs b/packages/yew/src/align_start_vertical.rs
new file mode 100644
index 0000000..590c1f7
--- /dev/null
+++ b/packages/yew/src/align_start_vertical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignStartVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignStartVertical(props: &AlignStartVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="9" height="6" x="6" y="14" rx="2" />
+            <rect width="16" height="6" x="6" y="4" rx="2" />
+            <path d="M2 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_vertical_distribute_center.rs b/packages/yew/src/align_vertical_distribute_center.rs
new file mode 100644
index 0000000..2cec4ff
--- /dev/null
+++ b/packages/yew/src/align_vertical_distribute_center.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignVerticalDistributeCenterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignVerticalDistributeCenter(props: &AlignVerticalDistributeCenterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 17h-3" />
+            <path d="M22 7h-5" />
+            <path d="M5 17H2" />
+            <path d="M7 7H2" />
+            <rect x="5" y="14" width="14" height="6" rx="2" />
+            <rect x="7" y="4" width="10" height="6" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_vertical_distribute_end.rs b/packages/yew/src/align_vertical_distribute_end.rs
new file mode 100644
index 0000000..abe8764
--- /dev/null
+++ b/packages/yew/src/align_vertical_distribute_end.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignVerticalDistributeEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignVerticalDistributeEnd(props: &AlignVerticalDistributeEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="14" rx="2" />
+            <rect width="10" height="6" x="7" y="4" rx="2" />
+            <path d="M2 20h20" />
+            <path d="M2 10h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_vertical_distribute_start.rs b/packages/yew/src/align_vertical_distribute_start.rs
new file mode 100644
index 0000000..cc113a7
--- /dev/null
+++ b/packages/yew/src/align_vertical_distribute_start.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignVerticalDistributeStartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignVerticalDistributeStart(props: &AlignVerticalDistributeStartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="14" rx="2" />
+            <rect width="10" height="6" x="7" y="4" rx="2" />
+            <path d="M2 14h20" />
+            <path d="M2 4h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_vertical_justify_center.rs b/packages/yew/src/align_vertical_justify_center.rs
new file mode 100644
index 0000000..858b7fa
--- /dev/null
+++ b/packages/yew/src/align_vertical_justify_center.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignVerticalJustifyCenterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignVerticalJustifyCenter(props: &AlignVerticalJustifyCenterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="16" rx="2" />
+            <rect width="10" height="6" x="7" y="2" rx="2" />
+            <path d="M2 12h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_vertical_justify_end.rs b/packages/yew/src/align_vertical_justify_end.rs
new file mode 100644
index 0000000..9471d15
--- /dev/null
+++ b/packages/yew/src/align_vertical_justify_end.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignVerticalJustifyEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignVerticalJustifyEnd(props: &AlignVerticalJustifyEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="12" rx="2" />
+            <rect width="10" height="6" x="7" y="2" rx="2" />
+            <path d="M2 22h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_vertical_justify_start.rs b/packages/yew/src/align_vertical_justify_start.rs
new file mode 100644
index 0000000..abaeeb2
--- /dev/null
+++ b/packages/yew/src/align_vertical_justify_start.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignVerticalJustifyStartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignVerticalJustifyStart(props: &AlignVerticalJustifyStartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="16" rx="2" />
+            <rect width="10" height="6" x="7" y="6" rx="2" />
+            <path d="M2 2h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_vertical_space_around.rs b/packages/yew/src/align_vertical_space_around.rs
new file mode 100644
index 0000000..76e11af
--- /dev/null
+++ b/packages/yew/src/align_vertical_space_around.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignVerticalSpaceAroundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignVerticalSpaceAround(props: &AlignVerticalSpaceAroundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="10" height="6" x="7" y="9" rx="2" />
+            <path d="M22 20H2" />
+            <path d="M22 4H2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/align_vertical_space_between.rs b/packages/yew/src/align_vertical_space_between.rs
new file mode 100644
index 0000000..73918f5
--- /dev/null
+++ b/packages/yew/src/align_vertical_space_between.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AlignVerticalSpaceBetweenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AlignVerticalSpaceBetween(props: &AlignVerticalSpaceBetweenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="6" x="5" y="15" rx="2" />
+            <rect width="10" height="6" x="7" y="3" rx="2" />
+            <path d="M2 21h20" />
+            <path d="M2 3h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ambulance.rs b/packages/yew/src/ambulance.rs
new file mode 100644
index 0000000..152e4e7
--- /dev/null
+++ b/packages/yew/src/ambulance.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AmbulanceProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ambulance(props: &AmbulanceProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10H6" />
+            <path d="M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2" />
+            <path
+                d="M19 18h2a1 1 0 0 0 1-1v-3.28a1 1 0 0 0-.684-.948l-1.923-.641a1 1 0 0 1-.578-.502l-1.539-3.076A1 1 0 0 0 16.382 8H14"
+            />
+            <path d="M8 8v4" />
+            <path d="M9 18h6" />
+            <circle cx="17" cy="18" r="2" />
+            <circle cx="7" cy="18" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ampersand.rs b/packages/yew/src/ampersand.rs
new file mode 100644
index 0000000..3cf0e9f
--- /dev/null
+++ b/packages/yew/src/ampersand.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AmpersandProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ampersand(props: &AmpersandProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M17.5 12c0 4.4-3.6 8-8 8A4.5 4.5 0 0 1 5 15.5c0-6 8-4 8-8.5a3 3 0 1 0-6 0c0 3 2.5 8.5 12 13"
+            />
+            <path d="M16 12h3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ampersands.rs b/packages/yew/src/ampersands.rs
new file mode 100644
index 0000000..6383fa9
--- /dev/null
+++ b/packages/yew/src/ampersands.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AmpersandsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ampersands(props: &AmpersandsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5"
+            />
+            <path
+                d="M22 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/amphora.rs b/packages/yew/src/amphora.rs
new file mode 100644
index 0000000..6860a5c
--- /dev/null
+++ b/packages/yew/src/amphora.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AmphoraProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Amphora(props: &AmphoraProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v5.632c0 .424-.272.795-.653.982A6 6 0 0 0 6 14c.006 4 3 7 5 8" />
+            <path d="M10 5H8a2 2 0 0 0 0 4h.68" />
+            <path d="M14 2v5.632c0 .424.272.795.652.982A6 6 0 0 1 18 14c0 4-3 7-5 8" />
+            <path d="M14 5h2a2 2 0 0 1 0 4h-.68" />
+            <path d="M18 22H6" />
+            <path d="M9 2h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/anchor.rs b/packages/yew/src/anchor.rs
new file mode 100644
index 0000000..56cfb60
--- /dev/null
+++ b/packages/yew/src/anchor.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AnchorProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Anchor(props: &AnchorProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22V8" />
+            <path d="M5 12H2a10 10 0 0 0 20 0h-3" />
+            <circle cx="12" cy="5" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/angry.rs b/packages/yew/src/angry.rs
new file mode 100644
index 0000000..dbb3507
--- /dev/null
+++ b/packages/yew/src/angry.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AngryProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Angry(props: &AngryProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M16 16s-1.5-2-4-2-4 2-4 2" />
+            <path d="M7.5 8 10 9" />
+            <path d="m14 9 2.5-1" />
+            <path d="M9 10h.01" />
+            <path d="M15 10h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/annoyed.rs b/packages/yew/src/annoyed.rs
new file mode 100644
index 0000000..3cb8361
--- /dev/null
+++ b/packages/yew/src/annoyed.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AnnoyedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Annoyed(props: &AnnoyedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M8 15h8" />
+            <path d="M8 9h2" />
+            <path d="M14 9h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/antenna.rs b/packages/yew/src/antenna.rs
new file mode 100644
index 0000000..b76659b
--- /dev/null
+++ b/packages/yew/src/antenna.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AntennaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Antenna(props: &AntennaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12 7 2" />
+            <path d="m7 12 5-10" />
+            <path d="m12 12 5-10" />
+            <path d="m17 12 5-10" />
+            <path d="M4.5 7h15" />
+            <path d="M12 16v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/anvil.rs b/packages/yew/src/anvil.rs
new file mode 100644
index 0000000..aec1d04
--- /dev/null
+++ b/packages/yew/src/anvil.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AnvilProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Anvil(props: &AnvilProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 10H6a4 4 0 0 1-4-4 1 1 0 0 1 1-1h4" />
+            <path d="M7 5a1 1 0 0 1 1-1h13a1 1 0 0 1 1 1 7 7 0 0 1-7 7H8a1 1 0 0 1-1-1z" />
+            <path d="M9 12v5" />
+            <path d="M15 12v5" />
+            <path d="M5 20a3 3 0 0 1 3-3h8a3 3 0 0 1 3 3 1 1 0 0 1-1 1H6a1 1 0 0 1-1-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/aperture.rs b/packages/yew/src/aperture.rs
new file mode 100644
index 0000000..d74a42b
--- /dev/null
+++ b/packages/yew/src/aperture.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ApertureProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Aperture(props: &ApertureProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m14.31 8 5.74 9.94" />
+            <path d="M9.69 8h11.48" />
+            <path d="m7.38 12 5.74-9.94" />
+            <path d="M9.69 16 3.95 6.06" />
+            <path d="M14.31 16H2.83" />
+            <path d="m16.62 12-5.74 9.94" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/app_window.rs b/packages/yew/src/app_window.rs
new file mode 100644
index 0000000..15f5952
--- /dev/null
+++ b/packages/yew/src/app_window.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AppWindowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AppWindow(props: &AppWindowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="2" y="4" width="20" height="16" rx="2" />
+            <path d="M10 4v4" />
+            <path d="M2 8h20" />
+            <path d="M6 4v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/app_window_mac.rs b/packages/yew/src/app_window_mac.rs
new file mode 100644
index 0000000..e2ced6f
--- /dev/null
+++ b/packages/yew/src/app_window_mac.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AppWindowMacProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AppWindowMac(props: &AppWindowMacProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+            <path d="M6 8h.01" />
+            <path d="M10 8h.01" />
+            <path d="M14 8h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/apple.rs b/packages/yew/src/apple.rs
new file mode 100644
index 0000000..f19ca95
--- /dev/null
+++ b/packages/yew/src/apple.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AppleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Apple(props: &AppleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 20.94c1.5 0 2.75 1.06 4 1.06 3 0 6-8 6-12.22A4.91 4.91 0 0 0 17 5c-2.22 0-4 1.44-5 2-1-.56-2.78-2-5-2a4.9 4.9 0 0 0-5 4.78C2 14 5 22 8 22c1.25 0 2.5-1.06 4-1.06Z"
+            />
+            <path d="M10 2c1 .5 2 2 2 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/archive.rs b/packages/yew/src/archive.rs
new file mode 100644
index 0000000..7afa769
--- /dev/null
+++ b/packages/yew/src/archive.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArchiveProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Archive(props: &ArchiveProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="5" x="2" y="3" rx="1" />
+            <path d="M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8" />
+            <path d="M10 12h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/archive_restore.rs b/packages/yew/src/archive_restore.rs
new file mode 100644
index 0000000..f7cf33a
--- /dev/null
+++ b/packages/yew/src/archive_restore.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArchiveRestoreProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArchiveRestore(props: &ArchiveRestoreProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="5" x="2" y="3" rx="1" />
+            <path d="M4 8v11a2 2 0 0 0 2 2h2" />
+            <path d="M20 8v11a2 2 0 0 1-2 2h-2" />
+            <path d="m9 15 3-3 3 3" />
+            <path d="M12 12v9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/archive_x.rs b/packages/yew/src/archive_x.rs
new file mode 100644
index 0000000..b7d5c67
--- /dev/null
+++ b/packages/yew/src/archive_x.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArchiveXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArchiveX(props: &ArchiveXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="5" x="2" y="3" rx="1" />
+            <path d="M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8" />
+            <path d="m9.5 17 5-5" />
+            <path d="m9.5 12 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/armchair.rs b/packages/yew/src/armchair.rs
new file mode 100644
index 0000000..c904bc6
--- /dev/null
+++ b/packages/yew/src/armchair.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArmchairProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Armchair(props: &ArmchairProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 9V6a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v3" />
+            <path
+                d="M3 16a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-9a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z"
+            />
+            <path d="M5 18v2" />
+            <path d="M19 18v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_big_down.rs b/packages/yew/src/arrow_big_down.rs
new file mode 100644
index 0000000..fea5c6c
--- /dev/null
+++ b/packages/yew/src/arrow_big_down.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowBigDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowBigDown(props: &ArrowBigDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 6v6h4l-7 7-7-7h4V6h6z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_big_down_dash.rs b/packages/yew/src/arrow_big_down_dash.rs
new file mode 100644
index 0000000..eaa367c
--- /dev/null
+++ b/packages/yew/src/arrow_big_down_dash.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowBigDownDashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowBigDownDash(props: &ArrowBigDownDashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 5H9" />
+            <path d="M15 9v3h4l-7 7-7-7h4V9z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_big_left.rs b/packages/yew/src/arrow_big_left.rs
new file mode 100644
index 0000000..c0e857b
--- /dev/null
+++ b/packages/yew/src/arrow_big_left.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowBigLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowBigLeft(props: &ArrowBigLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 15h-6v4l-7-7 7-7v4h6v6z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_big_left_dash.rs b/packages/yew/src/arrow_big_left_dash.rs
new file mode 100644
index 0000000..1b9c9a1
--- /dev/null
+++ b/packages/yew/src/arrow_big_left_dash.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowBigLeftDashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowBigLeftDash(props: &ArrowBigLeftDashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 15V9" />
+            <path d="M15 15h-3v4l-7-7 7-7v4h3v6z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_big_right.rs b/packages/yew/src/arrow_big_right.rs
new file mode 100644
index 0000000..5b14ceb
--- /dev/null
+++ b/packages/yew/src/arrow_big_right.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowBigRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowBigRight(props: &ArrowBigRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 9h6V5l7 7-7 7v-4H6V9z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_big_right_dash.rs b/packages/yew/src/arrow_big_right_dash.rs
new file mode 100644
index 0000000..6741e67
--- /dev/null
+++ b/packages/yew/src/arrow_big_right_dash.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowBigRightDashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowBigRightDash(props: &ArrowBigRightDashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 9v6" />
+            <path d="M9 9h3V5l7 7-7 7v-4H9V9z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_big_up.rs b/packages/yew/src/arrow_big_up.rs
new file mode 100644
index 0000000..c056e06
--- /dev/null
+++ b/packages/yew/src/arrow_big_up.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowBigUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowBigUp(props: &ArrowBigUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 18v-6H5l7-7 7 7h-4v6H9z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_big_up_dash.rs b/packages/yew/src/arrow_big_up_dash.rs
new file mode 100644
index 0000000..b9df561
--- /dev/null
+++ b/packages/yew/src/arrow_big_up_dash.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowBigUpDashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowBigUpDash(props: &ArrowBigUpDashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 19h6" />
+            <path d="M9 15v-3H5l7-7 7 7h-4v3H9z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down.rs b/packages/yew/src/arrow_down.rs
new file mode 100644
index 0000000..a17a6f0
--- /dev/null
+++ b/packages/yew/src/arrow_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDown(props: &ArrowDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5v14" />
+            <path d="m19 12-7 7-7-7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_0_1.rs b/packages/yew/src/arrow_down_0_1.rs
new file mode 100644
index 0000000..0cc3dbf
--- /dev/null
+++ b/packages/yew/src/arrow_down_0_1.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDown01Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDown01(props: &ArrowDown01Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4" />
+            <path d="M7 20V4" />
+            <rect x="15" y="4" width="4" height="6" ry="2" />
+            <path d="M17 20v-6h-2" />
+            <path d="M15 20h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_1_0.rs b/packages/yew/src/arrow_down_1_0.rs
new file mode 100644
index 0000000..a678f74
--- /dev/null
+++ b/packages/yew/src/arrow_down_1_0.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDown10Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDown10(props: &ArrowDown10Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4" />
+            <path d="M7 20V4" />
+            <path d="M17 10V4h-2" />
+            <path d="M15 10h4" />
+            <rect x="15" y="14" width="4" height="6" ry="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_a_z.rs b/packages/yew/src/arrow_down_a_z.rs
new file mode 100644
index 0000000..840b976
--- /dev/null
+++ b/packages/yew/src/arrow_down_a_z.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownAZProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownAZ(props: &ArrowDownAZProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4" />
+            <path d="M7 20V4" />
+            <path d="M20 8h-5" />
+            <path d="M15 10V6.5a2.5 2.5 0 0 1 5 0V10" />
+            <path d="M15 14h5l-5 6h5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_from_line.rs b/packages/yew/src/arrow_down_from_line.rs
new file mode 100644
index 0000000..206a768
--- /dev/null
+++ b/packages/yew/src/arrow_down_from_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownFromLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownFromLine(props: &ArrowDownFromLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 3H5" />
+            <path d="M12 21V7" />
+            <path d="m6 15 6 6 6-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_left.rs b/packages/yew/src/arrow_down_left.rs
new file mode 100644
index 0000000..61920bc
--- /dev/null
+++ b/packages/yew/src/arrow_down_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownLeft(props: &ArrowDownLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 7 7 17" />
+            <path d="M17 17H7V7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_narrow_wide.rs b/packages/yew/src/arrow_down_narrow_wide.rs
new file mode 100644
index 0000000..d6510a4
--- /dev/null
+++ b/packages/yew/src/arrow_down_narrow_wide.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownNarrowWideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownNarrowWide(props: &ArrowDownNarrowWideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4" />
+            <path d="M7 20V4" />
+            <path d="M11 4h4" />
+            <path d="M11 8h7" />
+            <path d="M11 12h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_right.rs b/packages/yew/src/arrow_down_right.rs
new file mode 100644
index 0000000..8efb491
--- /dev/null
+++ b/packages/yew/src/arrow_down_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownRight(props: &ArrowDownRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 7 10 10" />
+            <path d="M17 7v10H7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_to_dot.rs b/packages/yew/src/arrow_down_to_dot.rs
new file mode 100644
index 0000000..aae09e5
--- /dev/null
+++ b/packages/yew/src/arrow_down_to_dot.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownToDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownToDot(props: &ArrowDownToDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v14" />
+            <path d="m19 9-7 7-7-7" />
+            <circle cx="12" cy="21" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_to_line.rs b/packages/yew/src/arrow_down_to_line.rs
new file mode 100644
index 0000000..4d7f04a
--- /dev/null
+++ b/packages/yew/src/arrow_down_to_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownToLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownToLine(props: &ArrowDownToLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17V3" />
+            <path d="m6 11 6 6 6-6" />
+            <path d="M19 21H5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_up.rs b/packages/yew/src/arrow_down_up.rs
new file mode 100644
index 0000000..0a025ad
--- /dev/null
+++ b/packages/yew/src/arrow_down_up.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownUp(props: &ArrowDownUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4" />
+            <path d="M7 20V4" />
+            <path d="m21 8-4-4-4 4" />
+            <path d="M17 4v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_wide_narrow.rs b/packages/yew/src/arrow_down_wide_narrow.rs
new file mode 100644
index 0000000..944ab4e
--- /dev/null
+++ b/packages/yew/src/arrow_down_wide_narrow.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownWideNarrowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownWideNarrow(props: &ArrowDownWideNarrowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4" />
+            <path d="M7 20V4" />
+            <path d="M11 4h10" />
+            <path d="M11 8h7" />
+            <path d="M11 12h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_down_z_a.rs b/packages/yew/src/arrow_down_z_a.rs
new file mode 100644
index 0000000..0a47798
--- /dev/null
+++ b/packages/yew/src/arrow_down_z_a.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowDownZAProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowDownZA(props: &ArrowDownZAProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 16 4 4 4-4" />
+            <path d="M7 4v16" />
+            <path d="M15 4h5l-5 6h5" />
+            <path d="M15 20v-3.5a2.5 2.5 0 0 1 5 0V20" />
+            <path d="M20 18h-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_left.rs b/packages/yew/src/arrow_left.rs
new file mode 100644
index 0000000..8302093
--- /dev/null
+++ b/packages/yew/src/arrow_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowLeft(props: &ArrowLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 19-7-7 7-7" />
+            <path d="M19 12H5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_left_from_line.rs b/packages/yew/src/arrow_left_from_line.rs
new file mode 100644
index 0000000..61e991c
--- /dev/null
+++ b/packages/yew/src/arrow_left_from_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowLeftFromLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowLeftFromLine(props: &ArrowLeftFromLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 6-6 6 6 6" />
+            <path d="M3 12h14" />
+            <path d="M21 19V5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_left_right.rs b/packages/yew/src/arrow_left_right.rs
new file mode 100644
index 0000000..1c0feba
--- /dev/null
+++ b/packages/yew/src/arrow_left_right.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowLeftRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowLeftRight(props: &ArrowLeftRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3 4 7l4 4" />
+            <path d="M4 7h16" />
+            <path d="m16 21 4-4-4-4" />
+            <path d="M20 17H4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_left_to_line.rs b/packages/yew/src/arrow_left_to_line.rs
new file mode 100644
index 0000000..90a58f4
--- /dev/null
+++ b/packages/yew/src/arrow_left_to_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowLeftToLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowLeftToLine(props: &ArrowLeftToLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 19V5" />
+            <path d="m13 6-6 6 6 6" />
+            <path d="M7 12h14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_right.rs b/packages/yew/src/arrow_right.rs
new file mode 100644
index 0000000..fb4f038
--- /dev/null
+++ b/packages/yew/src/arrow_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowRight(props: &ArrowRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 12h14" />
+            <path d="m12 5 7 7-7 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_right_from_line.rs b/packages/yew/src/arrow_right_from_line.rs
new file mode 100644
index 0000000..de728ec
--- /dev/null
+++ b/packages/yew/src/arrow_right_from_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowRightFromLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowRightFromLine(props: &ArrowRightFromLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 5v14" />
+            <path d="M21 12H7" />
+            <path d="m15 18 6-6-6-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_right_left.rs b/packages/yew/src/arrow_right_left.rs
new file mode 100644
index 0000000..4629b96
--- /dev/null
+++ b/packages/yew/src/arrow_right_left.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowRightLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowRightLeft(props: &ArrowRightLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 3 4 4-4 4" />
+            <path d="M20 7H4" />
+            <path d="m8 21-4-4 4-4" />
+            <path d="M4 17h16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_right_to_line.rs b/packages/yew/src/arrow_right_to_line.rs
new file mode 100644
index 0000000..c6441d4
--- /dev/null
+++ b/packages/yew/src/arrow_right_to_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowRightToLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowRightToLine(props: &ArrowRightToLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 12H3" />
+            <path d="m11 18 6-6-6-6" />
+            <path d="M21 5v14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up.rs b/packages/yew/src/arrow_up.rs
new file mode 100644
index 0000000..452e562
--- /dev/null
+++ b/packages/yew/src/arrow_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUp(props: &ArrowUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5 12 7-7 7 7" />
+            <path d="M12 19V5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_0_1.rs b/packages/yew/src/arrow_up_0_1.rs
new file mode 100644
index 0000000..93cad0a
--- /dev/null
+++ b/packages/yew/src/arrow_up_0_1.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUp01Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUp01(props: &ArrowUp01Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4" />
+            <path d="M7 4v16" />
+            <rect x="15" y="4" width="4" height="6" ry="2" />
+            <path d="M17 20v-6h-2" />
+            <path d="M15 20h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_1_0.rs b/packages/yew/src/arrow_up_1_0.rs
new file mode 100644
index 0000000..2f219b5
--- /dev/null
+++ b/packages/yew/src/arrow_up_1_0.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUp10Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUp10(props: &ArrowUp10Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4" />
+            <path d="M7 4v16" />
+            <path d="M17 10V4h-2" />
+            <path d="M15 10h4" />
+            <rect x="15" y="14" width="4" height="6" ry="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_a_z.rs b/packages/yew/src/arrow_up_a_z.rs
new file mode 100644
index 0000000..d8597d9
--- /dev/null
+++ b/packages/yew/src/arrow_up_a_z.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpAZProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpAZ(props: &ArrowUpAZProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4" />
+            <path d="M7 4v16" />
+            <path d="M20 8h-5" />
+            <path d="M15 10V6.5a2.5 2.5 0 0 1 5 0V10" />
+            <path d="M15 14h5l-5 6h5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_down.rs b/packages/yew/src/arrow_up_down.rs
new file mode 100644
index 0000000..7e9c137
--- /dev/null
+++ b/packages/yew/src/arrow_up_down.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpDown(props: &ArrowUpDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21 16-4 4-4-4" />
+            <path d="M17 20V4" />
+            <path d="m3 8 4-4 4 4" />
+            <path d="M7 4v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_from_dot.rs b/packages/yew/src/arrow_up_from_dot.rs
new file mode 100644
index 0000000..00c28f3
--- /dev/null
+++ b/packages/yew/src/arrow_up_from_dot.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpFromDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpFromDot(props: &ArrowUpFromDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5 9 7-7 7 7" />
+            <path d="M12 16V2" />
+            <circle cx="12" cy="21" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_from_line.rs b/packages/yew/src/arrow_up_from_line.rs
new file mode 100644
index 0000000..fbb9dfe
--- /dev/null
+++ b/packages/yew/src/arrow_up_from_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpFromLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpFromLine(props: &ArrowUpFromLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 9-6-6-6 6" />
+            <path d="M12 3v14" />
+            <path d="M5 21h14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_left.rs b/packages/yew/src/arrow_up_left.rs
new file mode 100644
index 0000000..d50b456
--- /dev/null
+++ b/packages/yew/src/arrow_up_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpLeft(props: &ArrowUpLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 17V7h10" />
+            <path d="M17 17 7 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_narrow_wide.rs b/packages/yew/src/arrow_up_narrow_wide.rs
new file mode 100644
index 0000000..ae8a9ff
--- /dev/null
+++ b/packages/yew/src/arrow_up_narrow_wide.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpNarrowWideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpNarrowWide(props: &ArrowUpNarrowWideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4" />
+            <path d="M7 4v16" />
+            <path d="M11 12h4" />
+            <path d="M11 16h7" />
+            <path d="M11 20h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_right.rs b/packages/yew/src/arrow_up_right.rs
new file mode 100644
index 0000000..4bdf0dd
--- /dev/null
+++ b/packages/yew/src/arrow_up_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpRight(props: &ArrowUpRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 7h10v10" />
+            <path d="M7 17 17 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_to_line.rs b/packages/yew/src/arrow_up_to_line.rs
new file mode 100644
index 0000000..cf5a461
--- /dev/null
+++ b/packages/yew/src/arrow_up_to_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpToLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpToLine(props: &ArrowUpToLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 3h14" />
+            <path d="m18 13-6-6-6 6" />
+            <path d="M12 7v14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_wide_narrow.rs b/packages/yew/src/arrow_up_wide_narrow.rs
new file mode 100644
index 0000000..17a1167
--- /dev/null
+++ b/packages/yew/src/arrow_up_wide_narrow.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpWideNarrowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpWideNarrow(props: &ArrowUpWideNarrowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4" />
+            <path d="M7 4v16" />
+            <path d="M11 12h10" />
+            <path d="M11 16h7" />
+            <path d="M11 20h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrow_up_z_a.rs b/packages/yew/src/arrow_up_z_a.rs
new file mode 100644
index 0000000..46d8aa4
--- /dev/null
+++ b/packages/yew/src/arrow_up_z_a.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowUpZAProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowUpZA(props: &ArrowUpZAProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 8 4-4 4 4" />
+            <path d="M7 4v16" />
+            <path d="M15 4h5l-5 6h5" />
+            <path d="M15 20v-3.5a2.5 2.5 0 0 1 5 0V20" />
+            <path d="M20 18h-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/arrows_up_from_line.rs b/packages/yew/src/arrows_up_from_line.rs
new file mode 100644
index 0000000..4806356
--- /dev/null
+++ b/packages/yew/src/arrows_up_from_line.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ArrowsUpFromLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ArrowsUpFromLine(props: &ArrowsUpFromLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4 6 3-3 3 3" />
+            <path d="M7 17V3" />
+            <path d="m14 6 3-3 3 3" />
+            <path d="M17 17V3" />
+            <path d="M4 21h16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/asterisk.rs b/packages/yew/src/asterisk.rs
new file mode 100644
index 0000000..19c55e7
--- /dev/null
+++ b/packages/yew/src/asterisk.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AsteriskProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Asterisk(props: &AsteriskProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v12" />
+            <path d="M17.196 9 6.804 15" />
+            <path d="m6.804 9 10.392 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/at_sign.rs b/packages/yew/src/at_sign.rs
new file mode 100644
index 0000000..6523bef
--- /dev/null
+++ b/packages/yew/src/at_sign.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AtSignProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AtSign(props: &AtSignProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="4" />
+            <path d="M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-4 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/atom.rs b/packages/yew/src/atom.rs
new file mode 100644
index 0000000..b4b81c9
--- /dev/null
+++ b/packages/yew/src/atom.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AtomProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Atom(props: &AtomProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="1" />
+            <path
+                d="M20.2 20.2c2.04-2.03.02-7.36-4.5-11.9-4.54-4.52-9.87-6.54-11.9-4.5-2.04 2.03-.02 7.36 4.5 11.9 4.54 4.52 9.87 6.54 11.9 4.5Z"
+            />
+            <path
+                d="M15.7 15.7c4.52-4.54 6.54-9.87 4.5-11.9-2.03-2.04-7.36-.02-11.9 4.5-4.52 4.54-6.54 9.87-4.5 11.9 2.03 2.04 7.36.02 11.9-4.5Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/audio_lines.rs b/packages/yew/src/audio_lines.rs
new file mode 100644
index 0000000..9200876
--- /dev/null
+++ b/packages/yew/src/audio_lines.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AudioLinesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AudioLines(props: &AudioLinesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 10v3" />
+            <path d="M6 6v11" />
+            <path d="M10 3v18" />
+            <path d="M14 8v7" />
+            <path d="M18 5v13" />
+            <path d="M22 10v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/audio_waveform.rs b/packages/yew/src/audio_waveform.rs
new file mode 100644
index 0000000..f4f8187
--- /dev/null
+++ b/packages/yew/src/audio_waveform.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AudioWaveformProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn AudioWaveform(props: &AudioWaveformProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 13a2 2 0 0 0 2-2V7a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0V4a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0v-4a2 2 0 0 1 2-2"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/award.rs b/packages/yew/src/award.rs
new file mode 100644
index 0000000..68fef73
--- /dev/null
+++ b/packages/yew/src/award.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AwardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Award(props: &AwardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m15.477 12.89 1.515 8.526a.5.5 0 0 1-.81.47l-3.58-2.687a1 1 0 0 0-1.197 0l-3.586 2.686a.5.5 0 0 1-.81-.469l1.514-8.526"
+            />
+            <circle cx="12" cy="8" r="6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/axe.rs b/packages/yew/src/axe.rs
new file mode 100644
index 0000000..ead3289
--- /dev/null
+++ b/packages/yew/src/axe.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct AxeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Axe(props: &AxeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14 12-8.5 8.5a2.12 2.12 0 1 1-3-3L11 9" />
+            <path d="M15 13 9 7l4-4 6 6h3a8 8 0 0 1-7 7z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/axis_3_d.rs b/packages/yew/src/axis_3_d.rs
new file mode 100644
index 0000000..8af45fa
--- /dev/null
+++ b/packages/yew/src/axis_3_d.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Axis3DProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Axis3D(props: &Axis3DProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16h16" />
+            <path d="m4 20 7-7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/baby.rs b/packages/yew/src/baby.rs
new file mode 100644
index 0000000..dcc75d8
--- /dev/null
+++ b/packages/yew/src/baby.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BabyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Baby(props: &BabyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 12h.01" />
+            <path d="M15 12h.01" />
+            <path d="M10 16c.5.3 1.2.5 2 .5s1.5-.2 2-.5" />
+            <path
+                d="M19 6.3a9 9 0 0 1 1.8 3.9 2 2 0 0 1 0 3.6 9 9 0 0 1-17.6 0 2 2 0 0 1 0-3.6A9 9 0 0 1 12 3c2 0 3.5 1.1 3.5 2.5s-.9 2.5-2 2.5c-.8 0-1.5-.4-1.5-1"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/backpack.rs b/packages/yew/src/backpack.rs
new file mode 100644
index 0000000..728d576
--- /dev/null
+++ b/packages/yew/src/backpack.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BackpackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Backpack(props: &BackpackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10a4 4 0 0 1 4-4h8a4 4 0 0 1 4 4v10a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2z" />
+            <path d="M8 10h8" />
+            <path d="M8 18h8" />
+            <path d="M8 22v-6a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v6" />
+            <path d="M9 6V4a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge.rs b/packages/yew/src/badge.rs
new file mode 100644
index 0000000..da581a8
--- /dev/null
+++ b/packages/yew/src/badge.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Badge(props: &BadgeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_alert.rs b/packages/yew/src/badge_alert.rs
new file mode 100644
index 0000000..d68ab07
--- /dev/null
+++ b/packages/yew/src/badge_alert.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeAlertProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeAlert(props: &BadgeAlertProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <line x1="12" x2="12" y1="8" y2="12" />
+            <line x1="12" x2="12.01" y1="16" y2="16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_cent.rs b/packages/yew/src/badge_cent.rs
new file mode 100644
index 0000000..54b07ef
--- /dev/null
+++ b/packages/yew/src/badge_cent.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeCentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeCent(props: &BadgeCentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="M12 7v10" />
+            <path d="M15.4 10a4 4 0 1 0 0 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_check.rs b/packages/yew/src/badge_check.rs
new file mode 100644
index 0000000..5e17796
--- /dev/null
+++ b/packages/yew/src/badge_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeCheck(props: &BadgeCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="m9 12 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_dollar_sign.rs b/packages/yew/src/badge_dollar_sign.rs
new file mode 100644
index 0000000..42e6fa7
--- /dev/null
+++ b/packages/yew/src/badge_dollar_sign.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeDollarSignProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeDollarSign(props: &BadgeDollarSignProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8" />
+            <path d="M12 18V6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_euro.rs b/packages/yew/src/badge_euro.rs
new file mode 100644
index 0000000..ea174d9
--- /dev/null
+++ b/packages/yew/src/badge_euro.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeEuroProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeEuro(props: &BadgeEuroProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="M7 12h5" />
+            <path d="M15 9.4a4 4 0 1 0 0 5.2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_help.rs b/packages/yew/src/badge_help.rs
new file mode 100644
index 0000000..b70ec7f
--- /dev/null
+++ b/packages/yew/src/badge_help.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeHelpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeHelp(props: &BadgeHelpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" />
+            <line x1="12" x2="12.01" y1="17" y2="17" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_indian_rupee.rs b/packages/yew/src/badge_indian_rupee.rs
new file mode 100644
index 0000000..ed79f09
--- /dev/null
+++ b/packages/yew/src/badge_indian_rupee.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeIndianRupeeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeIndianRupee(props: &BadgeIndianRupeeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="M8 8h8" />
+            <path d="M8 12h8" />
+            <path d="m13 17-5-1h1a4 4 0 0 0 0-8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_info.rs b/packages/yew/src/badge_info.rs
new file mode 100644
index 0000000..6beb0b3
--- /dev/null
+++ b/packages/yew/src/badge_info.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeInfoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeInfo(props: &BadgeInfoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <line x1="12" x2="12" y1="16" y2="12" />
+            <line x1="12" x2="12.01" y1="8" y2="8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_japanese_yen.rs b/packages/yew/src/badge_japanese_yen.rs
new file mode 100644
index 0000000..c023e5b
--- /dev/null
+++ b/packages/yew/src/badge_japanese_yen.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeJapaneseYenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeJapaneseYen(props: &BadgeJapaneseYenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="m9 8 3 3v7" />
+            <path d="m12 11 3-3" />
+            <path d="M9 12h6" />
+            <path d="M9 16h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_minus.rs b/packages/yew/src/badge_minus.rs
new file mode 100644
index 0000000..d04243b
--- /dev/null
+++ b/packages/yew/src/badge_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeMinus(props: &BadgeMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <line x1="8" x2="16" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_percent.rs b/packages/yew/src/badge_percent.rs
new file mode 100644
index 0000000..2178512
--- /dev/null
+++ b/packages/yew/src/badge_percent.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgePercentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgePercent(props: &BadgePercentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="m15 9-6 6" />
+            <path d="M9 9h.01" />
+            <path d="M15 15h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_plus.rs b/packages/yew/src/badge_plus.rs
new file mode 100644
index 0000000..c88defa
--- /dev/null
+++ b/packages/yew/src/badge_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgePlus(props: &BadgePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <line x1="12" x2="12" y1="8" y2="16" />
+            <line x1="8" x2="16" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_pound_sterling.rs b/packages/yew/src/badge_pound_sterling.rs
new file mode 100644
index 0000000..016e12b
--- /dev/null
+++ b/packages/yew/src/badge_pound_sterling.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgePoundSterlingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgePoundSterling(props: &BadgePoundSterlingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="M8 12h4" />
+            <path d="M10 16V9.5a2.5 2.5 0 0 1 5 0" />
+            <path d="M8 16h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_russian_ruble.rs b/packages/yew/src/badge_russian_ruble.rs
new file mode 100644
index 0000000..5c6f819
--- /dev/null
+++ b/packages/yew/src/badge_russian_ruble.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeRussianRubleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeRussianRuble(props: &BadgeRussianRubleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="M9 16h5" />
+            <path d="M9 12h5a2 2 0 1 0 0-4h-3v9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_swiss_franc.rs b/packages/yew/src/badge_swiss_franc.rs
new file mode 100644
index 0000000..42bcf63
--- /dev/null
+++ b/packages/yew/src/badge_swiss_franc.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeSwissFrancProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeSwissFranc(props: &BadgeSwissFrancProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <path d="M11 17V8h4" />
+            <path d="M11 12h3" />
+            <path d="M9 16h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/badge_x.rs b/packages/yew/src/badge_x.rs
new file mode 100644
index 0000000..5b59d7f
--- /dev/null
+++ b/packages/yew/src/badge_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BadgeXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BadgeX(props: &BadgeXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"
+            />
+            <line x1="15" x2="9" y1="9" y2="15" />
+            <line x1="9" x2="15" y1="9" y2="15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/baggage_claim.rs b/packages/yew/src/baggage_claim.rs
new file mode 100644
index 0000000..1a74fce
--- /dev/null
+++ b/packages/yew/src/baggage_claim.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BaggageClaimProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BaggageClaim(props: &BaggageClaimProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 18H6a2 2 0 0 1-2-2V7a2 2 0 0 0-2-2" />
+            <path d="M17 14V4a2 2 0 0 0-2-2h-1a2 2 0 0 0-2 2v10" />
+            <rect width="13" height="8" x="8" y="6" rx="1" />
+            <circle cx="18" cy="20" r="2" />
+            <circle cx="9" cy="20" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ban.rs b/packages/yew/src/ban.rs
new file mode 100644
index 0000000..89f7aac
--- /dev/null
+++ b/packages/yew/src/ban.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ban(props: &BanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m4.9 4.9 14.2 14.2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/banana.rs b/packages/yew/src/banana.rs
new file mode 100644
index 0000000..0291144
--- /dev/null
+++ b/packages/yew/src/banana.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BananaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Banana(props: &BananaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 13c3.5-2 8-2 10 2a5.5 5.5 0 0 1 8 5" />
+            <path
+                d="M5.15 17.89c5.52-1.52 8.65-6.89 7-12C11.55 4 11.5 2 13 2c3.22 0 5 5.5 5 8 0 6.5-4.2 12-10.49 12C5.11 22 2 22 2 20c0-1.5 1.14-1.55 3.15-2.11Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bandage.rs b/packages/yew/src/bandage.rs
new file mode 100644
index 0000000..d647e76
--- /dev/null
+++ b/packages/yew/src/bandage.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BandageProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bandage(props: &BandageProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10.01h.01" />
+            <path d="M10 14.01h.01" />
+            <path d="M14 10.01h.01" />
+            <path d="M14 14.01h.01" />
+            <path d="M18 6v11.5" />
+            <path d="M6 6v12" />
+            <rect x="2" y="6" width="20" height="12" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/banknote.rs b/packages/yew/src/banknote.rs
new file mode 100644
index 0000000..9a088e6
--- /dev/null
+++ b/packages/yew/src/banknote.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BanknoteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Banknote(props: &BanknoteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="2" />
+            <circle cx="12" cy="12" r="2" />
+            <path d="M6 12h.01M18 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/barcode.rs b/packages/yew/src/barcode.rs
new file mode 100644
index 0000000..669b711
--- /dev/null
+++ b/packages/yew/src/barcode.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BarcodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Barcode(props: &BarcodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 5v14" />
+            <path d="M8 5v14" />
+            <path d="M12 5v14" />
+            <path d="M17 5v14" />
+            <path d="M21 5v14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/baseline.rs b/packages/yew/src/baseline.rs
new file mode 100644
index 0000000..421641e
--- /dev/null
+++ b/packages/yew/src/baseline.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BaselineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Baseline(props: &BaselineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 20h16" />
+            <path d="m6 16 6-12 6 12" />
+            <path d="M8 12h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bath.rs b/packages/yew/src/bath.rs
new file mode 100644
index 0000000..f0683ef
--- /dev/null
+++ b/packages/yew/src/bath.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BathProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bath(props: &BathProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 4 8 6" />
+            <path d="M17 19v2" />
+            <path d="M2 12h20" />
+            <path d="M7 19v2" />
+            <path d="M9 5 7.621 3.621A2.121 2.121 0 0 0 4 5v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/battery.rs b/packages/yew/src/battery.rs
new file mode 100644
index 0000000..7ca9fbd
--- /dev/null
+++ b/packages/yew/src/battery.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BatteryProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Battery(props: &BatteryProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="10" x="2" y="7" rx="2" ry="2" />
+            <line x1="22" x2="22" y1="11" y2="13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/battery_charging.rs b/packages/yew/src/battery_charging.rs
new file mode 100644
index 0000000..7ae8587
--- /dev/null
+++ b/packages/yew/src/battery_charging.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BatteryChargingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BatteryCharging(props: &BatteryChargingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 7h1a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2h-2" />
+            <path d="M6 7H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h1" />
+            <path d="m11 7-3 5h4l-3 5" />
+            <line x1="22" x2="22" y1="11" y2="13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/battery_full.rs b/packages/yew/src/battery_full.rs
new file mode 100644
index 0000000..857b4e2
--- /dev/null
+++ b/packages/yew/src/battery_full.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BatteryFullProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BatteryFull(props: &BatteryFullProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="10" x="2" y="7" rx="2" ry="2" />
+            <line x1="22" x2="22" y1="11" y2="13" />
+            <line x1="6" x2="6" y1="11" y2="13" />
+            <line x1="10" x2="10" y1="11" y2="13" />
+            <line x1="14" x2="14" y1="11" y2="13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/battery_low.rs b/packages/yew/src/battery_low.rs
new file mode 100644
index 0000000..9739582
--- /dev/null
+++ b/packages/yew/src/battery_low.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BatteryLowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BatteryLow(props: &BatteryLowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="10" x="2" y="7" rx="2" ry="2" />
+            <line x1="22" x2="22" y1="11" y2="13" />
+            <line x1="6" x2="6" y1="11" y2="13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/battery_medium.rs b/packages/yew/src/battery_medium.rs
new file mode 100644
index 0000000..2c66f39
--- /dev/null
+++ b/packages/yew/src/battery_medium.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BatteryMediumProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BatteryMedium(props: &BatteryMediumProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="10" x="2" y="7" rx="2" ry="2" />
+            <line x1="22" x2="22" y1="11" y2="13" />
+            <line x1="6" x2="6" y1="11" y2="13" />
+            <line x1="10" x2="10" y1="11" y2="13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/battery_warning.rs b/packages/yew/src/battery_warning.rs
new file mode 100644
index 0000000..7b7d161
--- /dev/null
+++ b/packages/yew/src/battery_warning.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BatteryWarningProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BatteryWarning(props: &BatteryWarningProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 17h.01" />
+            <path d="M10 7v6" />
+            <path d="M14 7h2a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2h-2" />
+            <path d="M22 11v2" />
+            <path d="M6 7H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/beaker.rs b/packages/yew/src/beaker.rs
new file mode 100644
index 0000000..9675bdb
--- /dev/null
+++ b/packages/yew/src/beaker.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BeakerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Beaker(props: &BeakerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.5 3h15" />
+            <path d="M6 3v16a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V3" />
+            <path d="M6 14h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bean.rs b/packages/yew/src/bean.rs
new file mode 100644
index 0000000..492ac23
--- /dev/null
+++ b/packages/yew/src/bean.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BeanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bean(props: &BeanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.165 6.598C9.954 7.478 9.64 8.36 9 9c-.64.64-1.521.954-2.402 1.165A6 6 0 0 0 8 22c7.732 0 14-6.268 14-14a6 6 0 0 0-11.835-1.402Z"
+            />
+            <path d="M5.341 10.62a4 4 0 1 0 5.279-5.28" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bean_off.rs b/packages/yew/src/bean_off.rs
new file mode 100644
index 0000000..b255678
--- /dev/null
+++ b/packages/yew/src/bean_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BeanOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BeanOff(props: &BeanOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 9c-.64.64-1.521.954-2.402 1.165A6 6 0 0 0 8 22a13.96 13.96 0 0 0 9.9-4.1" />
+            <path d="M10.75 5.093A6 6 0 0 1 22 8c0 2.411-.61 4.68-1.683 6.66" />
+            <path d="M5.341 10.62a4 4 0 0 0 6.487 1.208M10.62 5.341a4.015 4.015 0 0 1 2.039 2.04" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bed.rs b/packages/yew/src/bed.rs
new file mode 100644
index 0000000..75c92fc
--- /dev/null
+++ b/packages/yew/src/bed.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bed(props: &BedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 4v16" />
+            <path d="M2 8h18a2 2 0 0 1 2 2v10" />
+            <path d="M2 17h20" />
+            <path d="M6 8v9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bed_double.rs b/packages/yew/src/bed_double.rs
new file mode 100644
index 0000000..c368f94
--- /dev/null
+++ b/packages/yew/src/bed_double.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BedDoubleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BedDouble(props: &BedDoubleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20v-8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v8" />
+            <path d="M4 10V6a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v4" />
+            <path d="M12 4v6" />
+            <path d="M2 18h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bed_single.rs b/packages/yew/src/bed_single.rs
new file mode 100644
index 0000000..fb47312
--- /dev/null
+++ b/packages/yew/src/bed_single.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BedSingleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BedSingle(props: &BedSingleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 20v-8a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v8" />
+            <path d="M5 10V6a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v4" />
+            <path d="M3 18h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/beef.rs b/packages/yew/src/beef.rs
new file mode 100644
index 0000000..b995168
--- /dev/null
+++ b/packages/yew/src/beef.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BeefProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Beef(props: &BeefProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12.5" cy="8.5" r="2.5" />
+            <path
+                d="M12.5 2a6.5 6.5 0 0 0-6.22 4.6c-1.1 3.13-.78 3.9-3.18 6.08A3 3 0 0 0 5 18c4 0 8.4-1.8 11.4-4.3A6.5 6.5 0 0 0 12.5 2Z"
+            />
+            <path
+                d="m18.5 6 2.19 4.5a6.48 6.48 0 0 1 .31 2 6.49 6.49 0 0 1-2.6 5.2C15.4 20.2 11 22 7 22a3 3 0 0 1-2.68-1.66L2.4 16.5"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/beer.rs b/packages/yew/src/beer.rs
new file mode 100644
index 0000000..23ccad4
--- /dev/null
+++ b/packages/yew/src/beer.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BeerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Beer(props: &BeerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 11h1a3 3 0 0 1 0 6h-1" />
+            <path d="M9 12v6" />
+            <path d="M13 12v6" />
+            <path
+                d="M14 7.5c-1 0-1.44.5-3 .5s-2-.5-3-.5-1.72.5-2.5.5a2.5 2.5 0 0 1 0-5c.78 0 1.57.5 2.5.5S9.44 2 11 2s2 1.5 3 1.5 1.72-.5 2.5-.5a2.5 2.5 0 0 1 0 5c-.78 0-1.5-.5-2.5-.5Z"
+            />
+            <path d="M5 8v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/beer_off.rs b/packages/yew/src/beer_off.rs
new file mode 100644
index 0000000..3fc7fe4
--- /dev/null
+++ b/packages/yew/src/beer_off.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BeerOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BeerOff(props: &BeerOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 13v5" />
+            <path d="M17 11.47V8" />
+            <path d="M17 11h1a3 3 0 0 1 2.745 4.211" />
+            <path d="m2 2 20 20" />
+            <path d="M5 8v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2v-3" />
+            <path d="M7.536 7.535C6.766 7.649 6.154 8 5.5 8a2.5 2.5 0 0 1-1.768-4.268" />
+            <path
+                d="M8.727 3.204C9.306 2.767 9.885 2 11 2c1.56 0 2 1.5 3 1.5s1.72-.5 2.5-.5a1 1 0 1 1 0 5c-.78 0-1.5-.5-2.5-.5a3.149 3.149 0 0 0-.842.12"
+            />
+            <path d="M9 14.6V18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bell.rs b/packages/yew/src/bell.rs
new file mode 100644
index 0000000..f36d5bf
--- /dev/null
+++ b/packages/yew/src/bell.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BellProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bell(props: &BellProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8a6 6 0 0 1 12 0c0 7 3 9 3 9H3s3-2 3-9" />
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bell_dot.rs b/packages/yew/src/bell_dot.rs
new file mode 100644
index 0000000..d8ea6ca
--- /dev/null
+++ b/packages/yew/src/bell_dot.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BellDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BellDot(props: &BellDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.4 14.9C20.2 16.4 21 17 21 17H3s3-2 3-9c0-3.3 2.7-6 6-6 .7 0 1.3.1 1.9.3" />
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0" />
+            <circle cx="18" cy="8" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bell_electric.rs b/packages/yew/src/bell_electric.rs
new file mode 100644
index 0000000..17b7b1d
--- /dev/null
+++ b/packages/yew/src/bell_electric.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BellElectricProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BellElectric(props: &BellElectricProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.8 4A6.3 8.7 0 0 1 20 9" />
+            <path d="M9 9h.01" />
+            <circle cx="9" cy="9" r="7" />
+            <rect width="10" height="6" x="4" y="16" rx="2" />
+            <path d="M14 19c3 0 4.6-1.6 4.6-1.6" />
+            <circle cx="20" cy="16" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bell_minus.rs b/packages/yew/src/bell_minus.rs
new file mode 100644
index 0000000..7ab6c0d
--- /dev/null
+++ b/packages/yew/src/bell_minus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BellMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BellMinus(props: &BellMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.4 12c.8 3.8 2.6 5 2.6 5H3s3-2 3-9c0-3.3 2.7-6 6-6 1.8 0 3.4.8 4.5 2" />
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0" />
+            <path d="M15 8h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bell_off.rs b/packages/yew/src/bell_off.rs
new file mode 100644
index 0000000..31b36ec
--- /dev/null
+++ b/packages/yew/src/bell_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BellOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BellOff(props: &BellOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.7 3A6 6 0 0 1 18 8a21.3 21.3 0 0 0 .6 5" />
+            <path d="M17 17H3s3-2 3-9a4.67 4.67 0 0 1 .3-1.7" />
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bell_plus.rs b/packages/yew/src/bell_plus.rs
new file mode 100644
index 0000000..719c2b6
--- /dev/null
+++ b/packages/yew/src/bell_plus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BellPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BellPlus(props: &BellPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.3 14.8C20.1 16.4 21 17 21 17H3s3-2 3-9c0-3.3 2.7-6 6-6 1 0 1.9.2 2.8.7" />
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0" />
+            <path d="M15 8h6" />
+            <path d="M18 5v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bell_ring.rs b/packages/yew/src/bell_ring.rs
new file mode 100644
index 0000000..ae38d98
--- /dev/null
+++ b/packages/yew/src/bell_ring.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BellRingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BellRing(props: &BellRingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8a6 6 0 0 1 12 0c0 7 3 9 3 9H3s3-2 3-9" />
+            <path d="M10.3 21a1.94 1.94 0 0 0 3.4 0" />
+            <path d="M4 2C2.8 3.7 2 5.7 2 8" />
+            <path d="M22 8c0-2.3-.8-4.3-2-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/between_horizontal_end.rs b/packages/yew/src/between_horizontal_end.rs
new file mode 100644
index 0000000..e1532b1
--- /dev/null
+++ b/packages/yew/src/between_horizontal_end.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BetweenHorizontalEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BetweenHorizontalEnd(props: &BetweenHorizontalEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="13" height="7" x="3" y="3" rx="1" />
+            <path d="m22 15-3-3 3-3" />
+            <rect width="13" height="7" x="3" y="14" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/between_horizontal_start.rs b/packages/yew/src/between_horizontal_start.rs
new file mode 100644
index 0000000..6f30728
--- /dev/null
+++ b/packages/yew/src/between_horizontal_start.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BetweenHorizontalStartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BetweenHorizontalStart(props: &BetweenHorizontalStartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="13" height="7" x="8" y="3" rx="1" />
+            <path d="m2 9 3 3-3 3" />
+            <rect width="13" height="7" x="8" y="14" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/between_vertical_end.rs b/packages/yew/src/between_vertical_end.rs
new file mode 100644
index 0000000..6d3cbfd
--- /dev/null
+++ b/packages/yew/src/between_vertical_end.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BetweenVerticalEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BetweenVerticalEnd(props: &BetweenVerticalEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="13" x="3" y="3" rx="1" />
+            <path d="m9 22 3-3 3 3" />
+            <rect width="7" height="13" x="14" y="3" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/between_vertical_start.rs b/packages/yew/src/between_vertical_start.rs
new file mode 100644
index 0000000..d357aab
--- /dev/null
+++ b/packages/yew/src/between_vertical_start.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BetweenVerticalStartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BetweenVerticalStart(props: &BetweenVerticalStartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="13" x="3" y="8" rx="1" />
+            <path d="m15 2-3 3-3-3" />
+            <rect width="7" height="13" x="14" y="8" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/biceps_flexed.rs b/packages/yew/src/biceps_flexed.rs
new file mode 100644
index 0000000..afe2437
--- /dev/null
+++ b/packages/yew/src/biceps_flexed.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BicepsFlexedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BicepsFlexed(props: &BicepsFlexedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12.409 13.017A5 5 0 0 1 22 15c0 3.866-4 7-9 7-4.077 0-8.153-.82-10.371-2.462-.426-.316-.631-.832-.62-1.362C2.118 12.723 2.627 2 10 2a3 3 0 0 1 3 3 2 2 0 0 1-2 2c-1.105 0-1.64-.444-2-1"
+            />
+            <path d="M15 14a5 5 0 0 0-7.584 2" />
+            <path d="M9.964 6.825C8.019 7.977 9.5 13 8 15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bike.rs b/packages/yew/src/bike.rs
new file mode 100644
index 0000000..9867a23
--- /dev/null
+++ b/packages/yew/src/bike.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BikeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bike(props: &BikeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18.5" cy="17.5" r="3.5" />
+            <circle cx="5.5" cy="17.5" r="3.5" />
+            <circle cx="15" cy="5" r="1" />
+            <path d="M12 17.5V14l-3-3 4-3 2 3h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/binary.rs b/packages/yew/src/binary.rs
new file mode 100644
index 0000000..ebe6c26
--- /dev/null
+++ b/packages/yew/src/binary.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BinaryProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Binary(props: &BinaryProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="14" y="14" width="4" height="6" rx="2" />
+            <rect x="6" y="4" width="4" height="6" rx="2" />
+            <path d="M6 20h4" />
+            <path d="M14 10h4" />
+            <path d="M6 14h2v6" />
+            <path d="M14 4h2v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/binoculars.rs b/packages/yew/src/binoculars.rs
new file mode 100644
index 0000000..921050f
--- /dev/null
+++ b/packages/yew/src/binoculars.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BinocularsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Binoculars(props: &BinocularsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10h4" />
+            <path d="M19 7V4a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v3" />
+            <path
+                d="M20 21a2 2 0 0 0 2-2v-3.851c0-1.39-2-2.962-2-4.829V8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v11a2 2 0 0 0 2 2z"
+            />
+            <path d="M 22 16 L 2 16" />
+            <path
+                d="M4 21a2 2 0 0 1-2-2v-3.851c0-1.39 2-2.962 2-4.829V8a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v11a2 2 0 0 1-2 2z"
+            />
+            <path d="M9 7V4a1 1 0 0 0-1-1H6a1 1 0 0 0-1 1v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/biohazard.rs b/packages/yew/src/biohazard.rs
new file mode 100644
index 0000000..b36e3ab
--- /dev/null
+++ b/packages/yew/src/biohazard.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BiohazardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Biohazard(props: &BiohazardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="11.9" r="2" />
+            <path d="M6.7 3.4c-.9 2.5 0 5.2 2.2 6.7C6.5 9 3.7 9.6 2 11.6" />
+            <path d="m8.9 10.1 1.4.8" />
+            <path d="M17.3 3.4c.9 2.5 0 5.2-2.2 6.7 2.4-1.2 5.2-.6 6.9 1.5" />
+            <path d="m15.1 10.1-1.4.8" />
+            <path d="M16.7 20.8c-2.6-.4-4.6-2.6-4.7-5.3-.2 2.6-2.1 4.8-4.7 5.2" />
+            <path d="M12 13.9v1.6" />
+            <path d="M13.5 5.4c-1-.2-2-.2-3 0" />
+            <path d="M17 16.4c.7-.7 1.2-1.6 1.5-2.5" />
+            <path d="M5.5 13.9c.3.9.8 1.8 1.5 2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bird.rs b/packages/yew/src/bird.rs
new file mode 100644
index 0000000..9874155
--- /dev/null
+++ b/packages/yew/src/bird.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BirdProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bird(props: &BirdProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 7h.01" />
+            <path d="M3.4 18H12a8 8 0 0 0 8-8V7a4 4 0 0 0-7.28-2.3L2 20" />
+            <path d="m20 7 2 .5-2 .5" />
+            <path d="M10 18v3" />
+            <path d="M14 17.75V21" />
+            <path d="M7 18a6 6 0 0 0 3.84-10.61" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bitcoin.rs b/packages/yew/src/bitcoin.rs
new file mode 100644
index 0000000..efbb565
--- /dev/null
+++ b/packages/yew/src/bitcoin.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BitcoinProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bitcoin(props: &BitcoinProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11.767 19.089c4.924.868 6.14-6.025 1.216-6.894m-1.216 6.894L5.86 18.047m5.908 1.042-.347 1.97m1.563-8.864c4.924.869 6.14-6.025 1.215-6.893m-1.215 6.893-3.94-.694m5.155-6.2L8.29 4.26m5.908 1.042.348-1.97M7.48 20.364l3.126-17.727"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/blend.rs b/packages/yew/src/blend.rs
new file mode 100644
index 0000000..838c5dc
--- /dev/null
+++ b/packages/yew/src/blend.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BlendProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Blend(props: &BlendProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="9" cy="9" r="7" />
+            <circle cx="15" cy="15" r="7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/blinds.rs b/packages/yew/src/blinds.rs
new file mode 100644
index 0000000..79f8099
--- /dev/null
+++ b/packages/yew/src/blinds.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BlindsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Blinds(props: &BlindsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3h18" />
+            <path d="M20 7H8" />
+            <path d="M20 11H8" />
+            <path d="M10 19h10" />
+            <path d="M8 15h12" />
+            <path d="M4 3v14" />
+            <circle cx="4" cy="19" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/blocks.rs b/packages/yew/src/blocks.rs
new file mode 100644
index 0000000..c050783
--- /dev/null
+++ b/packages/yew/src/blocks.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BlocksProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Blocks(props: &BlocksProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="7" x="14" y="3" rx="1" />
+            <path
+                d="M10 21V8a1 1 0 0 0-1-1H4a1 1 0 0 0-1 1v12a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-5a1 1 0 0 0-1-1H3"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bluetooth.rs b/packages/yew/src/bluetooth.rs
new file mode 100644
index 0000000..9d94c0e
--- /dev/null
+++ b/packages/yew/src/bluetooth.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BluetoothProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bluetooth(props: &BluetoothProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 7 10 10-5 5V2l5 5L7 17" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bluetooth_connected.rs b/packages/yew/src/bluetooth_connected.rs
new file mode 100644
index 0000000..83b367b
--- /dev/null
+++ b/packages/yew/src/bluetooth_connected.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BluetoothConnectedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BluetoothConnected(props: &BluetoothConnectedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 7 10 10-5 5V2l5 5L7 17" />
+            <line x1="18" x2="21" y1="12" y2="12" />
+            <line x1="3" x2="6" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bluetooth_off.rs b/packages/yew/src/bluetooth_off.rs
new file mode 100644
index 0000000..0ba8235
--- /dev/null
+++ b/packages/yew/src/bluetooth_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BluetoothOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BluetoothOff(props: &BluetoothOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 17-5 5V12l-5 5" />
+            <path d="m2 2 20 20" />
+            <path d="M14.5 9.5 17 7l-5-5v4.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bluetooth_searching.rs b/packages/yew/src/bluetooth_searching.rs
new file mode 100644
index 0000000..4a69315
--- /dev/null
+++ b/packages/yew/src/bluetooth_searching.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BluetoothSearchingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BluetoothSearching(props: &BluetoothSearchingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 7 10 10-5 5V2l5 5L7 17" />
+            <path d="M20.83 14.83a4 4 0 0 0 0-5.66" />
+            <path d="M18 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bold.rs b/packages/yew/src/bold.rs
new file mode 100644
index 0000000..d493506
--- /dev/null
+++ b/packages/yew/src/bold.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BoldProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bold(props: &BoldProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bolt.rs b/packages/yew/src/bolt.rs
new file mode 100644
index 0000000..be432a5
--- /dev/null
+++ b/packages/yew/src/bolt.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BoltProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bolt(props: &BoltProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"
+            />
+            <circle cx="12" cy="12" r="4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bomb.rs b/packages/yew/src/bomb.rs
new file mode 100644
index 0000000..f1e4370
--- /dev/null
+++ b/packages/yew/src/bomb.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BombProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bomb(props: &BombProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="13" r="9" />
+            <path
+                d="M14.35 4.65 16.3 2.7a2.41 2.41 0 0 1 3.4 0l1.6 1.6a2.4 2.4 0 0 1 0 3.4l-1.95 1.95"
+            />
+            <path d="m22 2-1.5 1.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bone.rs b/packages/yew/src/bone.rs
new file mode 100644
index 0000000..b7d2a7f
--- /dev/null
+++ b/packages/yew/src/bone.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BoneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bone(props: &BoneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M17 10c.7-.7 1.69 0 2.5 0a2.5 2.5 0 1 0 0-5 .5.5 0 0 1-.5-.5 2.5 2.5 0 1 0-5 0c0 .81.7 1.8 0 2.5l-7 7c-.7.7-1.69 0-2.5 0a2.5 2.5 0 0 0 0 5c.28 0 .5.22.5.5a2.5 2.5 0 1 0 5 0c0-.81-.7-1.8 0-2.5Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book.rs b/packages/yew/src/book.rs
new file mode 100644
index 0000000..84929cb
--- /dev/null
+++ b/packages/yew/src/book.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Book(props: &BookProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_a.rs b/packages/yew/src/book_a.rs
new file mode 100644
index 0000000..8132af8
--- /dev/null
+++ b/packages/yew/src/book_a.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookAProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookA(props: &BookAProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="m8 13 4-7 4 7" />
+            <path d="M9.1 11h5.7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_audio.rs b/packages/yew/src/book_audio.rs
new file mode 100644
index 0000000..bd42084
--- /dev/null
+++ b/packages/yew/src/book_audio.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookAudioProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookAudio(props: &BookAudioProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v7" />
+            <path d="M16 8v3" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="M8 8v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_check.rs b/packages/yew/src/book_check.rs
new file mode 100644
index 0000000..6677c12
--- /dev/null
+++ b/packages/yew/src/book_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookCheck(props: &BookCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="m9 9.5 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_copy.rs b/packages/yew/src/book_copy.rs
new file mode 100644
index 0000000..96ac2c0
--- /dev/null
+++ b/packages/yew/src/book_copy.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookCopyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookCopy(props: &BookCopyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 16V4a2 2 0 0 1 2-2h11" />
+            <path
+                d="M22 18H11a2 2 0 1 0 0 4h10.5a.5.5 0 0 0 .5-.5v-15a.5.5 0 0 0-.5-.5H11a2 2 0 0 0-2 2v12"
+            />
+            <path d="M5 14H4a2 2 0 1 0 0 4h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_dashed.rs b/packages/yew/src/book_dashed.rs
new file mode 100644
index 0000000..c69a2df
--- /dev/null
+++ b/packages/yew/src/book_dashed.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookDashed(props: &BookDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17h2" />
+            <path d="M12 22h2" />
+            <path d="M12 2h2" />
+            <path d="M18 22h1a1 1 0 0 0 1-1" />
+            <path d="M18 2h1a1 1 0 0 1 1 1v1" />
+            <path d="M20 15v2h-2" />
+            <path d="M20 8v3" />
+            <path d="M4 11V9" />
+            <path d="M4 19.5V15" />
+            <path d="M4 5v-.5A2.5 2.5 0 0 1 6.5 2H8" />
+            <path d="M8 22H6.5a1 1 0 0 1 0-5H8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_down.rs b/packages/yew/src/book_down.rs
new file mode 100644
index 0000000..71dfd21
--- /dev/null
+++ b/packages/yew/src/book_down.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookDown(props: &BookDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V7" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="m9 10 3 3 3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_headphones.rs b/packages/yew/src/book_headphones.rs
new file mode 100644
index 0000000..3d21aec
--- /dev/null
+++ b/packages/yew/src/book_headphones.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookHeadphonesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookHeadphones(props: &BookHeadphonesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="M8 12v-2a4 4 0 0 1 8 0v2" />
+            <circle cx="15" cy="12" r="1" />
+            <circle cx="9" cy="12" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_heart.rs b/packages/yew/src/book_heart.rs
new file mode 100644
index 0000000..d787765
--- /dev/null
+++ b/packages/yew/src/book_heart.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookHeartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookHeart(props: &BookHeartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M16 8.2A2.22 2.22 0 0 0 13.8 6c-.8 0-1.4.3-1.8.9-.4-.6-1-.9-1.8-.9A2.22 2.22 0 0 0 8 8.2c0 .6.3 1.2.7 1.6A226.652 226.652 0 0 0 12 13a404 404 0 0 0 3.3-3.1 2.413 2.413 0 0 0 .7-1.7"
+            />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_image.rs b/packages/yew/src/book_image.rs
new file mode 100644
index 0000000..ff8dee8
--- /dev/null
+++ b/packages/yew/src/book_image.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookImageProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookImage(props: &BookImageProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m20 13.7-2.1-2.1a2 2 0 0 0-2.8 0L9.7 17" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <circle cx="10" cy="8" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_key.rs b/packages/yew/src/book_key.rs
new file mode 100644
index 0000000..8109840
--- /dev/null
+++ b/packages/yew/src/book_key.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookKeyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookKey(props: &BookKeyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 3 1 1" />
+            <path d="m20 2-4.5 4.5" />
+            <path d="M20 8v13a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20" />
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H14" />
+            <circle cx="14" cy="8" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_lock.rs b/packages/yew/src/book_lock.rs
new file mode 100644
index 0000000..5ede83c
--- /dev/null
+++ b/packages/yew/src/book_lock.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookLockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookLock(props: &BookLockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 6V4a2 2 0 1 0-4 0v2" />
+            <path d="M20 15v6a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20" />
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H10" />
+            <rect x="12" y="6" width="8" height="5" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_marked.rs b/packages/yew/src/book_marked.rs
new file mode 100644
index 0000000..6762560
--- /dev/null
+++ b/packages/yew/src/book_marked.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookMarkedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookMarked(props: &BookMarkedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v8l3-3 3 3V2" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_minus.rs b/packages/yew/src/book_minus.rs
new file mode 100644
index 0000000..2e12b46
--- /dev/null
+++ b/packages/yew/src/book_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookMinus(props: &BookMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="M9 10h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_open.rs b/packages/yew/src/book_open.rs
new file mode 100644
index 0000000..4d45405
--- /dev/null
+++ b/packages/yew/src/book_open.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookOpen(props: &BookOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v14" />
+            <path
+                d="M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_open_check.rs b/packages/yew/src/book_open_check.rs
new file mode 100644
index 0000000..fc10b22
--- /dev/null
+++ b/packages/yew/src/book_open_check.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookOpenCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookOpenCheck(props: &BookOpenCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 21V7" />
+            <path d="m16 12 2 2 4-4" />
+            <path
+                d="M22 6V4a1 1 0 0 0-1-1h-5a4 4 0 0 0-4 4 4 4 0 0 0-4-4H3a1 1 0 0 0-1 1v13a1 1 0 0 0 1 1h6a3 3 0 0 1 3 3 3 3 0 0 1 3-3h6a1 1 0 0 0 1-1v-1.3"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_open_text.rs b/packages/yew/src/book_open_text.rs
new file mode 100644
index 0000000..52f0601
--- /dev/null
+++ b/packages/yew/src/book_open_text.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookOpenTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookOpenText(props: &BookOpenTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v14" />
+            <path d="M16 12h2" />
+            <path d="M16 8h2" />
+            <path
+                d="M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z"
+            />
+            <path d="M6 12h2" />
+            <path d="M6 8h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_plus.rs b/packages/yew/src/book_plus.rs
new file mode 100644
index 0000000..498853c
--- /dev/null
+++ b/packages/yew/src/book_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookPlus(props: &BookPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v6" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="M9 10h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_text.rs b/packages/yew/src/book_text.rs
new file mode 100644
index 0000000..3284e8d
--- /dev/null
+++ b/packages/yew/src/book_text.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookText(props: &BookTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="M8 11h8" />
+            <path d="M8 7h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_type.rs b/packages/yew/src/book_type.rs
new file mode 100644
index 0000000..a958f21
--- /dev/null
+++ b/packages/yew/src/book_type.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookTypeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookType(props: &BookTypeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 13h4" />
+            <path d="M12 6v7" />
+            <path d="M16 8V6H8v2" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_up.rs b/packages/yew/src/book_up.rs
new file mode 100644
index 0000000..1289151
--- /dev/null
+++ b/packages/yew/src/book_up.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookUp(props: &BookUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V7" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="m9 10 3-3 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_up_2.rs b/packages/yew/src/book_up_2.rs
new file mode 100644
index 0000000..767515c
--- /dev/null
+++ b/packages/yew/src/book_up_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookUp2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookUp2(props: &BookUp2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V7" />
+            <path d="M18 2h1a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20" />
+            <path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2" />
+            <path d="m9 10 3-3 3 3" />
+            <path d="m9 5 3-3 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_user.rs b/packages/yew/src/book_user.rs
new file mode 100644
index 0000000..c7f4308
--- /dev/null
+++ b/packages/yew/src/book_user.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookUserProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookUser(props: &BookUserProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 13a3 3 0 1 0-6 0" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <circle cx="12" cy="8" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/book_x.rs b/packages/yew/src/book_x.rs
new file mode 100644
index 0000000..70f8300
--- /dev/null
+++ b/packages/yew/src/book_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookX(props: &BookXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14.5 7-5 5" />
+            <path
+                d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"
+            />
+            <path d="m9.5 7 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bookmark.rs b/packages/yew/src/bookmark.rs
new file mode 100644
index 0000000..af19320
--- /dev/null
+++ b/packages/yew/src/bookmark.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookmarkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bookmark(props: &BookmarkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bookmark_check.rs b/packages/yew/src/bookmark_check.rs
new file mode 100644
index 0000000..430f382
--- /dev/null
+++ b/packages/yew/src/bookmark_check.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookmarkCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookmarkCheck(props: &BookmarkCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2Z" />
+            <path d="m9 10 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bookmark_minus.rs b/packages/yew/src/bookmark_minus.rs
new file mode 100644
index 0000000..09b1ae3
--- /dev/null
+++ b/packages/yew/src/bookmark_minus.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookmarkMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookmarkMinus(props: &BookmarkMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z" />
+            <line x1="15" x2="9" y1="10" y2="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bookmark_plus.rs b/packages/yew/src/bookmark_plus.rs
new file mode 100644
index 0000000..e1b3dc1
--- /dev/null
+++ b/packages/yew/src/bookmark_plus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookmarkPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookmarkPlus(props: &BookmarkPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z" />
+            <line x1="12" x2="12" y1="7" y2="13" />
+            <line x1="15" x2="9" y1="10" y2="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bookmark_x.rs b/packages/yew/src/bookmark_x.rs
new file mode 100644
index 0000000..8fa3cde
--- /dev/null
+++ b/packages/yew/src/bookmark_x.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BookmarkXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BookmarkX(props: &BookmarkXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2Z" />
+            <path d="m14.5 7.5-5 5" />
+            <path d="m9.5 7.5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/boom_box.rs b/packages/yew/src/boom_box.rs
new file mode 100644
index 0000000..e9cae83
--- /dev/null
+++ b/packages/yew/src/boom_box.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BoomBoxProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BoomBox(props: &BoomBoxProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 9V5a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v4" />
+            <path d="M8 8v1" />
+            <path d="M12 8v1" />
+            <path d="M16 8v1" />
+            <rect width="20" height="12" x="2" y="9" rx="2" />
+            <circle cx="8" cy="15" r="2" />
+            <circle cx="16" cy="15" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bot.rs b/packages/yew/src/bot.rs
new file mode 100644
index 0000000..f66047f
--- /dev/null
+++ b/packages/yew/src/bot.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bot(props: &BotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 8V4H8" />
+            <rect width="16" height="12" x="4" y="8" rx="2" />
+            <path d="M2 14h2" />
+            <path d="M20 14h2" />
+            <path d="M15 13v2" />
+            <path d="M9 13v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bot_message_square.rs b/packages/yew/src/bot_message_square.rs
new file mode 100644
index 0000000..632a774
--- /dev/null
+++ b/packages/yew/src/bot_message_square.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BotMessageSquareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BotMessageSquare(props: &BotMessageSquareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6V2H8" />
+            <path d="m8 18-4 4V8a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2Z" />
+            <path d="M2 12h2" />
+            <path d="M9 11v2" />
+            <path d="M15 11v2" />
+            <path d="M20 12h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bot_off.rs b/packages/yew/src/bot_off.rs
new file mode 100644
index 0000000..14be638
--- /dev/null
+++ b/packages/yew/src/bot_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BotOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BotOff(props: &BotOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.67 8H18a2 2 0 0 1 2 2v4.33" />
+            <path d="M2 14h2" />
+            <path d="M20 14h2" />
+            <path d="M22 22 2 2" />
+            <path d="M8 8H6a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h12a2 2 0 0 0 1.414-.586" />
+            <path d="M9 13v2" />
+            <path d="M9.67 4H12v2.33" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/box.rs b/packages/yew/src/box.rs
new file mode 100644
index 0000000..8ba5b06
--- /dev/null
+++ b/packages/yew/src/box.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BoxProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Box(props: &BoxProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"
+            />
+            <path d="m3.3 7 8.7 5 8.7-5" />
+            <path d="M12 22V12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/boxes.rs b/packages/yew/src/boxes.rs
new file mode 100644
index 0000000..2a36626
--- /dev/null
+++ b/packages/yew/src/boxes.rs
@@ -0,0 +1,61 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BoxesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Boxes(props: &BoxesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z"
+            />
+            <path d="m7 16.5-4.74-2.85" />
+            <path d="m7 16.5 5-3" />
+            <path d="M7 16.5v5.17" />
+            <path
+                d="M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z"
+            />
+            <path d="m17 16.5-5-3" />
+            <path d="m17 16.5 4.74-2.85" />
+            <path d="M17 16.5v5.17" />
+            <path
+                d="M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0l-3 1.8Z"
+            />
+            <path d="M12 8 7.26 5.15" />
+            <path d="m12 8 4.74-2.85" />
+            <path d="M12 13.5V8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/braces.rs b/packages/yew/src/braces.rs
new file mode 100644
index 0000000..6ace75c
--- /dev/null
+++ b/packages/yew/src/braces.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BracesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Braces(props: &BracesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3H7a2 2 0 0 0-2 2v5a2 2 0 0 1-2 2 2 2 0 0 1 2 2v5c0 1.1.9 2 2 2h1" />
+            <path d="M16 21h1a2 2 0 0 0 2-2v-5c0-1.1.9-2 2-2a2 2 0 0 1-2-2V5a2 2 0 0 0-2-2h-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/brackets.rs b/packages/yew/src/brackets.rs
new file mode 100644
index 0000000..9c67519
--- /dev/null
+++ b/packages/yew/src/brackets.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BracketsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Brackets(props: &BracketsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 3h3v18h-3" />
+            <path d="M8 21H5V3h3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/brain.rs b/packages/yew/src/brain.rs
new file mode 100644
index 0000000..f1038bb
--- /dev/null
+++ b/packages/yew/src/brain.rs
@@ -0,0 +1,56 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BrainProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Brain(props: &BrainProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z"
+            />
+            <path
+                d="M12 5a3 3 0 1 1 5.997.125 4 4 0 0 1 2.526 5.77 4 4 0 0 1-.556 6.588A4 4 0 1 1 12 18Z"
+            />
+            <path d="M15 13a4.5 4.5 0 0 1-3-4 4.5 4.5 0 0 1-3 4" />
+            <path d="M17.599 6.5a3 3 0 0 0 .399-1.375" />
+            <path d="M6.003 5.125A3 3 0 0 0 6.401 6.5" />
+            <path d="M3.477 10.896a4 4 0 0 1 .585-.396" />
+            <path d="M19.938 10.5a4 4 0 0 1 .585.396" />
+            <path d="M6 18a4 4 0 0 1-1.967-.516" />
+            <path d="M19.967 17.484A4 4 0 0 1 18 18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/brain_circuit.rs b/packages/yew/src/brain_circuit.rs
new file mode 100644
index 0000000..3134a09
--- /dev/null
+++ b/packages/yew/src/brain_circuit.rs
@@ -0,0 +1,58 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BrainCircuitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BrainCircuit(props: &BrainCircuitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z"
+            />
+            <path d="M9 13a4.5 4.5 0 0 0 3-4" />
+            <path d="M6.003 5.125A3 3 0 0 0 6.401 6.5" />
+            <path d="M3.477 10.896a4 4 0 0 1 .585-.396" />
+            <path d="M6 18a4 4 0 0 1-1.967-.516" />
+            <path d="M12 13h4" />
+            <path d="M12 18h6a2 2 0 0 1 2 2v1" />
+            <path d="M12 8h8" />
+            <path d="M16 8V5a2 2 0 0 1 2-2" />
+            <circle cx="16" cy="13" r=".5" />
+            <circle cx="18" cy="3" r=".5" />
+            <circle cx="20" cy="21" r=".5" />
+            <circle cx="20" cy="8" r=".5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/brain_cog.rs b/packages/yew/src/brain_cog.rs
new file mode 100644
index 0000000..a4c0fb0
--- /dev/null
+++ b/packages/yew/src/brain_cog.rs
@@ -0,0 +1,61 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BrainCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BrainCog(props: &BrainCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 5a3 3 0 1 0-5.997.142 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588 4 4 0 0 0 7.636 2.106 3.2 3.2 0 0 0 .164-.546c.028-.13.306-.13.335 0a3.2 3.2 0 0 0 .163.546 4 4 0 0 0 7.636-2.106 4 4 0 0 0 .556-6.588 4 4 0 0 0-2.526-5.77A3 3 0 1 0 12 5"
+            />
+            <path d="M17.599 6.5a3 3 0 0 0 .399-1.375" />
+            <path d="M6.003 5.125A3 3 0 0 0 6.401 6.5" />
+            <path d="M3.477 10.896a4 4 0 0 1 .585-.396" />
+            <path d="M19.938 10.5a4 4 0 0 1 .585.396" />
+            <path d="M6 18a4 4 0 0 1-1.967-.516" />
+            <path d="M19.967 17.484A4 4 0 0 1 18 18" />
+            <circle cx="12" cy="12" r="3" />
+            <path d="m15.7 10.4-.9.4" />
+            <path d="m9.2 13.2-.9.4" />
+            <path d="m13.6 15.7-.4-.9" />
+            <path d="m10.8 9.2-.4-.9" />
+            <path d="m15.7 13.5-.9-.4" />
+            <path d="m9.2 10.9-.9-.4" />
+            <path d="m10.5 15.7.4-.9" />
+            <path d="m13.1 9.2.4-.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/brick_wall.rs b/packages/yew/src/brick_wall.rs
new file mode 100644
index 0000000..672f4e2
--- /dev/null
+++ b/packages/yew/src/brick_wall.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BrickWallProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BrickWall(props: &BrickWallProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M12 9v6" />
+            <path d="M16 15v6" />
+            <path d="M16 3v6" />
+            <path d="M3 15h18" />
+            <path d="M3 9h18" />
+            <path d="M8 15v6" />
+            <path d="M8 3v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/briefcase.rs b/packages/yew/src/briefcase.rs
new file mode 100644
index 0000000..9176288
--- /dev/null
+++ b/packages/yew/src/briefcase.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BriefcaseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Briefcase(props: &BriefcaseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 20V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16" />
+            <rect width="20" height="14" x="2" y="6" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/briefcase_business.rs b/packages/yew/src/briefcase_business.rs
new file mode 100644
index 0000000..967c98e
--- /dev/null
+++ b/packages/yew/src/briefcase_business.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BriefcaseBusinessProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BriefcaseBusiness(props: &BriefcaseBusinessProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12h.01" />
+            <path d="M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2" />
+            <path d="M22 13a18.15 18.15 0 0 1-20 0" />
+            <rect width="20" height="14" x="2" y="6" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/briefcase_conveyor_belt.rs b/packages/yew/src/briefcase_conveyor_belt.rs
new file mode 100644
index 0000000..2170294
--- /dev/null
+++ b/packages/yew/src/briefcase_conveyor_belt.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BriefcaseConveyorBeltProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BriefcaseConveyorBelt(props: &BriefcaseConveyorBeltProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 20v2" />
+            <path d="M14 20v2" />
+            <path d="M18 20v2" />
+            <path d="M21 20H3" />
+            <path d="M6 20v2" />
+            <path d="M8 16V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v12" />
+            <rect x="4" y="6" width="16" height="10" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/briefcase_medical.rs b/packages/yew/src/briefcase_medical.rs
new file mode 100644
index 0000000..f428184
--- /dev/null
+++ b/packages/yew/src/briefcase_medical.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BriefcaseMedicalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BriefcaseMedical(props: &BriefcaseMedicalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 11v4" />
+            <path d="M14 13h-4" />
+            <path d="M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2" />
+            <path d="M18 6v14" />
+            <path d="M6 6v14" />
+            <rect width="20" height="14" x="2" y="6" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bring_to_front.rs b/packages/yew/src/bring_to_front.rs
new file mode 100644
index 0000000..708e582
--- /dev/null
+++ b/packages/yew/src/bring_to_front.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BringToFrontProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BringToFront(props: &BringToFrontProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="8" y="8" width="8" height="8" rx="2" />
+            <path d="M4 10a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2" />
+            <path d="M14 20a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/brush.rs b/packages/yew/src/brush.rs
new file mode 100644
index 0000000..4e8993b
--- /dev/null
+++ b/packages/yew/src/brush.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BrushProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Brush(props: &BrushProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9.06 11.9 8.07-8.06a2.85 2.85 0 1 1 4.03 4.03l-8.06 8.08" />
+            <path
+                d="M7.07 14.94c-1.66 0-3 1.35-3 3.02 0 1.33-2.5 1.52-2 2.02 1.08 1.1 2.49 2.02 4 2.02 2.2 0 4-1.8 4-4.04a3.01 3.01 0 0 0-3-3.02z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bug.rs b/packages/yew/src/bug.rs
new file mode 100644
index 0000000..bdc8465
--- /dev/null
+++ b/packages/yew/src/bug.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BugProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bug(props: &BugProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 2 1.88 1.88" />
+            <path d="M14.12 3.88 16 2" />
+            <path d="M9 7.13v-1a3.003 3.003 0 1 1 6 0v1" />
+            <path d="M12 20c-3.3 0-6-2.7-6-6v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 4v3c0 3.3-2.7 6-6 6" />
+            <path d="M12 20v-9" />
+            <path d="M6.53 9C4.6 8.8 3 7.1 3 5" />
+            <path d="M6 13H2" />
+            <path d="M3 21c0-2.1 1.7-3.9 3.8-4" />
+            <path d="M20.97 5c0 2.1-1.6 3.8-3.5 4" />
+            <path d="M22 13h-4" />
+            <path d="M17.2 17c2.1.1 3.8 1.9 3.8 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bug_off.rs b/packages/yew/src/bug_off.rs
new file mode 100644
index 0000000..cfb63c7
--- /dev/null
+++ b/packages/yew/src/bug_off.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BugOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BugOff(props: &BugOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 7.13V6a3 3 0 0 0-5.14-2.1L8 2" />
+            <path d="M14.12 3.88 16 2" />
+            <path d="M22 13h-4v-2a4 4 0 0 0-4-4h-1.3" />
+            <path d="M20.97 5c0 2.1-1.6 3.8-3.5 4" />
+            <path d="m2 2 20 20" />
+            <path d="M7.7 7.7A4 4 0 0 0 6 11v3a6 6 0 0 0 11.13 3.13" />
+            <path d="M12 20v-8" />
+            <path d="M6 13H2" />
+            <path d="M3 21c0-2.1 1.7-3.9 3.8-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bug_play.rs b/packages/yew/src/bug_play.rs
new file mode 100644
index 0000000..cb83d2e
--- /dev/null
+++ b/packages/yew/src/bug_play.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BugPlayProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BugPlay(props: &BugPlayProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12.765 21.522a.5.5 0 0 1-.765-.424v-8.196a.5.5 0 0 1 .765-.424l5.878 3.674a1 1 0 0 1 0 1.696z"
+            />
+            <path d="M14.12 3.88 16 2" />
+            <path d="M18 11a4 4 0 0 0-4-4h-4a4 4 0 0 0-4 4v3a6.1 6.1 0 0 0 2 4.5" />
+            <path d="M20.97 5c0 2.1-1.6 3.8-3.5 4" />
+            <path d="M3 21c0-2.1 1.7-3.9 3.8-4" />
+            <path d="M6 13H2" />
+            <path d="M6.53 9C4.6 8.8 3 7.1 3 5" />
+            <path d="m8 2 1.88 1.88" />
+            <path d="M9 7.13v-1a3.003 3.003 0 1 1 6 0v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/building.rs b/packages/yew/src/building.rs
new file mode 100644
index 0000000..263cb29
--- /dev/null
+++ b/packages/yew/src/building.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BuildingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Building(props: &BuildingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="20" x="4" y="2" rx="2" ry="2" />
+            <path d="M9 22v-4h6v4" />
+            <path d="M8 6h.01" />
+            <path d="M16 6h.01" />
+            <path d="M12 6h.01" />
+            <path d="M12 10h.01" />
+            <path d="M12 14h.01" />
+            <path d="M16 10h.01" />
+            <path d="M16 14h.01" />
+            <path d="M8 10h.01" />
+            <path d="M8 14h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/building_2.rs b/packages/yew/src/building_2.rs
new file mode 100644
index 0000000..f2c6389
--- /dev/null
+++ b/packages/yew/src/building_2.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Building2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Building2(props: &Building2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 22V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v18Z" />
+            <path d="M6 12H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h2" />
+            <path d="M18 9h2a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2h-2" />
+            <path d="M10 6h4" />
+            <path d="M10 10h4" />
+            <path d="M10 14h4" />
+            <path d="M10 18h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bus.rs b/packages/yew/src/bus.rs
new file mode 100644
index 0000000..91e984c
--- /dev/null
+++ b/packages/yew/src/bus.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Bus(props: &BusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 6v6" />
+            <path d="M15 6v6" />
+            <path d="M2 12h19.6" />
+            <path
+                d="M18 18h3s.5-1.7.8-2.8c.1-.4.2-.8.2-1.2 0-.4-.1-.8-.2-1.2l-1.4-5C20.1 6.8 19.1 6 18 6H4a2 2 0 0 0-2 2v10h3"
+            />
+            <circle cx="7" cy="18" r="2" />
+            <path d="M9 18h5" />
+            <circle cx="16" cy="18" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/bus_front.rs b/packages/yew/src/bus_front.rs
new file mode 100644
index 0000000..9b86c08
--- /dev/null
+++ b/packages/yew/src/bus_front.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct BusFrontProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn BusFront(props: &BusFrontProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 6 2 7" />
+            <path d="M10 6h4" />
+            <path d="m22 7-2-1" />
+            <rect width="16" height="16" x="4" y="3" rx="2" />
+            <path d="M4 11h16" />
+            <path d="M8 15h.01" />
+            <path d="M16 15h.01" />
+            <path d="M6 19v2" />
+            <path d="M18 21v-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cable.rs b/packages/yew/src/cable.rs
new file mode 100644
index 0000000..a3c0580
--- /dev/null
+++ b/packages/yew/src/cable.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CableProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cable(props: &CableProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 21v-2a1 1 0 0 1-1-1v-1a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1" />
+            <path d="M19 15V6.5a1 1 0 0 0-7 0v11a1 1 0 0 1-7 0V9" />
+            <path d="M21 21v-2h-4" />
+            <path d="M3 5h4V3" />
+            <path d="M7 5a1 1 0 0 1 1 1v1a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V6a1 1 0 0 1 1-1V3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cable_car.rs b/packages/yew/src/cable_car.rs
new file mode 100644
index 0000000..5698328
--- /dev/null
+++ b/packages/yew/src/cable_car.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CableCarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CableCar(props: &CableCarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 3h.01" />
+            <path d="M14 2h.01" />
+            <path d="m2 9 20-5" />
+            <path d="M12 12V6.5" />
+            <rect width="16" height="10" x="4" y="12" rx="3" />
+            <path d="M9 12v5" />
+            <path d="M15 12v5" />
+            <path d="M4 17h16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cake.rs b/packages/yew/src/cake.rs
new file mode 100644
index 0000000..a5d07e8
--- /dev/null
+++ b/packages/yew/src/cake.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CakeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cake(props: &CakeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 21v-8a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v8" />
+            <path d="M4 16s.5-1 2-1 2.5 2 4 2 2.5-2 4-2 2.5 2 4 2 2-1 2-1" />
+            <path d="M2 21h20" />
+            <path d="M7 8v3" />
+            <path d="M12 8v3" />
+            <path d="M17 8v3" />
+            <path d="M7 4h.01" />
+            <path d="M12 4h.01" />
+            <path d="M17 4h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cake_slice.rs b/packages/yew/src/cake_slice.rs
new file mode 100644
index 0000000..650ce48
--- /dev/null
+++ b/packages/yew/src/cake_slice.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CakeSliceProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CakeSlice(props: &CakeSliceProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="9" cy="7" r="2" />
+            <path d="M7.2 7.9 3 11v9c0 .6.4 1 1 1h16c.6 0 1-.4 1-1v-9c0-2-3-6-7-8l-3.6 2.6" />
+            <path d="M16 13H3" />
+            <path d="M16 17H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calculator.rs b/packages/yew/src/calculator.rs
new file mode 100644
index 0000000..3f96545
--- /dev/null
+++ b/packages/yew/src/calculator.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalculatorProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Calculator(props: &CalculatorProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="20" x="4" y="2" rx="2" />
+            <line x1="8" x2="16" y1="6" y2="6" />
+            <line x1="16" x2="16" y1="14" y2="18" />
+            <path d="M16 10h.01" />
+            <path d="M12 10h.01" />
+            <path d="M8 10h.01" />
+            <path d="M12 14h.01" />
+            <path d="M8 14h.01" />
+            <path d="M12 18h.01" />
+            <path d="M8 18h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar.rs b/packages/yew/src/calendar.rs
new file mode 100644
index 0000000..43b0b1d
--- /dev/null
+++ b/packages/yew/src/calendar.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Calendar(props: &CalendarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <rect width="18" height="18" x="3" y="4" rx="2" />
+            <path d="M3 10h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_1.rs b/packages/yew/src/calendar_1.rs
new file mode 100644
index 0000000..5272dfe
--- /dev/null
+++ b/packages/yew/src/calendar_1.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Calendar1Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Calendar1(props: &Calendar1Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 14h1v4" />
+            <path d="M16 2v4" />
+            <path d="M3 10h18" />
+            <path d="M8 2v4" />
+            <rect x="3" y="4" width="18" height="18" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_arrow_down.rs b/packages/yew/src/calendar_arrow_down.rs
new file mode 100644
index 0000000..9badba1
--- /dev/null
+++ b/packages/yew/src/calendar_arrow_down.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarArrowDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarArrowDown(props: &CalendarArrowDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14 18 4 4 4-4" />
+            <path d="M16 2v4" />
+            <path d="M18 14v8" />
+            <path d="M21 11.354V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7.343" />
+            <path d="M3 10h18" />
+            <path d="M8 2v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_arrow_up.rs b/packages/yew/src/calendar_arrow_up.rs
new file mode 100644
index 0000000..0ccb420
--- /dev/null
+++ b/packages/yew/src/calendar_arrow_up.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarArrowUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarArrowUp(props: &CalendarArrowUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14 18 4-4 4 4" />
+            <path d="M16 2v4" />
+            <path d="M18 22v-8" />
+            <path d="M21 11.343V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h9" />
+            <path d="M3 10h18" />
+            <path d="M8 2v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_check.rs b/packages/yew/src/calendar_check.rs
new file mode 100644
index 0000000..55d63e7
--- /dev/null
+++ b/packages/yew/src/calendar_check.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarCheck(props: &CalendarCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <rect width="18" height="18" x="3" y="4" rx="2" />
+            <path d="M3 10h18" />
+            <path d="m9 16 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_check_2.rs b/packages/yew/src/calendar_check_2.rs
new file mode 100644
index 0000000..53a33f9
--- /dev/null
+++ b/packages/yew/src/calendar_check_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarCheck2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarCheck2(props: &CalendarCheck2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <path d="M21 14V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8" />
+            <path d="M3 10h18" />
+            <path d="m16 20 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_clock.rs b/packages/yew/src/calendar_clock.rs
new file mode 100644
index 0000000..9eb8aa3
--- /dev/null
+++ b/packages/yew/src/calendar_clock.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarClockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarClock(props: &CalendarClockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 7.5V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h3.5" />
+            <path d="M16 2v4" />
+            <path d="M8 2v4" />
+            <path d="M3 10h5" />
+            <path d="M17.5 17.5 16 16.3V14" />
+            <circle cx="16" cy="16" r="6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_cog.rs b/packages/yew/src/calendar_cog.rs
new file mode 100644
index 0000000..3dc0be1
--- /dev/null
+++ b/packages/yew/src/calendar_cog.rs
@@ -0,0 +1,56 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarCog(props: &CalendarCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15.2 16.9-.9-.4" />
+            <path d="m15.2 19.1-.9.4" />
+            <path d="M16 2v4" />
+            <path d="m16.9 15.2-.4-.9" />
+            <path d="m16.9 20.8-.4.9" />
+            <path d="m19.5 14.3-.4.9" />
+            <path d="m19.5 21.7-.4-.9" />
+            <path d="M21 10.5V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6" />
+            <path d="m21.7 16.5-.9.4" />
+            <path d="m21.7 19.5-.9-.4" />
+            <path d="M3 10h18" />
+            <path d="M8 2v4" />
+            <circle cx="18" cy="18" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_days.rs b/packages/yew/src/calendar_days.rs
new file mode 100644
index 0000000..5c448bb
--- /dev/null
+++ b/packages/yew/src/calendar_days.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarDaysProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarDays(props: &CalendarDaysProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <rect width="18" height="18" x="3" y="4" rx="2" />
+            <path d="M3 10h18" />
+            <path d="M8 14h.01" />
+            <path d="M12 14h.01" />
+            <path d="M16 14h.01" />
+            <path d="M8 18h.01" />
+            <path d="M12 18h.01" />
+            <path d="M16 18h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_fold.rs b/packages/yew/src/calendar_fold.rs
new file mode 100644
index 0000000..2da1e82
--- /dev/null
+++ b/packages/yew/src/calendar_fold.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarFoldProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarFold(props: &CalendarFoldProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <path d="M21 17V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h11Z" />
+            <path d="M3 10h18" />
+            <path d="M15 22v-4a2 2 0 0 1 2-2h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_heart.rs b/packages/yew/src/calendar_heart.rs
new file mode 100644
index 0000000..bc536e4
--- /dev/null
+++ b/packages/yew/src/calendar_heart.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarHeartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarHeart(props: &CalendarHeartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 10h18V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7" />
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <path
+                d="M21.29 14.7a2.43 2.43 0 0 0-2.65-.52c-.3.12-.57.3-.8.53l-.34.34-.35-.34a2.43 2.43 0 0 0-2.65-.53c-.3.12-.56.3-.79.53-.95.94-1 2.53.2 3.74L17.5 22l3.6-3.55c1.2-1.21 1.14-2.8.19-3.74Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_minus.rs b/packages/yew/src/calendar_minus.rs
new file mode 100644
index 0000000..770cc41
--- /dev/null
+++ b/packages/yew/src/calendar_minus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarMinus(props: &CalendarMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 19h6" />
+            <path d="M16 2v4" />
+            <path d="M21 15V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8.5" />
+            <path d="M3 10h18" />
+            <path d="M8 2v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_minus_2.rs b/packages/yew/src/calendar_minus_2.rs
new file mode 100644
index 0000000..fc4e537
--- /dev/null
+++ b/packages/yew/src/calendar_minus_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarMinus2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarMinus2(props: &CalendarMinus2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <rect width="18" height="18" x="3" y="4" rx="2" />
+            <path d="M3 10h18" />
+            <path d="M10 16h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_off.rs b/packages/yew/src/calendar_off.rs
new file mode 100644
index 0000000..bb3a93e
--- /dev/null
+++ b/packages/yew/src/calendar_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarOff(props: &CalendarOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.2 4.2A2 2 0 0 0 3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 1.82-1.18" />
+            <path d="M21 15.5V6a2 2 0 0 0-2-2H9.5" />
+            <path d="M16 2v4" />
+            <path d="M3 10h7" />
+            <path d="M21 10h-5.5" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_plus.rs b/packages/yew/src/calendar_plus.rs
new file mode 100644
index 0000000..8779338
--- /dev/null
+++ b/packages/yew/src/calendar_plus.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarPlus(props: &CalendarPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <path d="M21 13V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8" />
+            <path d="M3 10h18" />
+            <path d="M16 19h6" />
+            <path d="M19 16v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_plus_2.rs b/packages/yew/src/calendar_plus_2.rs
new file mode 100644
index 0000000..afeda7d
--- /dev/null
+++ b/packages/yew/src/calendar_plus_2.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarPlus2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarPlus2(props: &CalendarPlus2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <rect width="18" height="18" x="3" y="4" rx="2" />
+            <path d="M3 10h18" />
+            <path d="M10 16h4" />
+            <path d="M12 14v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_range.rs b/packages/yew/src/calendar_range.rs
new file mode 100644
index 0000000..f50deba
--- /dev/null
+++ b/packages/yew/src/calendar_range.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarRangeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarRange(props: &CalendarRangeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="4" rx="2" />
+            <path d="M16 2v4" />
+            <path d="M3 10h18" />
+            <path d="M8 2v4" />
+            <path d="M17 14h-6" />
+            <path d="M13 18H7" />
+            <path d="M7 14h.01" />
+            <path d="M17 18h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_search.rs b/packages/yew/src/calendar_search.rs
new file mode 100644
index 0000000..20ec5a9
--- /dev/null
+++ b/packages/yew/src/calendar_search.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarSearch(props: &CalendarSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 2v4" />
+            <path d="M21 11.75V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7.25" />
+            <path d="m22 22-1.875-1.875" />
+            <path d="M3 10h18" />
+            <path d="M8 2v4" />
+            <circle cx="18" cy="18" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_x.rs b/packages/yew/src/calendar_x.rs
new file mode 100644
index 0000000..0db6b44
--- /dev/null
+++ b/packages/yew/src/calendar_x.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarX(props: &CalendarXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <rect width="18" height="18" x="3" y="4" rx="2" />
+            <path d="M3 10h18" />
+            <path d="m14 14-4 4" />
+            <path d="m10 14 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/calendar_x_2.rs b/packages/yew/src/calendar_x_2.rs
new file mode 100644
index 0000000..05c8203
--- /dev/null
+++ b/packages/yew/src/calendar_x_2.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CalendarX2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CalendarX2(props: &CalendarX2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M16 2v4" />
+            <path d="M21 13V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8" />
+            <path d="M3 10h18" />
+            <path d="m17 22 5-5" />
+            <path d="m17 17 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/camera.rs b/packages/yew/src/camera.rs
new file mode 100644
index 0000000..7eaf25f
--- /dev/null
+++ b/packages/yew/src/camera.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CameraProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Camera(props: &CameraProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M14.5 4h-5L7 7H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-3l-2.5-3z"
+            />
+            <circle cx="12" cy="13" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/camera_off.rs b/packages/yew/src/camera_off.rs
new file mode 100644
index 0000000..6162e49
--- /dev/null
+++ b/packages/yew/src/camera_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CameraOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CameraOff(props: &CameraOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="22" y1="2" y2="22" />
+            <path d="M7 7H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h16" />
+            <path d="M9.5 4h5L17 7h3a2 2 0 0 1 2 2v7.5" />
+            <path d="M14.121 15.121A3 3 0 1 1 9.88 10.88" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/candy.rs b/packages/yew/src/candy.rs
new file mode 100644
index 0000000..1545eb2
--- /dev/null
+++ b/packages/yew/src/candy.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CandyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Candy(props: &CandyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9.5 7.5-2 2a4.95 4.95 0 1 0 7 7l2-2a4.95 4.95 0 1 0-7-7Z" />
+            <path d="M14 6.5v10" />
+            <path d="M10 7.5v10" />
+            <path d="m16 7 1-5 1.37.68A3 3 0 0 0 19.7 3H21v1.3c0 .46.1.92.32 1.33L22 7l-5 1" />
+            <path d="m8 17-1 5-1.37-.68A3 3 0 0 0 4.3 21H3v-1.3a3 3 0 0 0-.32-1.33L2 17l5-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/candy_cane.rs b/packages/yew/src/candy_cane.rs
new file mode 100644
index 0000000..457c23a
--- /dev/null
+++ b/packages/yew/src/candy_cane.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CandyCaneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CandyCane(props: &CandyCaneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M5.7 21a2 2 0 0 1-3.5-2l8.6-14a6 6 0 0 1 10.4 6 2 2 0 1 1-3.464-2 2 2 0 1 0-3.464-2Z"
+            />
+            <path d="M17.75 7 15 2.1" />
+            <path d="M10.9 4.8 13 9" />
+            <path d="m7.9 9.7 2 4.4" />
+            <path d="M4.9 14.7 7 18.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/candy_off.rs b/packages/yew/src/candy_off.rs
new file mode 100644
index 0000000..427a4dc
--- /dev/null
+++ b/packages/yew/src/candy_off.rs
@@ -0,0 +1,55 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CandyOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CandyOff(props: &CandyOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8.5 8.5-1 1a4.95 4.95 0 0 0 7 7l1-1" />
+            <path d="M11.843 6.187A4.947 4.947 0 0 1 16.5 7.5a4.947 4.947 0 0 1 1.313 4.657" />
+            <path d="M14 16.5V14" />
+            <path d="M14 6.5v1.843" />
+            <path d="M10 10v7.5" />
+            <path
+                d="m16 7 1-5 1.367.683A3 3 0 0 0 19.708 3H21v1.292a3 3 0 0 0 .317 1.341L22 7l-5 1"
+            />
+            <path
+                d="m8 17-1 5-1.367-.683A3 3 0 0 0 4.292 21H3v-1.292a3 3 0 0 0-.317-1.341L2 17l5-1"
+            />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cannabis.rs b/packages/yew/src/cannabis.rs
new file mode 100644
index 0000000..b7ab609
--- /dev/null
+++ b/packages/yew/src/cannabis.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CannabisProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cannabis(props: &CannabisProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-4" />
+            <path
+                d="M7 12c-1.5 0-4.5 1.5-5 3 3.5 1.5 6 1 6 1-1.5 1.5-2 3.5-2 5 2.5 0 4.5-1.5 6-3 1.5 1.5 3.5 3 6 3 0-1.5-.5-3.5-2-5 0 0 2.5.5 6-1-.5-1.5-3.5-3-5-3 1.5-1 4-4 4-6-2.5 0-5.5 1.5-7 3 0-2.5-.5-5-2-7-1.5 2-2 4.5-2 7-1.5-1.5-4.5-3-7-3 0 2 2.5 5 4 6"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/captions.rs b/packages/yew/src/captions.rs
new file mode 100644
index 0000000..bae3792
--- /dev/null
+++ b/packages/yew/src/captions.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CaptionsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Captions(props: &CaptionsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="14" x="3" y="5" rx="2" ry="2" />
+            <path d="M7 15h4M15 15h2M7 11h2M13 11h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/captions_off.rs b/packages/yew/src/captions_off.rs
new file mode 100644
index 0000000..3999df8
--- /dev/null
+++ b/packages/yew/src/captions_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CaptionsOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CaptionsOff(props: &CaptionsOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.5 5H19a2 2 0 0 1 2 2v8.5" />
+            <path d="M17 11h-.5" />
+            <path d="M19 19H5a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2" />
+            <path d="m2 2 20 20" />
+            <path d="M7 11h4" />
+            <path d="M7 15h2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/car.rs b/packages/yew/src/car.rs
new file mode 100644
index 0000000..32b5d19
--- /dev/null
+++ b/packages/yew/src/car.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Car(props: &CarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19 17h2c.6 0 1-.4 1-1v-3c0-.9-.7-1.7-1.5-1.9C18.7 10.6 16 10 16 10s-1.3-1.4-2.2-2.3c-.5-.4-1.1-.7-1.8-.7H5c-.6 0-1.1.4-1.4.9l-1.4 2.9A3.7 3.7 0 0 0 2 12v4c0 .6.4 1 1 1h2"
+            />
+            <circle cx="7" cy="17" r="2" />
+            <path d="M9 17h6" />
+            <circle cx="17" cy="17" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/car_front.rs b/packages/yew/src/car_front.rs
new file mode 100644
index 0000000..534b79f
--- /dev/null
+++ b/packages/yew/src/car_front.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CarFrontProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CarFront(props: &CarFrontProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8" />
+            <path d="M7 14h.01" />
+            <path d="M17 14h.01" />
+            <rect width="18" height="8" x="3" y="10" rx="2" />
+            <path d="M5 18v2" />
+            <path d="M19 18v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/car_taxi_front.rs b/packages/yew/src/car_taxi_front.rs
new file mode 100644
index 0000000..13e4148
--- /dev/null
+++ b/packages/yew/src/car_taxi_front.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CarTaxiFrontProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CarTaxiFront(props: &CarTaxiFrontProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2h4" />
+            <path d="m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8" />
+            <path d="M7 14h.01" />
+            <path d="M17 14h.01" />
+            <rect width="18" height="8" x="3" y="10" rx="2" />
+            <path d="M5 18v2" />
+            <path d="M19 18v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/caravan.rs b/packages/yew/src/caravan.rs
new file mode 100644
index 0000000..b61859e
--- /dev/null
+++ b/packages/yew/src/caravan.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CaravanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Caravan(props: &CaravanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 19V9a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v8a2 2 0 0 0 2 2h2" />
+            <path d="M2 9h3a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1H2" />
+            <path d="M22 17v1a1 1 0 0 1-1 1H10v-9a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v9" />
+            <circle cx="8" cy="19" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/carrot.rs b/packages/yew/src/carrot.rs
new file mode 100644
index 0000000..138c003
--- /dev/null
+++ b/packages/yew/src/carrot.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CarrotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Carrot(props: &CarrotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.27 21.7s9.87-3.5 12.73-6.36a4.5 4.5 0 0 0-6.36-6.37C5.77 11.84 2.27 21.7 2.27 21.7zM8.64 14l-2.05-2.04M15.34 15l-2.46-2.46"
+            />
+            <path d="M22 9s-1.33-2-3.5-2C16.86 7 15 9 15 9s1.33 2 3.5 2S22 9 22 9z" />
+            <path d="M15 2s-2 1.33-2 3.5S15 9 15 9s2-1.84 2-3.5C17 3.33 15 2 15 2z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/case_lower.rs b/packages/yew/src/case_lower.rs
new file mode 100644
index 0000000..a973189
--- /dev/null
+++ b/packages/yew/src/case_lower.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CaseLowerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CaseLower(props: &CaseLowerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="7" cy="12" r="3" />
+            <path d="M10 9v6" />
+            <circle cx="17" cy="12" r="3" />
+            <path d="M14 7v8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/case_sensitive.rs b/packages/yew/src/case_sensitive.rs
new file mode 100644
index 0000000..9998a78
--- /dev/null
+++ b/packages/yew/src/case_sensitive.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CaseSensitiveProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CaseSensitive(props: &CaseSensitiveProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 15 4-8 4 8" />
+            <path d="M4 13h6" />
+            <circle cx="18" cy="12" r="3" />
+            <path d="M21 9v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/case_upper.rs b/packages/yew/src/case_upper.rs
new file mode 100644
index 0000000..6648167
--- /dev/null
+++ b/packages/yew/src/case_upper.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CaseUpperProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CaseUpper(props: &CaseUpperProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 15 4-8 4 8" />
+            <path d="M4 13h6" />
+            <path d="M15 11h4.5a2 2 0 0 1 0 4H15V7h4a2 2 0 0 1 0 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cassette_tape.rs b/packages/yew/src/cassette_tape.rs
new file mode 100644
index 0000000..f2ece3a
--- /dev/null
+++ b/packages/yew/src/cassette_tape.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CassetteTapeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CassetteTape(props: &CassetteTapeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+            <circle cx="8" cy="10" r="2" />
+            <path d="M8 12h8" />
+            <circle cx="16" cy="10" r="2" />
+            <path d="m6 20 .7-2.9A1.4 1.4 0 0 1 8.1 16h7.8a1.4 1.4 0 0 1 1.4 1l.7 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cast.rs b/packages/yew/src/cast.rs
new file mode 100644
index 0000000..125a911
--- /dev/null
+++ b/packages/yew/src/cast.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CastProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cast(props: &CastProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6" />
+            <path d="M2 12a9 9 0 0 1 8 8" />
+            <path d="M2 16a5 5 0 0 1 4 4" />
+            <line x1="2" x2="2.01" y1="20" y2="20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/castle.rs b/packages/yew/src/castle.rs
new file mode 100644
index 0000000..ba8cb15
--- /dev/null
+++ b/packages/yew/src/castle.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CastleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Castle(props: &CastleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 20v-9H2v9a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2Z" />
+            <path d="M18 11V4H6v7" />
+            <path d="M15 22v-4a3 3 0 0 0-3-3a3 3 0 0 0-3 3v4" />
+            <path d="M22 11V9" />
+            <path d="M2 11V9" />
+            <path d="M6 4V2" />
+            <path d="M18 4V2" />
+            <path d="M10 4V2" />
+            <path d="M14 4V2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cat.rs b/packages/yew/src/cat.rs
new file mode 100644
index 0000000..a614755
--- /dev/null
+++ b/packages/yew/src/cat.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CatProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cat(props: &CatProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 5c.67 0 1.35.09 2 .26 1.78-2 5.03-2.84 6.42-2.26 1.4.58-.42 7-.42 7 .57 1.07 1 2.24 1 3.44C21 17.9 16.97 21 12 21s-9-3-9-7.56c0-1.25.5-2.4 1-3.44 0 0-1.89-6.42-.5-7 1.39-.58 4.72.23 6.5 2.23A9.04 9.04 0 0 1 12 5Z"
+            />
+            <path d="M8 14v.5" />
+            <path d="M16 14v.5" />
+            <path d="M11.25 16.25h1.5L12 17l-.75-.75Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cctv.rs b/packages/yew/src/cctv.rs
new file mode 100644
index 0000000..cdca347
--- /dev/null
+++ b/packages/yew/src/cctv.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CctvProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cctv(props: &CctvProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M16.75 12h3.632a1 1 0 0 1 .894 1.447l-2.034 4.069a1 1 0 0 1-1.708.134l-2.124-2.97"
+            />
+            <path
+                d="M17.106 9.053a1 1 0 0 1 .447 1.341l-3.106 6.211a1 1 0 0 1-1.342.447L3.61 12.3a2.92 2.92 0 0 1-1.3-3.91L3.69 5.6a2.92 2.92 0 0 1 3.92-1.3z"
+            />
+            <path d="M2 19h3.76a2 2 0 0 0 1.8-1.1L9 15" />
+            <path d="M2 21v-4" />
+            <path d="M7 9h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_area.rs b/packages/yew/src/chart_area.rs
new file mode 100644
index 0000000..5a94135
--- /dev/null
+++ b/packages/yew/src/chart_area.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartAreaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartArea(props: &ChartAreaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path
+                d="M7 11.207a.5.5 0 0 1 .146-.353l2-2a.5.5 0 0 1 .708 0l3.292 3.292a.5.5 0 0 0 .708 0l4.292-4.292a.5.5 0 0 1 .854.353V16a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_bar.rs b/packages/yew/src/chart_bar.rs
new file mode 100644
index 0000000..0eea55a
--- /dev/null
+++ b/packages/yew/src/chart_bar.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartBarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartBar(props: &ChartBarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="M7 16h8" />
+            <path d="M7 11h12" />
+            <path d="M7 6h3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_bar_big.rs b/packages/yew/src/chart_bar_big.rs
new file mode 100644
index 0000000..339e204
--- /dev/null
+++ b/packages/yew/src/chart_bar_big.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartBarBigProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartBarBig(props: &ChartBarBigProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <rect x="7" y="13" width="9" height="4" rx="1" />
+            <rect x="7" y="5" width="12" height="4" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_bar_decreasing.rs b/packages/yew/src/chart_bar_decreasing.rs
new file mode 100644
index 0000000..f2882fa
--- /dev/null
+++ b/packages/yew/src/chart_bar_decreasing.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartBarDecreasingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartBarDecreasing(props: &ChartBarDecreasingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="M7 11h8" />
+            <path d="M7 16h3" />
+            <path d="M7 6h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_bar_increasing.rs b/packages/yew/src/chart_bar_increasing.rs
new file mode 100644
index 0000000..806f448
--- /dev/null
+++ b/packages/yew/src/chart_bar_increasing.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartBarIncreasingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartBarIncreasing(props: &ChartBarIncreasingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="M7 11h8" />
+            <path d="M7 16h12" />
+            <path d="M7 6h3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_bar_stacked.rs b/packages/yew/src/chart_bar_stacked.rs
new file mode 100644
index 0000000..846a5ba
--- /dev/null
+++ b/packages/yew/src/chart_bar_stacked.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartBarStackedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartBarStacked(props: &ChartBarStackedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 13v4" />
+            <path d="M15 5v4" />
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <rect x="7" y="13" width="9" height="4" rx="1" />
+            <rect x="7" y="5" width="12" height="4" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_candlestick.rs b/packages/yew/src/chart_candlestick.rs
new file mode 100644
index 0000000..d79d23d
--- /dev/null
+++ b/packages/yew/src/chart_candlestick.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartCandlestickProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartCandlestick(props: &ChartCandlestickProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 5v4" />
+            <rect width="4" height="6" x="7" y="9" rx="1" />
+            <path d="M9 15v2" />
+            <path d="M17 3v2" />
+            <rect width="4" height="8" x="15" y="5" rx="1" />
+            <path d="M17 13v3" />
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_column.rs b/packages/yew/src/chart_column.rs
new file mode 100644
index 0000000..1a10926
--- /dev/null
+++ b/packages/yew/src/chart_column.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartColumnProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartColumn(props: &ChartColumnProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="M18 17V9" />
+            <path d="M13 17V5" />
+            <path d="M8 17v-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_column_big.rs b/packages/yew/src/chart_column_big.rs
new file mode 100644
index 0000000..0b00529
--- /dev/null
+++ b/packages/yew/src/chart_column_big.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartColumnBigProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartColumnBig(props: &ChartColumnBigProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <rect x="15" y="5" width="4" height="12" rx="1" />
+            <rect x="7" y="8" width="4" height="9" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_column_decreasing.rs b/packages/yew/src/chart_column_decreasing.rs
new file mode 100644
index 0000000..72b14e3
--- /dev/null
+++ b/packages/yew/src/chart_column_decreasing.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartColumnDecreasingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartColumnDecreasing(props: &ChartColumnDecreasingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 17V9" />
+            <path d="M18 17v-3" />
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="M8 17V5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_column_increasing.rs b/packages/yew/src/chart_column_increasing.rs
new file mode 100644
index 0000000..c79006f
--- /dev/null
+++ b/packages/yew/src/chart_column_increasing.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartColumnIncreasingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartColumnIncreasing(props: &ChartColumnIncreasingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 17V9" />
+            <path d="M18 17V5" />
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="M8 17v-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_column_stacked.rs b/packages/yew/src/chart_column_stacked.rs
new file mode 100644
index 0000000..cfc0ac8
--- /dev/null
+++ b/packages/yew/src/chart_column_stacked.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartColumnStackedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartColumnStacked(props: &ChartColumnStackedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 13H7" />
+            <path d="M19 9h-4" />
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <rect x="15" y="5" width="4" height="12" rx="1" />
+            <rect x="7" y="8" width="4" height="9" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_gantt.rs b/packages/yew/src/chart_gantt.rs
new file mode 100644
index 0000000..336c063
--- /dev/null
+++ b/packages/yew/src/chart_gantt.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartGanttProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartGantt(props: &ChartGanttProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 6h8" />
+            <path d="M12 16h6" />
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="M8 11h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_line.rs b/packages/yew/src/chart_line.rs
new file mode 100644
index 0000000..dca0ab2
--- /dev/null
+++ b/packages/yew/src/chart_line.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartLine(props: &ChartLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="m19 9-5 5-4-4-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_network.rs b/packages/yew/src/chart_network.rs
new file mode 100644
index 0000000..5d4cb0c
--- /dev/null
+++ b/packages/yew/src/chart_network.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartNetworkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartNetwork(props: &ChartNetworkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m13.11 7.664 1.78 2.672" />
+            <path d="m14.162 12.788-3.324 1.424" />
+            <path d="m20 4-6.06 1.515" />
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <circle cx="12" cy="6" r="2" />
+            <circle cx="16" cy="12" r="2" />
+            <circle cx="9" cy="15" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_no_axes_column.rs b/packages/yew/src/chart_no_axes_column.rs
new file mode 100644
index 0000000..eefb822
--- /dev/null
+++ b/packages/yew/src/chart_no_axes_column.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartNoAxesColumnProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartNoAxesColumn(props: &ChartNoAxesColumnProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="18" x2="18" y1="20" y2="10" />
+            <line x1="12" x2="12" y1="20" y2="4" />
+            <line x1="6" x2="6" y1="20" y2="14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_no_axes_column_decreasing.rs b/packages/yew/src/chart_no_axes_column_decreasing.rs
new file mode 100644
index 0000000..0fed102
--- /dev/null
+++ b/packages/yew/src/chart_no_axes_column_decreasing.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartNoAxesColumnDecreasingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartNoAxesColumnDecreasing(props: &ChartNoAxesColumnDecreasingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20V10" />
+            <path d="M18 20v-4" />
+            <path d="M6 20V4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_no_axes_column_increasing.rs b/packages/yew/src/chart_no_axes_column_increasing.rs
new file mode 100644
index 0000000..55df28c
--- /dev/null
+++ b/packages/yew/src/chart_no_axes_column_increasing.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartNoAxesColumnIncreasingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartNoAxesColumnIncreasing(props: &ChartNoAxesColumnIncreasingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="12" y1="20" y2="10" />
+            <line x1="18" x2="18" y1="20" y2="4" />
+            <line x1="6" x2="6" y1="20" y2="16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_no_axes_combined.rs b/packages/yew/src/chart_no_axes_combined.rs
new file mode 100644
index 0000000..5df34ce
--- /dev/null
+++ b/packages/yew/src/chart_no_axes_combined.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartNoAxesCombinedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartNoAxesCombined(props: &ChartNoAxesCombinedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 16v5" />
+            <path d="M16 14v7" />
+            <path d="M20 10v11" />
+            <path d="m22 3-8.646 8.646a.5.5 0 0 1-.708 0L9.354 8.354a.5.5 0 0 0-.707 0L2 15" />
+            <path d="M4 18v3" />
+            <path d="M8 14v7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_no_axes_gantt.rs b/packages/yew/src/chart_no_axes_gantt.rs
new file mode 100644
index 0000000..2f5e700
--- /dev/null
+++ b/packages/yew/src/chart_no_axes_gantt.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartNoAxesGanttProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartNoAxesGantt(props: &ChartNoAxesGanttProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 6h10" />
+            <path d="M6 12h9" />
+            <path d="M11 18h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_pie.rs b/packages/yew/src/chart_pie.rs
new file mode 100644
index 0000000..78a9a45
--- /dev/null
+++ b/packages/yew/src/chart_pie.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartPieProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartPie(props: &ChartPieProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21 12c.552 0 1.005-.449.95-.998a10 10 0 0 0-8.953-8.951c-.55-.055-.998.398-.998.95v8a1 1 0 0 0 1 1z"
+            />
+            <path d="M21.21 15.89A10 10 0 1 1 8 2.83" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_scatter.rs b/packages/yew/src/chart_scatter.rs
new file mode 100644
index 0000000..672f7eb
--- /dev/null
+++ b/packages/yew/src/chart_scatter.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartScatterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartScatter(props: &ChartScatterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="7.5" cy="7.5" r=".5" fill="currentColor" />
+            <circle cx="18.5" cy="5.5" r=".5" fill="currentColor" />
+            <circle cx="11.5" cy="11.5" r=".5" fill="currentColor" />
+            <circle cx="7.5" cy="16.5" r=".5" fill="currentColor" />
+            <circle cx="17.5" cy="14.5" r=".5" fill="currentColor" />
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chart_spline.rs b/packages/yew/src/chart_spline.rs
new file mode 100644
index 0000000..9e8fefe
--- /dev/null
+++ b/packages/yew/src/chart_spline.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChartSplineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChartSpline(props: &ChartSplineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3v16a2 2 0 0 0 2 2h16" />
+            <path d="M7 16c.5-2 1.5-7 4-7 2 0 2 3 4 3 2.5 0 4.5-5 5-7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/check.rs b/packages/yew/src/check.rs
new file mode 100644
index 0000000..33fda25
--- /dev/null
+++ b/packages/yew/src/check.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Check(props: &CheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 6 9 17l-5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/check_check.rs b/packages/yew/src/check_check.rs
new file mode 100644
index 0000000..0649ab1
--- /dev/null
+++ b/packages/yew/src/check_check.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CheckCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CheckCheck(props: &CheckCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 6 7 17l-5-5" />
+            <path d="m22 10-7.5 7.5L13 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chef_hat.rs b/packages/yew/src/chef_hat.rs
new file mode 100644
index 0000000..35c0141
--- /dev/null
+++ b/packages/yew/src/chef_hat.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChefHatProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChefHat(props: &ChefHatProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M17 21a1 1 0 0 0 1-1v-5.35c0-.457.316-.844.727-1.041a4 4 0 0 0-2.134-7.589 5 5 0 0 0-9.186 0 4 4 0 0 0-2.134 7.588c.411.198.727.585.727 1.041V20a1 1 0 0 0 1 1Z"
+            />
+            <path d="M6 17h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cherry.rs b/packages/yew/src/cherry.rs
new file mode 100644
index 0000000..2133b5e
--- /dev/null
+++ b/packages/yew/src/cherry.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CherryProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cherry(props: &CherryProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 17a5 5 0 0 0 10 0c0-2.76-2.5-5-5-3-2.5-2-5 .24-5 3Z" />
+            <path d="M12 17a5 5 0 0 0 10 0c0-2.76-2.5-5-5-3-2.5-2-5 .24-5 3Z" />
+            <path d="M7 14c3.22-2.91 4.29-8.75 5-12 1.66 2.38 4.94 9 5 12" />
+            <path d="M22 9c-4.29 0-7.14-2.33-10-7 5.71 0 10 4.67 10 7Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevron_down.rs b/packages/yew/src/chevron_down.rs
new file mode 100644
index 0000000..63ad704
--- /dev/null
+++ b/packages/yew/src/chevron_down.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronDown(props: &ChevronDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 9 6 6 6-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevron_first.rs b/packages/yew/src/chevron_first.rs
new file mode 100644
index 0000000..51845a0
--- /dev/null
+++ b/packages/yew/src/chevron_first.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronFirstProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronFirst(props: &ChevronFirstProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 18-6-6 6-6" />
+            <path d="M7 6v12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevron_last.rs b/packages/yew/src/chevron_last.rs
new file mode 100644
index 0000000..144af5d
--- /dev/null
+++ b/packages/yew/src/chevron_last.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronLastProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronLast(props: &ChevronLastProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 18 6-6-6-6" />
+            <path d="M17 6v12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevron_left.rs b/packages/yew/src/chevron_left.rs
new file mode 100644
index 0000000..5408883
--- /dev/null
+++ b/packages/yew/src/chevron_left.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronLeft(props: &ChevronLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 18-6-6 6-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevron_right.rs b/packages/yew/src/chevron_right.rs
new file mode 100644
index 0000000..4b6ce71
--- /dev/null
+++ b/packages/yew/src/chevron_right.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronRight(props: &ChevronRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 18 6-6-6-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevron_up.rs b/packages/yew/src/chevron_up.rs
new file mode 100644
index 0000000..e02d2b5
--- /dev/null
+++ b/packages/yew/src/chevron_up.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronUp(props: &ChevronUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 15-6-6-6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_down.rs b/packages/yew/src/chevrons_down.rs
new file mode 100644
index 0000000..84b53e9
--- /dev/null
+++ b/packages/yew/src/chevrons_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsDown(props: &ChevronsDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 6 5 5 5-5" />
+            <path d="m7 13 5 5 5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_down_up.rs b/packages/yew/src/chevrons_down_up.rs
new file mode 100644
index 0000000..6556e9c
--- /dev/null
+++ b/packages/yew/src/chevrons_down_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsDownUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsDownUp(props: &ChevronsDownUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 20 5-5 5 5" />
+            <path d="m7 4 5 5 5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_left.rs b/packages/yew/src/chevrons_left.rs
new file mode 100644
index 0000000..a185791
--- /dev/null
+++ b/packages/yew/src/chevrons_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsLeft(props: &ChevronsLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11 17-5-5 5-5" />
+            <path d="m18 17-5-5 5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_left_right.rs b/packages/yew/src/chevrons_left_right.rs
new file mode 100644
index 0000000..e449971
--- /dev/null
+++ b/packages/yew/src/chevrons_left_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsLeftRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsLeftRight(props: &ChevronsLeftRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 7-5 5 5 5" />
+            <path d="m15 7 5 5-5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_left_right_ellipsis.rs b/packages/yew/src/chevrons_left_right_ellipsis.rs
new file mode 100644
index 0000000..04a7353
--- /dev/null
+++ b/packages/yew/src/chevrons_left_right_ellipsis.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsLeftRightEllipsisProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsLeftRightEllipsis(props: &ChevronsLeftRightEllipsisProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 8 4 4-4 4" />
+            <path d="m6 8-4 4 4 4" />
+            <path d="M8 12h.01" />
+            <path d="M12 12h.01" />
+            <path d="M16 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_right.rs b/packages/yew/src/chevrons_right.rs
new file mode 100644
index 0000000..90f2000
--- /dev/null
+++ b/packages/yew/src/chevrons_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsRight(props: &ChevronsRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 17 5-5-5-5" />
+            <path d="m13 17 5-5-5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_right_left.rs b/packages/yew/src/chevrons_right_left.rs
new file mode 100644
index 0000000..1332241
--- /dev/null
+++ b/packages/yew/src/chevrons_right_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsRightLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsRightLeft(props: &ChevronsRightLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m20 17-5-5 5-5" />
+            <path d="m4 17 5-5-5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_up.rs b/packages/yew/src/chevrons_up.rs
new file mode 100644
index 0000000..0934e25
--- /dev/null
+++ b/packages/yew/src/chevrons_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsUp(props: &ChevronsUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 11-5-5-5 5" />
+            <path d="m17 18-5-5-5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chevrons_up_down.rs b/packages/yew/src/chevrons_up_down.rs
new file mode 100644
index 0000000..614ffeb
--- /dev/null
+++ b/packages/yew/src/chevrons_up_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChevronsUpDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ChevronsUpDown(props: &ChevronsUpDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 15 5 5 5-5" />
+            <path d="m7 9 5-5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/chrome.rs b/packages/yew/src/chrome.rs
new file mode 100644
index 0000000..e01c049
--- /dev/null
+++ b/packages/yew/src/chrome.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChromeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Chrome(props: &ChromeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <circle cx="12" cy="12" r="4" />
+            <line x1="21.17" x2="12" y1="8" y2="8" />
+            <line x1="3.95" x2="8.54" y1="6.06" y2="14" />
+            <line x1="10.88" x2="15.46" y1="21.94" y2="14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/church.rs b/packages/yew/src/church.rs
new file mode 100644
index 0000000..64de36e
--- /dev/null
+++ b/packages/yew/src/church.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ChurchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Church(props: &ChurchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9h4" />
+            <path d="M12 7v5" />
+            <path d="M14 22v-4a2 2 0 0 0-4 0v4" />
+            <path
+                d="M18 22V5.618a1 1 0 0 0-.553-.894l-4.553-2.277a2 2 0 0 0-1.788 0L6.553 4.724A1 1 0 0 0 6 5.618V22"
+            />
+            <path
+                d="m18 7 3.447 1.724a1 1 0 0 1 .553.894V20a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9.618a1 1 0 0 1 .553-.894L6 7"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cigarette.rs b/packages/yew/src/cigarette.rs
new file mode 100644
index 0000000..952df7e
--- /dev/null
+++ b/packages/yew/src/cigarette.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CigaretteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cigarette(props: &CigaretteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 12H3a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h14" />
+            <path d="M18 8c0-2.5-2-2.5-2-5" />
+            <path d="M21 16a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1" />
+            <path d="M22 8c0-2.5-2-2.5-2-5" />
+            <path d="M7 12v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cigarette_off.rs b/packages/yew/src/cigarette_off.rs
new file mode 100644
index 0000000..f7a6c15
--- /dev/null
+++ b/packages/yew/src/cigarette_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CigaretteOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CigaretteOff(props: &CigaretteOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12H3a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h13" />
+            <path d="M18 8c0-2.5-2-2.5-2-5" />
+            <path d="m2 2 20 20" />
+            <path d="M21 12a1 1 0 0 1 1 1v2a1 1 0 0 1-.5.866" />
+            <path d="M22 8c0-2.5-2-2.5-2-5" />
+            <path d="M7 12v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle.rs b/packages/yew/src/circle.rs
new file mode 100644
index 0000000..44f0e93
--- /dev/null
+++ b/packages/yew/src/circle.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Circle(props: &CircleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_alert.rs b/packages/yew/src/circle_alert.rs
new file mode 100644
index 0000000..c739ad8
--- /dev/null
+++ b/packages/yew/src/circle_alert.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleAlertProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleAlert(props: &CircleAlertProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <line x1="12" x2="12" y1="8" y2="12" />
+            <line x1="12" x2="12.01" y1="16" y2="16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_arrow_down.rs b/packages/yew/src/circle_arrow_down.rs
new file mode 100644
index 0000000..0637e90
--- /dev/null
+++ b/packages/yew/src/circle_arrow_down.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleArrowDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleArrowDown(props: &CircleArrowDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M12 8v8" />
+            <path d="m8 12 4 4 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_arrow_left.rs b/packages/yew/src/circle_arrow_left.rs
new file mode 100644
index 0000000..a1f56b9
--- /dev/null
+++ b/packages/yew/src/circle_arrow_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleArrowLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleArrowLeft(props: &CircleArrowLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M16 12H8" />
+            <path d="m12 8-4 4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_arrow_out_down_left.rs b/packages/yew/src/circle_arrow_out_down_left.rs
new file mode 100644
index 0000000..501ce14
--- /dev/null
+++ b/packages/yew/src/circle_arrow_out_down_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleArrowOutDownLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleArrowOutDownLeft(props: &CircleArrowOutDownLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12a10 10 0 1 1 10 10" />
+            <path d="m2 22 10-10" />
+            <path d="M8 22H2v-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_arrow_out_down_right.rs b/packages/yew/src/circle_arrow_out_down_right.rs
new file mode 100644
index 0000000..121be13
--- /dev/null
+++ b/packages/yew/src/circle_arrow_out_down_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleArrowOutDownRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleArrowOutDownRight(props: &CircleArrowOutDownRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22a10 10 0 1 1 10-10" />
+            <path d="M22 22 12 12" />
+            <path d="M22 16v6h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_arrow_out_up_left.rs b/packages/yew/src/circle_arrow_out_up_left.rs
new file mode 100644
index 0000000..271b2cb
--- /dev/null
+++ b/packages/yew/src/circle_arrow_out_up_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleArrowOutUpLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleArrowOutUpLeft(props: &CircleArrowOutUpLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 8V2h6" />
+            <path d="m2 2 10 10" />
+            <path d="M12 2A10 10 0 1 1 2 12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_arrow_out_up_right.rs b/packages/yew/src/circle_arrow_out_up_right.rs
new file mode 100644
index 0000000..8ae884d
--- /dev/null
+++ b/packages/yew/src/circle_arrow_out_up_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleArrowOutUpRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleArrowOutUpRight(props: &CircleArrowOutUpRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12A10 10 0 1 1 12 2" />
+            <path d="M22 2 12 12" />
+            <path d="M16 2h6v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_arrow_right.rs b/packages/yew/src/circle_arrow_right.rs
new file mode 100644
index 0000000..8e5a746
--- /dev/null
+++ b/packages/yew/src/circle_arrow_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleArrowRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleArrowRight(props: &CircleArrowRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M8 12h8" />
+            <path d="m12 16 4-4-4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_arrow_up.rs b/packages/yew/src/circle_arrow_up.rs
new file mode 100644
index 0000000..28c4b6a
--- /dev/null
+++ b/packages/yew/src/circle_arrow_up.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleArrowUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleArrowUp(props: &CircleArrowUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m16 12-4-4-4 4" />
+            <path d="M12 16V8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_check.rs b/packages/yew/src/circle_check.rs
new file mode 100644
index 0000000..6762141
--- /dev/null
+++ b/packages/yew/src/circle_check.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleCheck(props: &CircleCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m9 12 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_check_big.rs b/packages/yew/src/circle_check_big.rs
new file mode 100644
index 0000000..797caa7
--- /dev/null
+++ b/packages/yew/src/circle_check_big.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleCheckBigProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleCheckBig(props: &CircleCheckBigProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.801 10A10 10 0 1 1 17 3.335" />
+            <path d="m9 11 3 3L22 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_chevron_down.rs b/packages/yew/src/circle_chevron_down.rs
new file mode 100644
index 0000000..744e518
--- /dev/null
+++ b/packages/yew/src/circle_chevron_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleChevronDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleChevronDown(props: &CircleChevronDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m16 10-4 4-4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_chevron_left.rs b/packages/yew/src/circle_chevron_left.rs
new file mode 100644
index 0000000..5af96ef
--- /dev/null
+++ b/packages/yew/src/circle_chevron_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleChevronLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleChevronLeft(props: &CircleChevronLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m14 16-4-4 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_chevron_right.rs b/packages/yew/src/circle_chevron_right.rs
new file mode 100644
index 0000000..65b9092
--- /dev/null
+++ b/packages/yew/src/circle_chevron_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleChevronRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleChevronRight(props: &CircleChevronRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m10 8 4 4-4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_chevron_up.rs b/packages/yew/src/circle_chevron_up.rs
new file mode 100644
index 0000000..b95a4e0
--- /dev/null
+++ b/packages/yew/src/circle_chevron_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleChevronUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleChevronUp(props: &CircleChevronUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m8 14 4-4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_dashed.rs b/packages/yew/src/circle_dashed.rs
new file mode 100644
index 0000000..fcedd4b
--- /dev/null
+++ b/packages/yew/src/circle_dashed.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleDashed(props: &CircleDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.1 2.182a10 10 0 0 1 3.8 0" />
+            <path d="M13.9 21.818a10 10 0 0 1-3.8 0" />
+            <path d="M17.609 3.721a10 10 0 0 1 2.69 2.7" />
+            <path d="M2.182 13.9a10 10 0 0 1 0-3.8" />
+            <path d="M20.279 17.609a10 10 0 0 1-2.7 2.69" />
+            <path d="M21.818 10.1a10 10 0 0 1 0 3.8" />
+            <path d="M3.721 6.391a10 10 0 0 1 2.7-2.69" />
+            <path d="M6.391 20.279a10 10 0 0 1-2.69-2.7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_divide.rs b/packages/yew/src/circle_divide.rs
new file mode 100644
index 0000000..3f7baeb
--- /dev/null
+++ b/packages/yew/src/circle_divide.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleDivideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleDivide(props: &CircleDivideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="8" x2="16" y1="12" y2="12" />
+            <line x1="12" x2="12" y1="16" y2="16" />
+            <line x1="12" x2="12" y1="8" y2="8" />
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_dollar_sign.rs b/packages/yew/src/circle_dollar_sign.rs
new file mode 100644
index 0000000..5c4c886
--- /dev/null
+++ b/packages/yew/src/circle_dollar_sign.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleDollarSignProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleDollarSign(props: &CircleDollarSignProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8" />
+            <path d="M12 18V6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_dot.rs b/packages/yew/src/circle_dot.rs
new file mode 100644
index 0000000..546b9ad
--- /dev/null
+++ b/packages/yew/src/circle_dot.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleDot(props: &CircleDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <circle cx="12" cy="12" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_dot_dashed.rs b/packages/yew/src/circle_dot_dashed.rs
new file mode 100644
index 0000000..d96f5a5
--- /dev/null
+++ b/packages/yew/src/circle_dot_dashed.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleDotDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleDotDashed(props: &CircleDotDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.1 2.18a9.93 9.93 0 0 1 3.8 0" />
+            <path d="M17.6 3.71a9.95 9.95 0 0 1 2.69 2.7" />
+            <path d="M21.82 10.1a9.93 9.93 0 0 1 0 3.8" />
+            <path d="M20.29 17.6a9.95 9.95 0 0 1-2.7 2.69" />
+            <path d="M13.9 21.82a9.94 9.94 0 0 1-3.8 0" />
+            <path d="M6.4 20.29a9.95 9.95 0 0 1-2.69-2.7" />
+            <path d="M2.18 13.9a9.93 9.93 0 0 1 0-3.8" />
+            <path d="M3.71 6.4a9.95 9.95 0 0 1 2.7-2.69" />
+            <circle cx="12" cy="12" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_ellipsis.rs b/packages/yew/src/circle_ellipsis.rs
new file mode 100644
index 0000000..0b85841
--- /dev/null
+++ b/packages/yew/src/circle_ellipsis.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleEllipsisProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleEllipsis(props: &CircleEllipsisProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M17 12h.01" />
+            <path d="M12 12h.01" />
+            <path d="M7 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_equal.rs b/packages/yew/src/circle_equal.rs
new file mode 100644
index 0000000..725bd37
--- /dev/null
+++ b/packages/yew/src/circle_equal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleEqualProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleEqual(props: &CircleEqualProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 10h10" />
+            <path d="M7 14h10" />
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_fading_arrow_up.rs b/packages/yew/src/circle_fading_arrow_up.rs
new file mode 100644
index 0000000..144c9e5
--- /dev/null
+++ b/packages/yew/src/circle_fading_arrow_up.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleFadingArrowUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleFadingArrowUp(props: &CircleFadingArrowUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2a10 10 0 0 1 7.38 16.75" />
+            <path d="m16 12-4-4-4 4" />
+            <path d="M12 16V8" />
+            <path d="M2.5 8.875a10 10 0 0 0-.5 3" />
+            <path d="M2.83 16a10 10 0 0 0 2.43 3.4" />
+            <path d="M4.636 5.235a10 10 0 0 1 .891-.857" />
+            <path d="M8.644 21.42a10 10 0 0 0 7.631-.38" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_fading_plus.rs b/packages/yew/src/circle_fading_plus.rs
new file mode 100644
index 0000000..72415ed
--- /dev/null
+++ b/packages/yew/src/circle_fading_plus.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleFadingPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleFadingPlus(props: &CircleFadingPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2a10 10 0 0 1 7.38 16.75" />
+            <path d="M12 8v8" />
+            <path d="M16 12H8" />
+            <path d="M2.5 8.875a10 10 0 0 0-.5 3" />
+            <path d="M2.83 16a10 10 0 0 0 2.43 3.4" />
+            <path d="M4.636 5.235a10 10 0 0 1 .891-.857" />
+            <path d="M8.644 21.42a10 10 0 0 0 7.631-.38" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_gauge.rs b/packages/yew/src/circle_gauge.rs
new file mode 100644
index 0000000..00dec1d
--- /dev/null
+++ b/packages/yew/src/circle_gauge.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleGaugeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleGauge(props: &CircleGaugeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.6 2.7a10 10 0 1 0 5.7 5.7" />
+            <circle cx="12" cy="12" r="2" />
+            <path d="M13.4 10.6 19 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_help.rs b/packages/yew/src/circle_help.rs
new file mode 100644
index 0000000..9dce42b
--- /dev/null
+++ b/packages/yew/src/circle_help.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleHelpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleHelp(props: &CircleHelpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" />
+            <path d="M12 17h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_minus.rs b/packages/yew/src/circle_minus.rs
new file mode 100644
index 0000000..ba4ced4
--- /dev/null
+++ b/packages/yew/src/circle_minus.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleMinus(props: &CircleMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M8 12h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_off.rs b/packages/yew/src/circle_off.rs
new file mode 100644
index 0000000..5c7ecee
--- /dev/null
+++ b/packages/yew/src/circle_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleOff(props: &CircleOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 2 20 20" />
+            <path d="M8.35 2.69A10 10 0 0 1 21.3 15.65" />
+            <path d="M19.08 19.08A10 10 0 1 1 4.92 4.92" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_parking.rs b/packages/yew/src/circle_parking.rs
new file mode 100644
index 0000000..a4537e8
--- /dev/null
+++ b/packages/yew/src/circle_parking.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleParkingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleParking(props: &CircleParkingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M9 17V7h4a3 3 0 0 1 0 6H9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_parking_off.rs b/packages/yew/src/circle_parking_off.rs
new file mode 100644
index 0000000..dc1deb7
--- /dev/null
+++ b/packages/yew/src/circle_parking_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleParkingOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleParkingOff(props: &CircleParkingOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m5 5 14 14" />
+            <path d="M13 13a3 3 0 1 0 0-6H9v2" />
+            <path d="M9 17v-2.34" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_pause.rs b/packages/yew/src/circle_pause.rs
new file mode 100644
index 0000000..646213b
--- /dev/null
+++ b/packages/yew/src/circle_pause.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CirclePauseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CirclePause(props: &CirclePauseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <line x1="10" x2="10" y1="15" y2="9" />
+            <line x1="14" x2="14" y1="15" y2="9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_percent.rs b/packages/yew/src/circle_percent.rs
new file mode 100644
index 0000000..21c988b
--- /dev/null
+++ b/packages/yew/src/circle_percent.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CirclePercentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CirclePercent(props: &CirclePercentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m15 9-6 6" />
+            <path d="M9 9h.01" />
+            <path d="M15 15h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_play.rs b/packages/yew/src/circle_play.rs
new file mode 100644
index 0000000..547d729
--- /dev/null
+++ b/packages/yew/src/circle_play.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CirclePlayProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CirclePlay(props: &CirclePlayProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polygon points="10 8 16 12 10 16 10 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_plus.rs b/packages/yew/src/circle_plus.rs
new file mode 100644
index 0000000..ce33f63
--- /dev/null
+++ b/packages/yew/src/circle_plus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CirclePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CirclePlus(props: &CirclePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M8 12h8" />
+            <path d="M12 8v8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_power.rs b/packages/yew/src/circle_power.rs
new file mode 100644
index 0000000..992677e
--- /dev/null
+++ b/packages/yew/src/circle_power.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CirclePowerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CirclePower(props: &CirclePowerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v4" />
+            <path d="M7.998 9.003a5 5 0 1 0 8-.005" />
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_slash.rs b/packages/yew/src/circle_slash.rs
new file mode 100644
index 0000000..cd7b62b
--- /dev/null
+++ b/packages/yew/src/circle_slash.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleSlashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleSlash(props: &CircleSlashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <line x1="9" x2="15" y1="15" y2="9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_slash_2.rs b/packages/yew/src/circle_slash_2.rs
new file mode 100644
index 0000000..1e210d9
--- /dev/null
+++ b/packages/yew/src/circle_slash_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleSlash2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleSlash2(props: &CircleSlash2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M22 2 2 22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_stop.rs b/packages/yew/src/circle_stop.rs
new file mode 100644
index 0000000..7b1aa25
--- /dev/null
+++ b/packages/yew/src/circle_stop.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleStopProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleStop(props: &CircleStopProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <rect x="9" y="9" width="6" height="6" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_user.rs b/packages/yew/src/circle_user.rs
new file mode 100644
index 0000000..14712ab
--- /dev/null
+++ b/packages/yew/src/circle_user.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleUserProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleUser(props: &CircleUserProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <circle cx="12" cy="10" r="3" />
+            <path d="M7 20.662V19a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v1.662" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_user_round.rs b/packages/yew/src/circle_user_round.rs
new file mode 100644
index 0000000..c71a546
--- /dev/null
+++ b/packages/yew/src/circle_user_round.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleUserRoundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleUserRound(props: &CircleUserRoundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 20a6 6 0 0 0-12 0" />
+            <circle cx="12" cy="10" r="4" />
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circle_x.rs b/packages/yew/src/circle_x.rs
new file mode 100644
index 0000000..e17ab1d
--- /dev/null
+++ b/packages/yew/src/circle_x.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircleXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircleX(props: &CircleXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m15 9-6 6" />
+            <path d="m9 9 6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/circuit_board.rs b/packages/yew/src/circuit_board.rs
new file mode 100644
index 0000000..1b595dd
--- /dev/null
+++ b/packages/yew/src/circuit_board.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CircuitBoardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CircuitBoard(props: &CircuitBoardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M11 9h4a2 2 0 0 0 2-2V3" />
+            <circle cx="9" cy="9" r="2" />
+            <path d="M7 21v-4a2 2 0 0 1 2-2h4" />
+            <circle cx="15" cy="15" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/citrus.rs b/packages/yew/src/citrus.rs
new file mode 100644
index 0000000..dfb26e4
--- /dev/null
+++ b/packages/yew/src/citrus.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CitrusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Citrus(props: &CitrusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21.66 17.67a1.08 1.08 0 0 1-.04 1.6A12 12 0 0 1 4.73 2.38a1.1 1.1 0 0 1 1.61-.04z"
+            />
+            <path d="M19.65 15.66A8 8 0 0 1 8.35 4.34" />
+            <path d="m14 10-5.5 5.5" />
+            <path d="M14 17.85V10H6.15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clapperboard.rs b/packages/yew/src/clapperboard.rs
new file mode 100644
index 0000000..5349f93
--- /dev/null
+++ b/packages/yew/src/clapperboard.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClapperboardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clapperboard(props: &ClapperboardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20.2 6 3 11l-.9-2.4c-.3-1.1.3-2.2 1.3-2.5l13.5-4c1.1-.3 2.2.3 2.5 1.3Z" />
+            <path d="m6.2 5.3 3.1 3.9" />
+            <path d="m12.4 3.4 3.1 4" />
+            <path d="M3 11h18v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard.rs b/packages/yew/src/clipboard.rs
new file mode 100644
index 0000000..9a63577
--- /dev/null
+++ b/packages/yew/src/clipboard.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clipboard(props: &ClipboardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_check.rs b/packages/yew/src/clipboard_check.rs
new file mode 100644
index 0000000..af2c821
--- /dev/null
+++ b/packages/yew/src/clipboard_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardCheck(props: &ClipboardCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" />
+            <path d="m9 14 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_copy.rs b/packages/yew/src/clipboard_copy.rs
new file mode 100644
index 0000000..395be6a
--- /dev/null
+++ b/packages/yew/src/clipboard_copy.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardCopyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardCopy(props: &ClipboardCopyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1" />
+            <path d="M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-2" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v4" />
+            <path d="M21 14H11" />
+            <path d="m15 10-4 4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_list.rs b/packages/yew/src/clipboard_list.rs
new file mode 100644
index 0000000..aea6ae3
--- /dev/null
+++ b/packages/yew/src/clipboard_list.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardListProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardList(props: &ClipboardListProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" />
+            <path d="M12 11h4" />
+            <path d="M12 16h4" />
+            <path d="M8 11h.01" />
+            <path d="M8 16h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_minus.rs b/packages/yew/src/clipboard_minus.rs
new file mode 100644
index 0000000..b64244c
--- /dev/null
+++ b/packages/yew/src/clipboard_minus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardMinus(props: &ClipboardMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" />
+            <path d="M9 14h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_paste.rs b/packages/yew/src/clipboard_paste.rs
new file mode 100644
index 0000000..9ccf91a
--- /dev/null
+++ b/packages/yew/src/clipboard_paste.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardPasteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardPaste(props: &ClipboardPasteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H9a1 1 0 0 0-1 1v2c0 .6.4 1 1 1h6c.6 0 1-.4 1-1V3c0-.6-.4-1-1-1Z" />
+            <path
+                d="M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2M16 4h2a2 2 0 0 1 2 2v2M11 14h10"
+            />
+            <path d="m17 10 4 4-4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_pen.rs b/packages/yew/src/clipboard_pen.rs
new file mode 100644
index 0000000..a22b7ee
--- /dev/null
+++ b/packages/yew/src/clipboard_pen.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardPenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardPen(props: &ClipboardPenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-5.5" />
+            <path d="M4 13.5V6a2 2 0 0 1 2-2h2" />
+            <path
+                d="M13.378 15.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_pen_line.rs b/packages/yew/src/clipboard_pen_line.rs
new file mode 100644
index 0000000..428423c
--- /dev/null
+++ b/packages/yew/src/clipboard_pen_line.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardPenLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardPenLine(props: &ClipboardPenLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" />
+            <path d="M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-.5" />
+            <path d="M16 4h2a2 2 0 0 1 1.73 1" />
+            <path d="M8 18h1" />
+            <path
+                d="M21.378 12.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_plus.rs b/packages/yew/src/clipboard_plus.rs
new file mode 100644
index 0000000..58977d9
--- /dev/null
+++ b/packages/yew/src/clipboard_plus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardPlus(props: &ClipboardPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" />
+            <path d="M9 14h6" />
+            <path d="M12 17v-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_type.rs b/packages/yew/src/clipboard_type.rs
new file mode 100644
index 0000000..1b7fb1d
--- /dev/null
+++ b/packages/yew/src/clipboard_type.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardTypeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardType(props: &ClipboardTypeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" />
+            <path d="M9 12v-1h6v1" />
+            <path d="M11 17h2" />
+            <path d="M12 11v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clipboard_x.rs b/packages/yew/src/clipboard_x.rs
new file mode 100644
index 0000000..29b3805
--- /dev/null
+++ b/packages/yew/src/clipboard_x.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClipboardXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClipboardX(props: &ClipboardXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="4" x="8" y="2" rx="1" ry="1" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" />
+            <path d="m15 11-6 6" />
+            <path d="m9 11 6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock.rs b/packages/yew/src/clock.rs
new file mode 100644
index 0000000..7caf6c6
--- /dev/null
+++ b/packages/yew/src/clock.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock(props: &ClockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 16 14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_1.rs b/packages/yew/src/clock_1.rs
new file mode 100644
index 0000000..f1d5277
--- /dev/null
+++ b/packages/yew/src/clock_1.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock1Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock1(props: &Clock1Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 14.5 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_10.rs b/packages/yew/src/clock_10.rs
new file mode 100644
index 0000000..f8b8ed6
--- /dev/null
+++ b/packages/yew/src/clock_10.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock10Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock10(props: &Clock10Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 8 10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_11.rs b/packages/yew/src/clock_11.rs
new file mode 100644
index 0000000..a4a4e7f
--- /dev/null
+++ b/packages/yew/src/clock_11.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock11Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock11(props: &Clock11Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 9.5 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_12.rs b/packages/yew/src/clock_12.rs
new file mode 100644
index 0000000..9b28aeb
--- /dev/null
+++ b/packages/yew/src/clock_12.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock12Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock12(props: &Clock12Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_2.rs b/packages/yew/src/clock_2.rs
new file mode 100644
index 0000000..93358f1
--- /dev/null
+++ b/packages/yew/src/clock_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock2(props: &Clock2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 16 10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_3.rs b/packages/yew/src/clock_3.rs
new file mode 100644
index 0000000..e71aad2
--- /dev/null
+++ b/packages/yew/src/clock_3.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock3(props: &Clock3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 16.5 12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_4.rs b/packages/yew/src/clock_4.rs
new file mode 100644
index 0000000..d55c871
--- /dev/null
+++ b/packages/yew/src/clock_4.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock4Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock4(props: &Clock4Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 16 14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_5.rs b/packages/yew/src/clock_5.rs
new file mode 100644
index 0000000..6d40078
--- /dev/null
+++ b/packages/yew/src/clock_5.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock5Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock5(props: &Clock5Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 14.5 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_6.rs b/packages/yew/src/clock_6.rs
new file mode 100644
index 0000000..4b97a09
--- /dev/null
+++ b/packages/yew/src/clock_6.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock6Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock6(props: &Clock6Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 12 16.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_7.rs b/packages/yew/src/clock_7.rs
new file mode 100644
index 0000000..48915ad
--- /dev/null
+++ b/packages/yew/src/clock_7.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock7Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock7(props: &Clock7Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 9.5 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_8.rs b/packages/yew/src/clock_8.rs
new file mode 100644
index 0000000..d4b1f1d
--- /dev/null
+++ b/packages/yew/src/clock_8.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock8Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock8(props: &Clock8Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 8 14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_9.rs b/packages/yew/src/clock_9.rs
new file mode 100644
index 0000000..a6a485d
--- /dev/null
+++ b/packages/yew/src/clock_9.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Clock9Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clock9(props: &Clock9Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <polyline points="12 6 12 12 7.5 12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_alert.rs b/packages/yew/src/clock_alert.rs
new file mode 100644
index 0000000..9836f4c
--- /dev/null
+++ b/packages/yew/src/clock_alert.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClockAlertProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClockAlert(props: &ClockAlertProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v6l4 2" />
+            <path d="M16 21.16a10 10 0 1 1 5-13.516" />
+            <path d="M20 11.5v6" />
+            <path d="M20 21.5h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_arrow_down.rs b/packages/yew/src/clock_arrow_down.rs
new file mode 100644
index 0000000..d7e61e2
--- /dev/null
+++ b/packages/yew/src/clock_arrow_down.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClockArrowDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClockArrowDown(props: &ClockArrowDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.338 21.994A10 10 0 1 1 21.925 13.227" />
+            <path d="M12 6v6l2 1" />
+            <path d="m14 18 4 4 4-4" />
+            <path d="M18 14v8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clock_arrow_up.rs b/packages/yew/src/clock_arrow_up.rs
new file mode 100644
index 0000000..c793128
--- /dev/null
+++ b/packages/yew/src/clock_arrow_up.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClockArrowUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ClockArrowUp(props: &ClockArrowUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.228 21.925A10 10 0 1 1 21.994 12.338" />
+            <path d="M12 6v6l1.562.781" />
+            <path d="m14 18 4-4 4 4" />
+            <path d="M18 22v-8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud.rs b/packages/yew/src/cloud.rs
new file mode 100644
index 0000000..e42acae
--- /dev/null
+++ b/packages/yew/src/cloud.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cloud(props: &CloudProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_alert.rs b/packages/yew/src/cloud_alert.rs
new file mode 100644
index 0000000..24d56c8
--- /dev/null
+++ b/packages/yew/src/cloud_alert.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudAlertProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudAlert(props: &CloudAlertProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12v4" />
+            <path d="M12 20h.01" />
+            <path d="M17 18h.5a1 1 0 0 0 0-9h-1.79A7 7 0 1 0 7 17.708" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_cog.rs b/packages/yew/src/cloud_cog.rs
new file mode 100644
index 0000000..5470db0
--- /dev/null
+++ b/packages/yew/src/cloud_cog.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudCog(props: &CloudCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="17" r="3" />
+            <path d="M4.2 15.1A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.2" />
+            <path d="m15.7 18.4-.9-.3" />
+            <path d="m9.2 15.9-.9-.3" />
+            <path d="m10.6 20.7.3-.9" />
+            <path d="m13.1 14.2.3-.9" />
+            <path d="m13.6 20.7-.4-1" />
+            <path d="m10.8 14.3-.4-1" />
+            <path d="m8.3 18.6 1-.4" />
+            <path d="m14.7 15.8 1-.4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_download.rs b/packages/yew/src/cloud_download.rs
new file mode 100644
index 0000000..eed52dd
--- /dev/null
+++ b/packages/yew/src/cloud_download.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudDownloadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudDownload(props: &CloudDownloadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13v8l-4-4" />
+            <path d="m12 21 4-4" />
+            <path d="M4.393 15.269A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.436 8.284" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_drizzle.rs b/packages/yew/src/cloud_drizzle.rs
new file mode 100644
index 0000000..57d8e28
--- /dev/null
+++ b/packages/yew/src/cloud_drizzle.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudDrizzleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudDrizzle(props: &CloudDrizzleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
+            <path d="M8 19v1" />
+            <path d="M8 14v1" />
+            <path d="M16 19v1" />
+            <path d="M16 14v1" />
+            <path d="M12 21v1" />
+            <path d="M12 16v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_fog.rs b/packages/yew/src/cloud_fog.rs
new file mode 100644
index 0000000..1426fe8
--- /dev/null
+++ b/packages/yew/src/cloud_fog.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudFogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudFog(props: &CloudFogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
+            <path d="M16 17H7" />
+            <path d="M17 21H9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_hail.rs b/packages/yew/src/cloud_hail.rs
new file mode 100644
index 0000000..7cd19c2
--- /dev/null
+++ b/packages/yew/src/cloud_hail.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudHailProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudHail(props: &CloudHailProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
+            <path d="M16 14v2" />
+            <path d="M8 14v2" />
+            <path d="M16 20h.01" />
+            <path d="M8 20h.01" />
+            <path d="M12 16v2" />
+            <path d="M12 22h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_lightning.rs b/packages/yew/src/cloud_lightning.rs
new file mode 100644
index 0000000..a008a34
--- /dev/null
+++ b/packages/yew/src/cloud_lightning.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudLightningProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudLightning(props: &CloudLightningProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 16.326A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 .5 8.973" />
+            <path d="m13 12-3 5h4l-3 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_moon.rs b/packages/yew/src/cloud_moon.rs
new file mode 100644
index 0000000..a8d993d
--- /dev/null
+++ b/packages/yew/src/cloud_moon.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudMoonProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudMoon(props: &CloudMoonProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.188 8.5A6 6 0 0 1 16 4a1 1 0 0 0 6 6 6 6 0 0 1-3 5.197" />
+            <path d="M13 16a3 3 0 1 1 0 6H7a5 5 0 1 1 4.9-6Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_moon_rain.rs b/packages/yew/src/cloud_moon_rain.rs
new file mode 100644
index 0000000..8d56d9e
--- /dev/null
+++ b/packages/yew/src/cloud_moon_rain.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudMoonRainProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudMoonRain(props: &CloudMoonRainProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.188 8.5A6 6 0 0 1 16 4a1 1 0 0 0 6 6 6 6 0 0 1-3 5.197" />
+            <path d="M11 20v2" />
+            <path d="M3 20a5 5 0 1 1 8.9-4H13a3 3 0 0 1 2 5.24" />
+            <path d="M7 19v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_off.rs b/packages/yew/src/cloud_off.rs
new file mode 100644
index 0000000..96ec36b
--- /dev/null
+++ b/packages/yew/src/cloud_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudOff(props: &CloudOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 2 20 20" />
+            <path d="M5.782 5.782A7 7 0 0 0 9 19h8.5a4.5 4.5 0 0 0 1.307-.193" />
+            <path d="M21.532 16.5A4.5 4.5 0 0 0 17.5 10h-1.79A7.008 7.008 0 0 0 10 5.07" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_rain.rs b/packages/yew/src/cloud_rain.rs
new file mode 100644
index 0000000..fb2435a
--- /dev/null
+++ b/packages/yew/src/cloud_rain.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudRainProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudRain(props: &CloudRainProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
+            <path d="M16 14v6" />
+            <path d="M8 14v6" />
+            <path d="M12 16v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_rain_wind.rs b/packages/yew/src/cloud_rain_wind.rs
new file mode 100644
index 0000000..3ce00cc
--- /dev/null
+++ b/packages/yew/src/cloud_rain_wind.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudRainWindProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudRainWind(props: &CloudRainWindProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
+            <path d="m9.2 22 3-7" />
+            <path d="m9 13-3 7" />
+            <path d="m17 13-3 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_snow.rs b/packages/yew/src/cloud_snow.rs
new file mode 100644
index 0000000..4522a0c
--- /dev/null
+++ b/packages/yew/src/cloud_snow.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudSnowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudSnow(props: &CloudSnowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
+            <path d="M8 15h.01" />
+            <path d="M8 19h.01" />
+            <path d="M12 17h.01" />
+            <path d="M12 21h.01" />
+            <path d="M16 15h.01" />
+            <path d="M16 19h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_sun.rs b/packages/yew/src/cloud_sun.rs
new file mode 100644
index 0000000..bdd2a9a
--- /dev/null
+++ b/packages/yew/src/cloud_sun.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudSunProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudSun(props: &CloudSunProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v2" />
+            <path d="m4.93 4.93 1.41 1.41" />
+            <path d="M20 12h2" />
+            <path d="m19.07 4.93-1.41 1.41" />
+            <path d="M15.947 12.65a4 4 0 0 0-5.925-4.128" />
+            <path d="M13 22H7a5 5 0 1 1 4.9-6H13a3 3 0 0 1 0 6Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_sun_rain.rs b/packages/yew/src/cloud_sun_rain.rs
new file mode 100644
index 0000000..4a3d64b
--- /dev/null
+++ b/packages/yew/src/cloud_sun_rain.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudSunRainProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudSunRain(props: &CloudSunRainProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v2" />
+            <path d="m4.93 4.93 1.41 1.41" />
+            <path d="M20 12h2" />
+            <path d="m19.07 4.93-1.41 1.41" />
+            <path d="M15.947 12.65a4 4 0 0 0-5.925-4.128" />
+            <path d="M3 20a5 5 0 1 1 8.9-4H13a3 3 0 0 1 2 5.24" />
+            <path d="M11 20v2" />
+            <path d="M7 19v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloud_upload.rs b/packages/yew/src/cloud_upload.rs
new file mode 100644
index 0000000..5866f9d
--- /dev/null
+++ b/packages/yew/src/cloud_upload.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudUploadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CloudUpload(props: &CloudUploadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13v8" />
+            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
+            <path d="m8 17 4-4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cloudy.rs b/packages/yew/src/cloudy.rs
new file mode 100644
index 0000000..9ce7b51
--- /dev/null
+++ b/packages/yew/src/cloudy.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloudyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cloudy(props: &CloudyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.5 21H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z" />
+            <path d="M22 10a3 3 0 0 0-3-3h-2.207a5.502 5.502 0 0 0-10.702.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/clover.rs b/packages/yew/src/clover.rs
new file mode 100644
index 0000000..085f58c
--- /dev/null
+++ b/packages/yew/src/clover.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CloverProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Clover(props: &CloverProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16.17 7.83 2 22" />
+            <path
+                d="M4.02 12a2.827 2.827 0 1 1 3.81-4.17A2.827 2.827 0 1 1 12 4.02a2.827 2.827 0 1 1 4.17 3.81A2.827 2.827 0 1 1 19.98 12a2.827 2.827 0 1 1-3.81 4.17A2.827 2.827 0 1 1 12 19.98a2.827 2.827 0 1 1-4.17-3.81A1 1 0 1 1 4 12"
+            />
+            <path d="m7.83 7.83 8.34 8.34" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/club.rs b/packages/yew/src/club.rs
new file mode 100644
index 0000000..01e1ca5
--- /dev/null
+++ b/packages/yew/src/club.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ClubProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Club(props: &ClubProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M17.28 9.05a5.5 5.5 0 1 0-10.56 0A5.5 5.5 0 1 0 12 17.66a5.5 5.5 0 1 0 5.28-8.6Z"
+            />
+            <path d="M12 17.66L12 22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/code.rs b/packages/yew/src/code.rs
new file mode 100644
index 0000000..e1d48f2
--- /dev/null
+++ b/packages/yew/src/code.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Code(props: &CodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="16 18 22 12 16 6" />
+            <polyline points="8 6 2 12 8 18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/code_xml.rs b/packages/yew/src/code_xml.rs
new file mode 100644
index 0000000..5ded452
--- /dev/null
+++ b/packages/yew/src/code_xml.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CodeXmlProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CodeXml(props: &CodeXmlProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 16 4-4-4-4" />
+            <path d="m6 8-4 4 4 4" />
+            <path d="m14.5 4-5 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/codepen.rs b/packages/yew/src/codepen.rs
new file mode 100644
index 0000000..6e47f9e
--- /dev/null
+++ b/packages/yew/src/codepen.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CodepenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Codepen(props: &CodepenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2" />
+            <line x1="12" x2="12" y1="22" y2="15.5" />
+            <polyline points="22 8.5 12 15.5 2 8.5" />
+            <polyline points="2 15.5 12 8.5 22 15.5" />
+            <line x1="12" x2="12" y1="2" y2="8.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/codesandbox.rs b/packages/yew/src/codesandbox.rs
new file mode 100644
index 0000000..31e6eec
--- /dev/null
+++ b/packages/yew/src/codesandbox.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CodesandboxProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Codesandbox(props: &CodesandboxProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"
+            />
+            <polyline points="7.5 4.21 12 6.81 16.5 4.21" />
+            <polyline points="7.5 19.79 7.5 14.6 3 12" />
+            <polyline points="21 12 16.5 14.6 16.5 19.79" />
+            <polyline points="3.27 6.96 12 12.01 20.73 6.96" />
+            <line x1="12" x2="12" y1="22.08" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/coffee.rs b/packages/yew/src/coffee.rs
new file mode 100644
index 0000000..9f08bb9
--- /dev/null
+++ b/packages/yew/src/coffee.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CoffeeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Coffee(props: &CoffeeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v2" />
+            <path d="M14 2v2" />
+            <path
+                d="M16 8a1 1 0 0 1 1 1v8a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1h14a4 4 0 1 1 0 8h-1"
+            />
+            <path d="M6 2v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cog.rs b/packages/yew/src/cog.rs
new file mode 100644
index 0000000..b5ef0d0
--- /dev/null
+++ b/packages/yew/src/cog.rs
@@ -0,0 +1,57 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cog(props: &CogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20a8 8 0 1 0 0-16 8 8 0 0 0 0 16Z" />
+            <path d="M12 14a2 2 0 1 0 0-4 2 2 0 0 0 0 4Z" />
+            <path d="M12 2v2" />
+            <path d="M12 22v-2" />
+            <path d="m17 20.66-1-1.73" />
+            <path d="M11 10.27 7 3.34" />
+            <path d="m20.66 17-1.73-1" />
+            <path d="m3.34 7 1.73 1" />
+            <path d="M14 12h8" />
+            <path d="M2 12h2" />
+            <path d="m20.66 7-1.73 1" />
+            <path d="m3.34 17 1.73-1" />
+            <path d="m17 3.34-1 1.73" />
+            <path d="m11 13.73-4 6.93" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/coins.rs b/packages/yew/src/coins.rs
new file mode 100644
index 0000000..aac0660
--- /dev/null
+++ b/packages/yew/src/coins.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CoinsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Coins(props: &CoinsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="8" cy="8" r="6" />
+            <path d="M18.09 10.37A6 6 0 1 1 10.34 18" />
+            <path d="M7 6h1v4" />
+            <path d="m16.71 13.88.7.71-2.82 2.82" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/columns_2.rs b/packages/yew/src/columns_2.rs
new file mode 100644
index 0000000..224a90d
--- /dev/null
+++ b/packages/yew/src/columns_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Columns2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Columns2(props: &Columns2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M12 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/columns_3.rs b/packages/yew/src/columns_3.rs
new file mode 100644
index 0000000..a285bc6
--- /dev/null
+++ b/packages/yew/src/columns_3.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Columns3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Columns3(props: &Columns3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M9 3v18" />
+            <path d="M15 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/columns_4.rs b/packages/yew/src/columns_4.rs
new file mode 100644
index 0000000..d121893
--- /dev/null
+++ b/packages/yew/src/columns_4.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Columns4Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Columns4(props: &Columns4Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M7.5 3v18" />
+            <path d="M12 3v18" />
+            <path d="M16.5 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/combine.rs b/packages/yew/src/combine.rs
new file mode 100644
index 0000000..e892393
--- /dev/null
+++ b/packages/yew/src/combine.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CombineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Combine(props: &CombineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 18H5a3 3 0 0 1-3-3v-1" />
+            <path d="M14 2a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2" />
+            <path d="M20 2a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2" />
+            <path d="m7 21 3-3-3-3" />
+            <rect x="14" y="14" width="8" height="8" rx="2" />
+            <rect x="2" y="2" width="8" height="8" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/command.rs b/packages/yew/src/command.rs
new file mode 100644
index 0000000..784a0d7
--- /dev/null
+++ b/packages/yew/src/command.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CommandProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Command(props: &CommandProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 6v12a3 3 0 1 0 3-3H6a3 3 0 1 0 3 3V6a3 3 0 1 0-3 3h12a3 3 0 1 0-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/compass.rs b/packages/yew/src/compass.rs
new file mode 100644
index 0000000..d51261d
--- /dev/null
+++ b/packages/yew/src/compass.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CompassProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Compass(props: &CompassProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m16.24 7.76-1.804 5.411a2 2 0 0 1-1.265 1.265L7.76 16.24l1.804-5.411a2 2 0 0 1 1.265-1.265z"
+            />
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/component.rs b/packages/yew/src/component.rs
new file mode 100644
index 0000000..0c24d59
--- /dev/null
+++ b/packages/yew/src/component.rs
@@ -0,0 +1,55 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ComponentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Component(props: &ComponentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M15.536 11.293a1 1 0 0 0 0 1.414l2.376 2.377a1 1 0 0 0 1.414 0l2.377-2.377a1 1 0 0 0 0-1.414l-2.377-2.377a1 1 0 0 0-1.414 0z"
+            />
+            <path
+                d="M2.297 11.293a1 1 0 0 0 0 1.414l2.377 2.377a1 1 0 0 0 1.414 0l2.377-2.377a1 1 0 0 0 0-1.414L6.088 8.916a1 1 0 0 0-1.414 0z"
+            />
+            <path
+                d="M8.916 17.912a1 1 0 0 0 0 1.415l2.377 2.376a1 1 0 0 0 1.414 0l2.377-2.376a1 1 0 0 0 0-1.415l-2.377-2.376a1 1 0 0 0-1.414 0z"
+            />
+            <path
+                d="M8.916 4.674a1 1 0 0 0 0 1.414l2.377 2.376a1 1 0 0 0 1.414 0l2.377-2.376a1 1 0 0 0 0-1.414l-2.377-2.377a1 1 0 0 0-1.414 0z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/computer.rs b/packages/yew/src/computer.rs
new file mode 100644
index 0000000..5a40619
--- /dev/null
+++ b/packages/yew/src/computer.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ComputerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Computer(props: &ComputerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="8" x="5" y="2" rx="2" />
+            <rect width="20" height="8" x="2" y="14" rx="2" />
+            <path d="M6 18h2" />
+            <path d="M12 18h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/concierge_bell.rs b/packages/yew/src/concierge_bell.rs
new file mode 100644
index 0000000..4d8d035
--- /dev/null
+++ b/packages/yew/src/concierge_bell.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ConciergeBellProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ConciergeBell(props: &ConciergeBellProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 20a1 1 0 0 1-1-1v-1a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1Z" />
+            <path d="M20 16a8 8 0 1 0-16 0" />
+            <path d="M12 4v4" />
+            <path d="M10 4h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cone.rs b/packages/yew/src/cone.rs
new file mode 100644
index 0000000..bfac460
--- /dev/null
+++ b/packages/yew/src/cone.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ConeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cone(props: &ConeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m20.9 18.55-8-15.98a1 1 0 0 0-1.8 0l-8 15.98" />
+            <ellipse cx="12" cy="19" rx="9" ry="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/construction.rs b/packages/yew/src/construction.rs
new file mode 100644
index 0000000..ec25253
--- /dev/null
+++ b/packages/yew/src/construction.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ConstructionProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Construction(props: &ConstructionProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="2" y="6" width="20" height="8" rx="1" />
+            <path d="M17 14v7" />
+            <path d="M7 14v7" />
+            <path d="M17 3v3" />
+            <path d="M7 3v3" />
+            <path d="M10 14 2.3 6.3" />
+            <path d="m14 6 7.7 7.7" />
+            <path d="m8 6 8 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/contact.rs b/packages/yew/src/contact.rs
new file mode 100644
index 0000000..e0484e4
--- /dev/null
+++ b/packages/yew/src/contact.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ContactProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Contact(props: &ContactProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 2v2" />
+            <path d="M7 22v-2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v2" />
+            <path d="M8 2v2" />
+            <circle cx="12" cy="11" r="3" />
+            <rect x="3" y="4" width="18" height="18" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/contact_round.rs b/packages/yew/src/contact_round.rs
new file mode 100644
index 0000000..ea8ec29
--- /dev/null
+++ b/packages/yew/src/contact_round.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ContactRoundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ContactRound(props: &ContactRoundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 2v2" />
+            <path d="M17.915 22a6 6 0 0 0-12 0" />
+            <path d="M8 2v2" />
+            <circle cx="12" cy="12" r="4" />
+            <rect x="3" y="4" width="18" height="18" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/container.rs b/packages/yew/src/container.rs
new file mode 100644
index 0000000..3cb4b79
--- /dev/null
+++ b/packages/yew/src/container.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ContainerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Container(props: &ContainerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M22 7.7c0-.6-.4-1.2-.8-1.5l-6.3-3.9a1.72 1.72 0 0 0-1.7 0l-10.3 6c-.5.2-.9.8-.9 1.4v6.6c0 .5.4 1.2.8 1.5l6.3 3.9a1.72 1.72 0 0 0 1.7 0l10.3-6c.5-.3.9-1 .9-1.5Z"
+            />
+            <path d="M10 21.9V14L2.1 9.1" />
+            <path d="m10 14 11.9-6.9" />
+            <path d="M14 19.8v-8.1" />
+            <path d="M18 17.5V9.4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/contrast.rs b/packages/yew/src/contrast.rs
new file mode 100644
index 0000000..9094bfb
--- /dev/null
+++ b/packages/yew/src/contrast.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ContrastProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Contrast(props: &ContrastProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M12 18a6 6 0 0 0 0-12v12z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cookie.rs b/packages/yew/src/cookie.rs
new file mode 100644
index 0000000..94fd7a9
--- /dev/null
+++ b/packages/yew/src/cookie.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CookieProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cookie(props: &CookieProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2a10 10 0 1 0 10 10 4 4 0 0 1-5-5 4 4 0 0 1-5-5" />
+            <path d="M8.5 8.5v.01" />
+            <path d="M16 15.5v.01" />
+            <path d="M12 12v.01" />
+            <path d="M11 17v.01" />
+            <path d="M7 14v.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cooking_pot.rs b/packages/yew/src/cooking_pot.rs
new file mode 100644
index 0000000..fcd3b03
--- /dev/null
+++ b/packages/yew/src/cooking_pot.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CookingPotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CookingPot(props: &CookingPotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12h20" />
+            <path d="M20 12v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-8" />
+            <path d="m4 8 16-4" />
+            <path d="m8.86 6.78-.45-1.81a2 2 0 0 1 1.45-2.43l1.94-.48a2 2 0 0 1 2.43 1.46l.45 1.8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/copy.rs b/packages/yew/src/copy.rs
new file mode 100644
index 0000000..911f4be
--- /dev/null
+++ b/packages/yew/src/copy.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CopyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Copy(props: &CopyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2" />
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/copy_check.rs b/packages/yew/src/copy_check.rs
new file mode 100644
index 0000000..c3aa82c
--- /dev/null
+++ b/packages/yew/src/copy_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CopyCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CopyCheck(props: &CopyCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 15 2 2 4-4" />
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2" />
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/copy_minus.rs b/packages/yew/src/copy_minus.rs
new file mode 100644
index 0000000..f950c6b
--- /dev/null
+++ b/packages/yew/src/copy_minus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CopyMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CopyMinus(props: &CopyMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="18" y1="15" y2="15" />
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2" />
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/copy_plus.rs b/packages/yew/src/copy_plus.rs
new file mode 100644
index 0000000..d3a64bb
--- /dev/null
+++ b/packages/yew/src/copy_plus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CopyPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CopyPlus(props: &CopyPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="15" x2="15" y1="12" y2="18" />
+            <line x1="12" x2="18" y1="15" y2="15" />
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2" />
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/copy_slash.rs b/packages/yew/src/copy_slash.rs
new file mode 100644
index 0000000..37d20b7
--- /dev/null
+++ b/packages/yew/src/copy_slash.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CopySlashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CopySlash(props: &CopySlashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="18" y1="18" y2="12" />
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2" />
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/copy_x.rs b/packages/yew/src/copy_x.rs
new file mode 100644
index 0000000..b9c501b
--- /dev/null
+++ b/packages/yew/src/copy_x.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CopyXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CopyX(props: &CopyXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="18" y1="12" y2="18" />
+            <line x1="12" x2="18" y1="18" y2="12" />
+            <rect width="14" height="14" x="8" y="8" rx="2" ry="2" />
+            <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/copyleft.rs b/packages/yew/src/copyleft.rs
new file mode 100644
index 0000000..6537283
--- /dev/null
+++ b/packages/yew/src/copyleft.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CopyleftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Copyleft(props: &CopyleftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M9.17 14.83a4 4 0 1 0 0-5.66" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/copyright.rs b/packages/yew/src/copyright.rs
new file mode 100644
index 0000000..f089fae
--- /dev/null
+++ b/packages/yew/src/copyright.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CopyrightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Copyright(props: &CopyrightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M14.83 14.83a4 4 0 1 1 0-5.66" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/corner_down_left.rs b/packages/yew/src/corner_down_left.rs
new file mode 100644
index 0000000..1290e52
--- /dev/null
+++ b/packages/yew/src/corner_down_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CornerDownLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CornerDownLeft(props: &CornerDownLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="9 10 4 15 9 20" />
+            <path d="M20 4v7a4 4 0 0 1-4 4H4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/corner_down_right.rs b/packages/yew/src/corner_down_right.rs
new file mode 100644
index 0000000..1a175b8
--- /dev/null
+++ b/packages/yew/src/corner_down_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CornerDownRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CornerDownRight(props: &CornerDownRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="15 10 20 15 15 20" />
+            <path d="M4 4v7a4 4 0 0 0 4 4h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/corner_left_down.rs b/packages/yew/src/corner_left_down.rs
new file mode 100644
index 0000000..4078f42
--- /dev/null
+++ b/packages/yew/src/corner_left_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CornerLeftDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CornerLeftDown(props: &CornerLeftDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="14 15 9 20 4 15" />
+            <path d="M20 4h-7a4 4 0 0 0-4 4v12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/corner_left_up.rs b/packages/yew/src/corner_left_up.rs
new file mode 100644
index 0000000..31de680
--- /dev/null
+++ b/packages/yew/src/corner_left_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CornerLeftUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CornerLeftUp(props: &CornerLeftUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="14 9 9 4 4 9" />
+            <path d="M20 20h-7a4 4 0 0 1-4-4V4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/corner_right_down.rs b/packages/yew/src/corner_right_down.rs
new file mode 100644
index 0000000..ecdd581
--- /dev/null
+++ b/packages/yew/src/corner_right_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CornerRightDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CornerRightDown(props: &CornerRightDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="10 15 15 20 20 15" />
+            <path d="M4 4h7a4 4 0 0 1 4 4v12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/corner_right_up.rs b/packages/yew/src/corner_right_up.rs
new file mode 100644
index 0000000..b7b3f98
--- /dev/null
+++ b/packages/yew/src/corner_right_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CornerRightUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CornerRightUp(props: &CornerRightUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="10 9 15 4 20 9" />
+            <path d="M4 20h7a4 4 0 0 0 4-4V4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/corner_up_left.rs b/packages/yew/src/corner_up_left.rs
new file mode 100644
index 0000000..afb2c4d
--- /dev/null
+++ b/packages/yew/src/corner_up_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CornerUpLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CornerUpLeft(props: &CornerUpLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="9 14 4 9 9 4" />
+            <path d="M20 20v-7a4 4 0 0 0-4-4H4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/corner_up_right.rs b/packages/yew/src/corner_up_right.rs
new file mode 100644
index 0000000..f82549f
--- /dev/null
+++ b/packages/yew/src/corner_up_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CornerUpRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CornerUpRight(props: &CornerUpRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="15 14 20 9 15 4" />
+            <path d="M4 20v-7a4 4 0 0 1 4-4h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cpu.rs b/packages/yew/src/cpu.rs
new file mode 100644
index 0000000..727b3cd
--- /dev/null
+++ b/packages/yew/src/cpu.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CpuProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cpu(props: &CpuProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="16" x="4" y="4" rx="2" />
+            <rect width="6" height="6" x="9" y="9" rx="1" />
+            <path d="M15 2v2" />
+            <path d="M15 20v2" />
+            <path d="M2 15h2" />
+            <path d="M2 9h2" />
+            <path d="M20 15h2" />
+            <path d="M20 9h2" />
+            <path d="M9 2v2" />
+            <path d="M9 20v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/creative_commons.rs b/packages/yew/src/creative_commons.rs
new file mode 100644
index 0000000..07a21fc
--- /dev/null
+++ b/packages/yew/src/creative_commons.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CreativeCommonsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CreativeCommons(props: &CreativeCommonsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M10 9.3a2.8 2.8 0 0 0-3.5 1 3.1 3.1 0 0 0 0 3.4 2.7 2.7 0 0 0 3.5 1" />
+            <path d="M17 9.3a2.8 2.8 0 0 0-3.5 1 3.1 3.1 0 0 0 0 3.4 2.7 2.7 0 0 0 3.5 1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/credit_card.rs b/packages/yew/src/credit_card.rs
new file mode 100644
index 0000000..7425650
--- /dev/null
+++ b/packages/yew/src/credit_card.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CreditCardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CreditCard(props: &CreditCardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="14" x="2" y="5" rx="2" />
+            <line x1="2" x2="22" y1="10" y2="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/croissant.rs b/packages/yew/src/croissant.rs
new file mode 100644
index 0000000..3f9c244
--- /dev/null
+++ b/packages/yew/src/croissant.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CroissantProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Croissant(props: &CroissantProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m4.6 13.11 5.79-3.21c1.89-1.05 4.79 1.78 3.71 3.71l-3.22 5.81C8.8 23.16.79 15.23 4.6 13.11Z"
+            />
+            <path
+                d="m10.5 9.5-1-2.29C9.2 6.48 8.8 6 8 6H4.5C2.79 6 2 6.5 2 8.5a7.71 7.71 0 0 0 2 4.83"
+            />
+            <path d="M8 6c0-1.55.24-4-2-4-2 0-2.5 2.17-2.5 4" />
+            <path
+                d="m14.5 13.5 2.29 1c.73.3 1.21.7 1.21 1.5v3.5c0 1.71-.5 2.5-2.5 2.5a7.71 7.71 0 0 1-4.83-2"
+            />
+            <path d="M18 16c1.55 0 4-.24 4 2 0 2-2.17 2.5-4 2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/crop.rs b/packages/yew/src/crop.rs
new file mode 100644
index 0000000..8a8996f
--- /dev/null
+++ b/packages/yew/src/crop.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CropProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Crop(props: &CropProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 2v14a2 2 0 0 0 2 2h14" />
+            <path d="M18 22V8a2 2 0 0 0-2-2H2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cross.rs b/packages/yew/src/cross.rs
new file mode 100644
index 0000000..b58a844
--- /dev/null
+++ b/packages/yew/src/cross.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CrossProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cross(props: &CrossProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 9a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h4a1 1 0 0 1 1 1v4a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-4a1 1 0 0 1 1-1h4a2 2 0 0 0 2-2v-2a2 2 0 0 0-2-2h-4a1 1 0 0 1-1-1V4a2 2 0 0 0-2-2h-2a2 2 0 0 0-2 2v4a1 1 0 0 1-1 1z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/crosshair.rs b/packages/yew/src/crosshair.rs
new file mode 100644
index 0000000..978068d
--- /dev/null
+++ b/packages/yew/src/crosshair.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CrosshairProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Crosshair(props: &CrosshairProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <line x1="22" x2="18" y1="12" y2="12" />
+            <line x1="6" x2="2" y1="12" y2="12" />
+            <line x1="12" x2="12" y1="6" y2="2" />
+            <line x1="12" x2="12" y1="22" y2="18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/crown.rs b/packages/yew/src/crown.rs
new file mode 100644
index 0000000..3c6e0fa
--- /dev/null
+++ b/packages/yew/src/crown.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CrownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Crown(props: &CrownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11.562 3.266a.5.5 0 0 1 .876 0L15.39 8.87a1 1 0 0 0 1.516.294L21.183 5.5a.5.5 0 0 1 .798.519l-2.834 10.246a1 1 0 0 1-.956.734H5.81a1 1 0 0 1-.957-.734L2.02 6.02a.5.5 0 0 1 .798-.519l4.276 3.664a1 1 0 0 0 1.516-.294z"
+            />
+            <path d="M5 21h14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cuboid.rs b/packages/yew/src/cuboid.rs
new file mode 100644
index 0000000..b5c26ab
--- /dev/null
+++ b/packages/yew/src/cuboid.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CuboidProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cuboid(props: &CuboidProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m21.12 6.4-6.05-4.06a2 2 0 0 0-2.17-.05L2.95 8.41a2 2 0 0 0-.95 1.7v5.82a2 2 0 0 0 .88 1.66l6.05 4.07a2 2 0 0 0 2.17.05l9.95-6.12a2 2 0 0 0 .95-1.7V8.06a2 2 0 0 0-.88-1.66Z"
+            />
+            <path d="M10 22v-8L2.25 9.15" />
+            <path d="m10 14 11.77-6.87" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cup_soda.rs b/packages/yew/src/cup_soda.rs
new file mode 100644
index 0000000..6b326f4
--- /dev/null
+++ b/packages/yew/src/cup_soda.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CupSodaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn CupSoda(props: &CupSodaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 8 1.75 12.28a2 2 0 0 0 2 1.72h4.54a2 2 0 0 0 2-1.72L18 8" />
+            <path d="M5 8h14" />
+            <path d="M7 15a6.47 6.47 0 0 1 5 0 6.47 6.47 0 0 0 5 0" />
+            <path d="m12 8 1-6h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/currency.rs b/packages/yew/src/currency.rs
new file mode 100644
index 0000000..f6226e0
--- /dev/null
+++ b/packages/yew/src/currency.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CurrencyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Currency(props: &CurrencyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="8" />
+            <line x1="3" x2="6" y1="3" y2="6" />
+            <line x1="21" x2="18" y1="3" y2="6" />
+            <line x1="3" x2="6" y1="21" y2="18" />
+            <line x1="21" x2="18" y1="21" y2="18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/cylinder.rs b/packages/yew/src/cylinder.rs
new file mode 100644
index 0000000..b391dcc
--- /dev/null
+++ b/packages/yew/src/cylinder.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct CylinderProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Cylinder(props: &CylinderProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="5" rx="9" ry="3" />
+            <path d="M3 5v14a9 3 0 0 0 18 0V5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dam.rs b/packages/yew/src/dam.rs
new file mode 100644
index 0000000..33b94ce
--- /dev/null
+++ b/packages/yew/src/dam.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DamProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dam(props: &DamProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 11.31c1.17.56 1.54 1.69 3.5 1.69 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1" />
+            <path d="M11.75 18c.35.5 1.45 1 2.75 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1" />
+            <path d="M2 10h4" />
+            <path d="M2 14h4" />
+            <path d="M2 18h4" />
+            <path d="M2 6h4" />
+            <path d="M7 3a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h4a1 1 0 0 0 1-1L10 4a1 1 0 0 0-1-1z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/database.rs b/packages/yew/src/database.rs
new file mode 100644
index 0000000..397e8bf
--- /dev/null
+++ b/packages/yew/src/database.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DatabaseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Database(props: &DatabaseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="5" rx="9" ry="3" />
+            <path d="M3 5V19A9 3 0 0 0 21 19V5" />
+            <path d="M3 12A9 3 0 0 0 21 12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/database_backup.rs b/packages/yew/src/database_backup.rs
new file mode 100644
index 0000000..fc942a8
--- /dev/null
+++ b/packages/yew/src/database_backup.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DatabaseBackupProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DatabaseBackup(props: &DatabaseBackupProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="5" rx="9" ry="3" />
+            <path d="M3 12a9 3 0 0 0 5 2.69" />
+            <path d="M21 9.3V5" />
+            <path d="M3 5v14a9 3 0 0 0 6.47 2.88" />
+            <path d="M12 12v4h4" />
+            <path d="M13 20a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L12 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/database_zap.rs b/packages/yew/src/database_zap.rs
new file mode 100644
index 0000000..08329aa
--- /dev/null
+++ b/packages/yew/src/database_zap.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DatabaseZapProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DatabaseZap(props: &DatabaseZapProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="5" rx="9" ry="3" />
+            <path d="M3 5V19A9 3 0 0 0 15 21.84" />
+            <path d="M21 5V8" />
+            <path d="M21 12L18 17H22L19 22" />
+            <path d="M3 12A9 3 0 0 0 14.59 14.87" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/delete.rs b/packages/yew/src/delete.rs
new file mode 100644
index 0000000..4db12a5
--- /dev/null
+++ b/packages/yew/src/delete.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DeleteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Delete(props: &DeleteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10 5a2 2 0 0 0-1.344.519l-6.328 5.74a1 1 0 0 0 0 1.481l6.328 5.741A2 2 0 0 0 10 19h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2z"
+            />
+            <path d="m12 9 6 6" />
+            <path d="m18 9-6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dessert.rs b/packages/yew/src/dessert.rs
new file mode 100644
index 0000000..332db95
--- /dev/null
+++ b/packages/yew/src/dessert.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DessertProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dessert(props: &DessertProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="4" r="2" />
+            <path
+                d="M10.2 3.2C5.5 4 2 8.1 2 13a2 2 0 0 0 4 0v-1a2 2 0 0 1 4 0v4a2 2 0 0 0 4 0v-4a2 2 0 0 1 4 0v1a2 2 0 0 0 4 0c0-4.9-3.5-9-8.2-9.8"
+            />
+            <path d="M3.2 14.8a9 9 0 0 0 17.6 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/diameter.rs b/packages/yew/src/diameter.rs
new file mode 100644
index 0000000..c44a1cb
--- /dev/null
+++ b/packages/yew/src/diameter.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DiameterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Diameter(props: &DiameterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="19" cy="19" r="2" />
+            <circle cx="5" cy="5" r="2" />
+            <path d="M6.48 3.66a10 10 0 0 1 13.86 13.86" />
+            <path d="m6.41 6.41 11.18 11.18" />
+            <path d="M3.66 6.48a10 10 0 0 0 13.86 13.86" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/diamond.rs b/packages/yew/src/diamond.rs
new file mode 100644
index 0000000..9623bf6
--- /dev/null
+++ b/packages/yew/src/diamond.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DiamondProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Diamond(props: &DiamondProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41l-7.59-7.59a2.41 2.41 0 0 0-3.41 0Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/diamond_minus.rs b/packages/yew/src/diamond_minus.rs
new file mode 100644
index 0000000..13fe413
--- /dev/null
+++ b/packages/yew/src/diamond_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DiamondMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DiamondMinus(props: &DiamondMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0z"
+            />
+            <path d="M8 12h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/diamond_percent.rs b/packages/yew/src/diamond_percent.rs
new file mode 100644
index 0000000..1de2b67
--- /dev/null
+++ b/packages/yew/src/diamond_percent.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DiamondPercentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DiamondPercent(props: &DiamondPercentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0Z"
+            />
+            <path d="M9.2 9.2h.01" />
+            <path d="m14.5 9.5-5 5" />
+            <path d="M14.7 14.8h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/diamond_plus.rs b/packages/yew/src/diamond_plus.rs
new file mode 100644
index 0000000..981fe89
--- /dev/null
+++ b/packages/yew/src/diamond_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DiamondPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DiamondPlus(props: &DiamondPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 8v8" />
+            <path
+                d="M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0z"
+            />
+            <path d="M8 12h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dice_1.rs b/packages/yew/src/dice_1.rs
new file mode 100644
index 0000000..ec715a7
--- /dev/null
+++ b/packages/yew/src/dice_1.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Dice1Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dice1(props: &Dice1Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <path d="M12 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dice_2.rs b/packages/yew/src/dice_2.rs
new file mode 100644
index 0000000..085e305
--- /dev/null
+++ b/packages/yew/src/dice_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Dice2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dice2(props: &Dice2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <path d="M15 9h.01" />
+            <path d="M9 15h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dice_3.rs b/packages/yew/src/dice_3.rs
new file mode 100644
index 0000000..5c3ad46
--- /dev/null
+++ b/packages/yew/src/dice_3.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Dice3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dice3(props: &Dice3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <path d="M16 8h.01" />
+            <path d="M12 12h.01" />
+            <path d="M8 16h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dice_4.rs b/packages/yew/src/dice_4.rs
new file mode 100644
index 0000000..0289507
--- /dev/null
+++ b/packages/yew/src/dice_4.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Dice4Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dice4(props: &Dice4Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <path d="M16 8h.01" />
+            <path d="M8 8h.01" />
+            <path d="M8 16h.01" />
+            <path d="M16 16h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dice_5.rs b/packages/yew/src/dice_5.rs
new file mode 100644
index 0000000..10a8c11
--- /dev/null
+++ b/packages/yew/src/dice_5.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Dice5Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dice5(props: &Dice5Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <path d="M16 8h.01" />
+            <path d="M8 8h.01" />
+            <path d="M8 16h.01" />
+            <path d="M16 16h.01" />
+            <path d="M12 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dice_6.rs b/packages/yew/src/dice_6.rs
new file mode 100644
index 0000000..e842242
--- /dev/null
+++ b/packages/yew/src/dice_6.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Dice6Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dice6(props: &Dice6Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <path d="M16 8h.01" />
+            <path d="M16 12h.01" />
+            <path d="M16 16h.01" />
+            <path d="M8 8h.01" />
+            <path d="M8 12h.01" />
+            <path d="M8 16h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dices.rs b/packages/yew/src/dices.rs
new file mode 100644
index 0000000..f01afd0
--- /dev/null
+++ b/packages/yew/src/dices.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DicesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dices(props: &DicesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="12" height="12" x="2" y="10" rx="2" ry="2" />
+            <path d="m17.92 14 3.5-3.5a2.24 2.24 0 0 0 0-3l-5-4.92a2.24 2.24 0 0 0-3 0L10 6" />
+            <path d="M6 18h.01" />
+            <path d="M10 14h.01" />
+            <path d="M15 6h.01" />
+            <path d="M18 9h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/diff.rs b/packages/yew/src/diff.rs
new file mode 100644
index 0000000..2f9bc60
--- /dev/null
+++ b/packages/yew/src/diff.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DiffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Diff(props: &DiffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v14" />
+            <path d="M5 10h14" />
+            <path d="M5 21h14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/disc.rs b/packages/yew/src/disc.rs
new file mode 100644
index 0000000..820cc27
--- /dev/null
+++ b/packages/yew/src/disc.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DiscProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Disc(props: &DiscProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <circle cx="12" cy="12" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/disc_2.rs b/packages/yew/src/disc_2.rs
new file mode 100644
index 0000000..a49de3e
--- /dev/null
+++ b/packages/yew/src/disc_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Disc2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Disc2(props: &Disc2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <circle cx="12" cy="12" r="4" />
+            <path d="M12 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/disc_3.rs b/packages/yew/src/disc_3.rs
new file mode 100644
index 0000000..27234cd
--- /dev/null
+++ b/packages/yew/src/disc_3.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Disc3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Disc3(props: &Disc3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M6 12c0-1.7.7-3.2 1.8-4.2" />
+            <circle cx="12" cy="12" r="2" />
+            <path d="M18 12c0 1.7-.7 3.2-1.8 4.2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/disc_album.rs b/packages/yew/src/disc_album.rs
new file mode 100644
index 0000000..0d1f7f1
--- /dev/null
+++ b/packages/yew/src/disc_album.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DiscAlbumProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DiscAlbum(props: &DiscAlbumProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <circle cx="12" cy="12" r="5" />
+            <path d="M12 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/divide.rs b/packages/yew/src/divide.rs
new file mode 100644
index 0000000..ae01378
--- /dev/null
+++ b/packages/yew/src/divide.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DivideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Divide(props: &DivideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="6" r="1" />
+            <line x1="5" x2="19" y1="12" y2="12" />
+            <circle cx="12" cy="18" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dna.rs b/packages/yew/src/dna.rs
new file mode 100644
index 0000000..eac5b3c
--- /dev/null
+++ b/packages/yew/src/dna.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DnaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dna(props: &DnaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10 16 1.5 1.5" />
+            <path d="m14 8-1.5-1.5" />
+            <path d="M15 2c-1.798 1.998-2.518 3.995-2.807 5.993" />
+            <path d="m16.5 10.5 1 1" />
+            <path d="m17 6-2.891-2.891" />
+            <path d="M2 15c6.667-6 13.333 0 20-6" />
+            <path d="m20 9 .891.891" />
+            <path d="M3.109 14.109 4 15" />
+            <path d="m6.5 12.5 1 1" />
+            <path d="m7 18 2.891 2.891" />
+            <path d="M9 22c1.798-1.998 2.518-3.995 2.807-5.993" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dna_off.rs b/packages/yew/src/dna_off.rs
new file mode 100644
index 0000000..664d2f9
--- /dev/null
+++ b/packages/yew/src/dna_off.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DnaOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DnaOff(props: &DnaOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2c-1.35 1.5-2.092 3-2.5 4.5L14 8" />
+            <path d="m17 6-2.891-2.891" />
+            <path d="M2 15c3.333-3 6.667-3 10-3" />
+            <path d="m2 2 20 20" />
+            <path d="m20 9 .891.891" />
+            <path d="M22 9c-1.5 1.35-3 2.092-4.5 2.5l-1-1" />
+            <path d="M3.109 14.109 4 15" />
+            <path d="m6.5 12.5 1 1" />
+            <path d="m7 18 2.891 2.891" />
+            <path d="M9 22c1.35-1.5 2.092-3 2.5-4.5L10 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dock.rs b/packages/yew/src/dock.rs
new file mode 100644
index 0000000..f182974
--- /dev/null
+++ b/packages/yew/src/dock.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dock(props: &DockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 8h20" />
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+            <path d="M6 16h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dog.rs b/packages/yew/src/dog.rs
new file mode 100644
index 0000000..ea80f4f
--- /dev/null
+++ b/packages/yew/src/dog.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dog(props: &DogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.25 16.25h1.5L12 17z" />
+            <path d="M16 14v.5" />
+            <path
+                d="M4.42 11.247A13.152 13.152 0 0 0 4 14.556C4 18.728 7.582 21 12 21s8-2.272 8-6.444a11.702 11.702 0 0 0-.493-3.309"
+            />
+            <path d="M8 14v.5" />
+            <path
+                d="M8.5 8.5c-.384 1.05-1.083 2.028-2.344 2.5-1.931.722-3.576-.297-3.656-1-.113-.994 1.177-6.53 4-7 1.923-.321 3.651.845 3.651 2.235A7.497 7.497 0 0 1 14 5.277c0-1.39 1.844-2.598 3.767-2.277 2.823.47 4.113 6.006 4 7-.08.703-1.725 1.722-3.656 1-1.261-.472-1.855-1.45-2.239-2.5"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dollar_sign.rs b/packages/yew/src/dollar_sign.rs
new file mode 100644
index 0000000..db4802f
--- /dev/null
+++ b/packages/yew/src/dollar_sign.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DollarSignProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DollarSign(props: &DollarSignProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="12" y1="2" y2="22" />
+            <path d="M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/donut.rs b/packages/yew/src/donut.rs
new file mode 100644
index 0000000..c6fbbab
--- /dev/null
+++ b/packages/yew/src/donut.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DonutProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Donut(props: &DonutProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20.5 10a2.5 2.5 0 0 1-2.4-3H18a2.95 2.95 0 0 1-2.6-4.4 10 10 0 1 0 6.3 7.1c-.3.2-.8.3-1.2.3"
+            />
+            <circle cx="12" cy="12" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/door_closed.rs b/packages/yew/src/door_closed.rs
new file mode 100644
index 0000000..66eec57
--- /dev/null
+++ b/packages/yew/src/door_closed.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DoorClosedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DoorClosed(props: &DoorClosedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 20V6a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v14" />
+            <path d="M2 20h20" />
+            <path d="M14 12v.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/door_open.rs b/packages/yew/src/door_open.rs
new file mode 100644
index 0000000..0c51c6d
--- /dev/null
+++ b/packages/yew/src/door_open.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DoorOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DoorOpen(props: &DoorOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 4h3a2 2 0 0 1 2 2v14" />
+            <path d="M2 20h3" />
+            <path d="M13 20h9" />
+            <path d="M10 12v.01" />
+            <path
+                d="M13 4.562v16.157a1 1 0 0 1-1.242.97L5 20V5.562a2 2 0 0 1 1.515-1.94l4-1A2 2 0 0 1 13 4.561Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dot.rs b/packages/yew/src/dot.rs
new file mode 100644
index 0000000..78b3678
--- /dev/null
+++ b/packages/yew/src/dot.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dot(props: &DotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12.1" cy="12.1" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/download.rs b/packages/yew/src/download.rs
new file mode 100644
index 0000000..f4f875e
--- /dev/null
+++ b/packages/yew/src/download.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DownloadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Download(props: &DownloadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+            <polyline points="7 10 12 15 17 10" />
+            <line x1="12" x2="12" y1="15" y2="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/drafting_compass.rs b/packages/yew/src/drafting_compass.rs
new file mode 100644
index 0000000..49d4aa2
--- /dev/null
+++ b/packages/yew/src/drafting_compass.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DraftingCompassProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn DraftingCompass(props: &DraftingCompassProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12.99 6.74 1.93 3.44" />
+            <path d="M19.136 12a10 10 0 0 1-14.271 0" />
+            <path d="m21 21-2.16-3.84" />
+            <path d="m3 21 8.02-14.26" />
+            <circle cx="12" cy="5" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/drama.rs b/packages/yew/src/drama.rs
new file mode 100644
index 0000000..70fcf98
--- /dev/null
+++ b/packages/yew/src/drama.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DramaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Drama(props: &DramaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 11h.01" />
+            <path d="M14 6h.01" />
+            <path d="M18 6h.01" />
+            <path d="M6.5 13.1h.01" />
+            <path d="M22 5c0 9-4 12-6 12s-6-3-6-12c0-2 2-3 6-3s6 1 6 3" />
+            <path d="M17.4 9.9c-.8.8-2 .8-2.8 0" />
+            <path
+                d="M10.1 7.1C9 7.2 7.7 7.7 6 8.6c-3.5 2-4.7 3.9-3.7 5.6 4.5 7.8 9.5 8.4 11.2 7.4.9-.5 1.9-2.1 1.9-4.7"
+            />
+            <path d="M9.1 16.5c.3-1.1 1.4-1.7 2.4-1.4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dribbble.rs b/packages/yew/src/dribbble.rs
new file mode 100644
index 0000000..048aee0
--- /dev/null
+++ b/packages/yew/src/dribbble.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DribbbleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dribbble(props: &DribbbleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M19.13 5.09C15.22 9.14 10 10.44 2.25 10.94" />
+            <path d="M21.75 12.84c-6.62-1.41-12.14 1-16.38 6.32" />
+            <path d="M8.56 2.75c4.37 6 6 9.42 8 17.72" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/drill.rs b/packages/yew/src/drill.rs
new file mode 100644
index 0000000..574a71a
--- /dev/null
+++ b/packages/yew/src/drill.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DrillProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Drill(props: &DrillProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 18a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1H5a3 3 0 0 1-3-3 1 1 0 0 1 1-1z" />
+            <path
+                d="M13 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a1 1 0 0 1 1 1v6a1 1 0 0 1-1 1l-.81 3.242a1 1 0 0 1-.97.758H8"
+            />
+            <path d="M14 4h3a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1h-3" />
+            <path d="M18 6h4" />
+            <path d="m5 10-2 8" />
+            <path d="m7 18 2-8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/droplet.rs b/packages/yew/src/droplet.rs
new file mode 100644
index 0000000..88293ff
--- /dev/null
+++ b/packages/yew/src/droplet.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DropletProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Droplet(props: &DropletProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 22a7 7 0 0 0 7-7c0-2-1-3.9-3-5.5s-3.5-4-4-6.5c-.5 2.5-2 4.9-4 6.5C6 11.1 5 13 5 15a7 7 0 0 0 7 7z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/droplets.rs b/packages/yew/src/droplets.rs
new file mode 100644
index 0000000..9a70970
--- /dev/null
+++ b/packages/yew/src/droplets.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DropletsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Droplets(props: &DropletsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M7 16.3c2.2 0 4-1.83 4-4.05 0-1.16-.57-2.26-1.71-3.19S7.29 6.75 7 5.3c-.29 1.45-1.14 2.84-2.29 3.76S3 11.1 3 12.25c0 2.22 1.8 4.05 4 4.05z"
+            />
+            <path
+                d="M12.56 6.6A10.97 10.97 0 0 0 14 3.02c.5 2.5 2 4.9 4 6.5s3 3.5 3 5.5a6.98 6.98 0 0 1-11.91 4.97"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/drum.rs b/packages/yew/src/drum.rs
new file mode 100644
index 0000000..7992ec6
--- /dev/null
+++ b/packages/yew/src/drum.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DrumProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Drum(props: &DrumProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 2 8 8" />
+            <path d="m22 2-8 8" />
+            <ellipse cx="12" cy="9" rx="10" ry="5" />
+            <path d="M7 13.4v7.9" />
+            <path d="M12 14v8" />
+            <path d="M17 13.4v7.9" />
+            <path d="M2 9v8a10 5 0 0 0 20 0V9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/drumstick.rs b/packages/yew/src/drumstick.rs
new file mode 100644
index 0000000..1144e79
--- /dev/null
+++ b/packages/yew/src/drumstick.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DrumstickProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Drumstick(props: &DrumstickProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.4 15.63a7.875 6 135 1 1 6.23-6.23 4.5 3.43 135 0 0-6.23 6.23" />
+            <path d="m8.29 12.71-2.6 2.6a2.5 2.5 0 1 0-1.65 4.65A2.5 2.5 0 1 0 8.7 18.3l2.59-2.59" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/dumbbell.rs b/packages/yew/src/dumbbell.rs
new file mode 100644
index 0000000..b9c27c0
--- /dev/null
+++ b/packages/yew/src/dumbbell.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct DumbbellProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Dumbbell(props: &DumbbellProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.4 14.4 9.6 9.6" />
+            <path
+                d="M18.657 21.485a2 2 0 1 1-2.829-2.828l-1.767 1.768a2 2 0 1 1-2.829-2.829l6.364-6.364a2 2 0 1 1 2.829 2.829l-1.768 1.767a2 2 0 1 1 2.828 2.829z"
+            />
+            <path d="m21.5 21.5-1.4-1.4" />
+            <path d="M3.9 3.9 2.5 2.5" />
+            <path
+                d="M6.404 12.768a2 2 0 1 1-2.829-2.829l1.768-1.767a2 2 0 1 1-2.828-2.829l2.828-2.828a2 2 0 1 1 2.829 2.828l1.767-1.768a2 2 0 1 1 2.829 2.829z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ear.rs b/packages/yew/src/ear.rs
new file mode 100644
index 0000000..174a217
--- /dev/null
+++ b/packages/yew/src/ear.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ear(props: &EarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8.5a6.5 6.5 0 1 1 13 0c0 6-6 6-6 10a3.5 3.5 0 1 1-7 0" />
+            <path d="M15 8.5a2.5 2.5 0 0 0-5 0v1a2 2 0 1 1 0 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ear_off.rs b/packages/yew/src/ear_off.rs
new file mode 100644
index 0000000..78161ae
--- /dev/null
+++ b/packages/yew/src/ear_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EarOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EarOff(props: &EarOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 18.5a3.5 3.5 0 1 0 7 0c0-1.57.92-2.52 2.04-3.46" />
+            <path d="M6 8.5c0-.75.13-1.47.36-2.14" />
+            <path d="M8.8 3.15A6.5 6.5 0 0 1 19 8.5c0 1.63-.44 2.81-1.09 3.76" />
+            <path d="M12.5 6A2.5 2.5 0 0 1 15 8.5M10 13a2 2 0 0 0 1.82-1.18" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/earth.rs b/packages/yew/src/earth.rs
new file mode 100644
index 0000000..a31c484
--- /dev/null
+++ b/packages/yew/src/earth.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EarthProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Earth(props: &EarthProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21.54 15H17a2 2 0 0 0-2 2v4.54" />
+            <path
+                d="M7 3.34V5a3 3 0 0 0 3 3a2 2 0 0 1 2 2c0 1.1.9 2 2 2a2 2 0 0 0 2-2c0-1.1.9-2 2-2h3.17"
+            />
+            <path d="M11 21.95V18a2 2 0 0 0-2-2a2 2 0 0 1-2-2v-1a2 2 0 0 0-2-2H2.05" />
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/earth_lock.rs b/packages/yew/src/earth_lock.rs
new file mode 100644
index 0000000..c96fe88
--- /dev/null
+++ b/packages/yew/src/earth_lock.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EarthLockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EarthLock(props: &EarthLockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 3.34V5a3 3 0 0 0 3 3" />
+            <path d="M11 21.95V18a2 2 0 0 0-2-2 2 2 0 0 1-2-2v-1a2 2 0 0 0-2-2H2.05" />
+            <path d="M21.54 15H17a2 2 0 0 0-2 2v4.54" />
+            <path d="M12 2a10 10 0 1 0 9.54 13" />
+            <path d="M20 6V4a2 2 0 1 0-4 0v2" />
+            <rect width="8" height="5" x="14" y="6" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/eclipse.rs b/packages/yew/src/eclipse.rs
new file mode 100644
index 0000000..216fa5f
--- /dev/null
+++ b/packages/yew/src/eclipse.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EclipseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Eclipse(props: &EclipseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M12 2a7 7 0 1 0 10 10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/egg.rs b/packages/yew/src/egg.rs
new file mode 100644
index 0000000..94bbe96
--- /dev/null
+++ b/packages/yew/src/egg.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EggProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Egg(props: &EggProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 22c6.23-.05 7.87-5.57 7.5-10-.36-4.34-3.95-9.96-7.5-10-3.55.04-7.14 5.66-7.5 10-.37 4.43 1.27 9.95 7.5 10z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/egg_fried.rs b/packages/yew/src/egg_fried.rs
new file mode 100644
index 0000000..db99fff
--- /dev/null
+++ b/packages/yew/src/egg_fried.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EggFriedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EggFried(props: &EggFriedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11.5" cy="12.5" r="3.5" />
+            <path
+                d="M3 8c0-3.5 2.5-6 6.5-6 5 0 4.83 3 7.5 5s5 2 5 6c0 4.5-2.5 6.5-7 6.5-2.5 0-2.5 2.5-6 2.5s-7-2-7-5.5c0-3 1.5-3 1.5-5C3.5 10 3 9 3 8Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/egg_off.rs b/packages/yew/src/egg_off.rs
new file mode 100644
index 0000000..a0e11e9
--- /dev/null
+++ b/packages/yew/src/egg_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EggOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EggOff(props: &EggOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M6.399 6.399C5.362 8.157 4.65 10.189 4.5 12c-.37 4.43 1.27 9.95 7.5 10 3.256-.026 5.259-1.547 6.375-3.625"
+            />
+            <path
+                d="M19.532 13.875A14.07 14.07 0 0 0 19.5 12c-.36-4.34-3.95-9.96-7.5-10-1.04.012-2.082.502-3.046 1.297"
+            />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ellipsis.rs b/packages/yew/src/ellipsis.rs
new file mode 100644
index 0000000..96ee232
--- /dev/null
+++ b/packages/yew/src/ellipsis.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EllipsisProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ellipsis(props: &EllipsisProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="1" />
+            <circle cx="19" cy="12" r="1" />
+            <circle cx="5" cy="12" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ellipsis_vertical.rs b/packages/yew/src/ellipsis_vertical.rs
new file mode 100644
index 0000000..e88decc
--- /dev/null
+++ b/packages/yew/src/ellipsis_vertical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EllipsisVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EllipsisVertical(props: &EllipsisVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="1" />
+            <circle cx="12" cy="5" r="1" />
+            <circle cx="12" cy="19" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/equal.rs b/packages/yew/src/equal.rs
new file mode 100644
index 0000000..504c7f5
--- /dev/null
+++ b/packages/yew/src/equal.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EqualProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Equal(props: &EqualProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="5" x2="19" y1="9" y2="9" />
+            <line x1="5" x2="19" y1="15" y2="15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/equal_approximately.rs b/packages/yew/src/equal_approximately.rs
new file mode 100644
index 0000000..417a4b7
--- /dev/null
+++ b/packages/yew/src/equal_approximately.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EqualApproximatelyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EqualApproximately(props: &EqualApproximatelyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 15a6.5 6.5 0 0 1 7 0 6.5 6.5 0 0 0 7 0" />
+            <path d="M5 9a6.5 6.5 0 0 1 7 0 6.5 6.5 0 0 0 7 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/equal_not.rs b/packages/yew/src/equal_not.rs
new file mode 100644
index 0000000..be54a83
--- /dev/null
+++ b/packages/yew/src/equal_not.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EqualNotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EqualNot(props: &EqualNotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="5" x2="19" y1="9" y2="9" />
+            <line x1="5" x2="19" y1="15" y2="15" />
+            <line x1="19" x2="5" y1="5" y2="19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/eraser.rs b/packages/yew/src/eraser.rs
new file mode 100644
index 0000000..eed206a
--- /dev/null
+++ b/packages/yew/src/eraser.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EraserProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Eraser(props: &EraserProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m7 21-4.3-4.3c-1-1-1-2.5 0-3.4l9.6-9.6c1-1 2.5-1 3.4 0l5.6 5.6c1 1 1 2.5 0 3.4L13 21"
+            />
+            <path d="M22 21H7" />
+            <path d="m5 11 9 9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ethernet_port.rs b/packages/yew/src/ethernet_port.rs
new file mode 100644
index 0000000..718a557
--- /dev/null
+++ b/packages/yew/src/ethernet_port.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EthernetPortProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EthernetPort(props: &EthernetPortProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3z"
+            />
+            <path d="M6 8v1" />
+            <path d="M10 8v1" />
+            <path d="M14 8v1" />
+            <path d="M18 8v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/euro.rs b/packages/yew/src/euro.rs
new file mode 100644
index 0000000..356059a
--- /dev/null
+++ b/packages/yew/src/euro.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EuroProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Euro(props: &EuroProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10h12" />
+            <path d="M4 14h9" />
+            <path
+                d="M19 6a7.7 7.7 0 0 0-5.2-2A7.9 7.9 0 0 0 6 12c0 4.4 3.5 8 7.8 8 2 0 3.8-.8 5.2-2"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/expand.rs b/packages/yew/src/expand.rs
new file mode 100644
index 0000000..fa2cc1e
--- /dev/null
+++ b/packages/yew/src/expand.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ExpandProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Expand(props: &ExpandProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21 21-6-6m6 6v-4.8m0 4.8h-4.8" />
+            <path d="M3 16.2V21m0 0h4.8M3 21l6-6" />
+            <path d="M21 7.8V3m0 0h-4.8M21 3l-6 6" />
+            <path d="M3 7.8V3m0 0h4.8M3 3l6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/external_link.rs b/packages/yew/src/external_link.rs
new file mode 100644
index 0000000..3afb327
--- /dev/null
+++ b/packages/yew/src/external_link.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ExternalLinkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ExternalLink(props: &ExternalLinkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 3h6v6" />
+            <path d="M10 14 21 3" />
+            <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/eye.rs b/packages/yew/src/eye.rs
new file mode 100644
index 0000000..ec4b451
--- /dev/null
+++ b/packages/yew/src/eye.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EyeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Eye(props: &EyeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.062 12.348a1 1 0 0 1 0-.696 10.75 10.75 0 0 1 19.876 0 1 1 0 0 1 0 .696 10.75 10.75 0 0 1-19.876 0"
+            />
+            <circle cx="12" cy="12" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/eye_closed.rs b/packages/yew/src/eye_closed.rs
new file mode 100644
index 0000000..81bb008
--- /dev/null
+++ b/packages/yew/src/eye_closed.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EyeClosedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EyeClosed(props: &EyeClosedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 18-.722-3.25" />
+            <path d="M2 8a10.645 10.645 0 0 0 20 0" />
+            <path d="m20 15-1.726-2.05" />
+            <path d="m4 15 1.726-2.05" />
+            <path d="m9 18 .722-3.25" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/eye_off.rs b/packages/yew/src/eye_off.rs
new file mode 100644
index 0000000..e6620ac
--- /dev/null
+++ b/packages/yew/src/eye_off.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct EyeOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn EyeOff(props: &EyeOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.733 5.076a10.744 10.744 0 0 1 11.205 6.575 1 1 0 0 1 0 .696 10.747 10.747 0 0 1-1.444 2.49"
+            />
+            <path d="M14.084 14.158a3 3 0 0 1-4.242-4.242" />
+            <path
+                d="M17.479 17.499a10.75 10.75 0 0 1-15.417-5.151 1 1 0 0 1 0-.696 10.75 10.75 0 0 1 4.446-5.143"
+            />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/facebook.rs b/packages/yew/src/facebook.rs
new file mode 100644
index 0000000..635bf3d
--- /dev/null
+++ b/packages/yew/src/facebook.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FacebookProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Facebook(props: &FacebookProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 2h-3a5 5 0 0 0-5 5v3H7v4h3v8h4v-8h3l1-4h-4V7a1 1 0 0 1 1-1h3z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/factory.rs b/packages/yew/src/factory.rs
new file mode 100644
index 0000000..5063606
--- /dev/null
+++ b/packages/yew/src/factory.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FactoryProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Factory(props: &FactoryProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 20a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V8l-7 5V8l-7 5V4a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"
+            />
+            <path d="M17 18h1" />
+            <path d="M12 18h1" />
+            <path d="M7 18h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fan.rs b/packages/yew/src/fan.rs
new file mode 100644
index 0000000..f467387
--- /dev/null
+++ b/packages/yew/src/fan.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Fan(props: &FanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.827 16.379a6.082 6.082 0 0 1-8.618-7.002l5.412 1.45a6.082 6.082 0 0 1 7.002-8.618l-1.45 5.412a6.082 6.082 0 0 1 8.618 7.002l-5.412-1.45a6.082 6.082 0 0 1-7.002 8.618l1.45-5.412Z"
+            />
+            <path d="M12 12v.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fast_forward.rs b/packages/yew/src/fast_forward.rs
new file mode 100644
index 0000000..531e255
--- /dev/null
+++ b/packages/yew/src/fast_forward.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FastForwardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FastForward(props: &FastForwardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="13 19 22 12 13 5 13 19" />
+            <polygon points="2 19 11 12 2 5 2 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/feather.rs b/packages/yew/src/feather.rs
new file mode 100644
index 0000000..6f8030d
--- /dev/null
+++ b/packages/yew/src/feather.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FeatherProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Feather(props: &FeatherProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12.67 19a2 2 0 0 0 1.416-.588l6.154-6.172a6 6 0 0 0-8.49-8.49L5.586 9.914A2 2 0 0 0 5 11.328V18a1 1 0 0 0 1 1z"
+            />
+            <path d="M16 8 2 22" />
+            <path d="M17.5 15H9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fence.rs b/packages/yew/src/fence.rs
new file mode 100644
index 0000000..6a28cbe
--- /dev/null
+++ b/packages/yew/src/fence.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FenceProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Fence(props: &FenceProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 3 2 5v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z" />
+            <path d="M6 8h4" />
+            <path d="M6 18h4" />
+            <path d="m12 3-2 2v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z" />
+            <path d="M14 8h4" />
+            <path d="M14 18h4" />
+            <path d="m20 3-2 2v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ferris_wheel.rs b/packages/yew/src/ferris_wheel.rs
new file mode 100644
index 0000000..babe4bf
--- /dev/null
+++ b/packages/yew/src/ferris_wheel.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FerrisWheelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FerrisWheel(props: &FerrisWheelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="2" />
+            <path d="M12 2v4" />
+            <path d="m6.8 15-3.5 2" />
+            <path d="m20.7 7-3.5 2" />
+            <path d="M6.8 9 3.3 7" />
+            <path d="m20.7 17-3.5-2" />
+            <path d="m9 22 3-8 3 8" />
+            <path d="M8 22h8" />
+            <path d="M18 18.7a9 9 0 1 0-12 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/figma.rs b/packages/yew/src/figma.rs
new file mode 100644
index 0000000..28169f0
--- /dev/null
+++ b/packages/yew/src/figma.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FigmaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Figma(props: &FigmaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 5.5A3.5 3.5 0 0 1 8.5 2H12v7H8.5A3.5 3.5 0 0 1 5 5.5z" />
+            <path d="M12 2h3.5a3.5 3.5 0 1 1 0 7H12V2z" />
+            <path d="M12 12.5a3.5 3.5 0 1 1 7 0 3.5 3.5 0 1 1-7 0z" />
+            <path d="M5 19.5A3.5 3.5 0 0 1 8.5 16H12v3.5a3.5 3.5 0 1 1-7 0z" />
+            <path d="M5 12.5A3.5 3.5 0 0 1 8.5 9H12v7H8.5A3.5 3.5 0 0 1 5 12.5z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file.rs b/packages/yew/src/file.rs
new file mode 100644
index 0000000..ad13f30
--- /dev/null
+++ b/packages/yew/src/file.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn File(props: &FileProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_archive.rs b/packages/yew/src/file_archive.rs
new file mode 100644
index 0000000..f014198
--- /dev/null
+++ b/packages/yew/src/file_archive.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileArchiveProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileArchive(props: &FileArchiveProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 12v-1" />
+            <path d="M10 18v-2" />
+            <path d="M10 7V6" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M15.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v16a2 2 0 0 0 .274 1.01" />
+            <circle cx="10" cy="20" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_audio.rs b/packages/yew/src/file_audio.rs
new file mode 100644
index 0000000..ae799b5
--- /dev/null
+++ b/packages/yew/src/file_audio.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileAudioProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileAudio(props: &FileAudioProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17.5 22h.5a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path
+                d="M2 19a2 2 0 1 1 4 0v1a2 2 0 1 1-4 0v-4a6 6 0 0 1 12 0v4a2 2 0 1 1-4 0v-1a2 2 0 1 1 4 0"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_audio_2.rs b/packages/yew/src/file_audio_2.rs
new file mode 100644
index 0000000..95e7f73
--- /dev/null
+++ b/packages/yew/src/file_audio_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileAudio2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileAudio2(props: &FileAudio2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v2" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <circle cx="3" cy="17" r="1" />
+            <path d="M2 17v-3a4 4 0 0 1 8 0v3" />
+            <circle cx="9" cy="17" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_axis_3_d.rs b/packages/yew/src/file_axis_3_d.rs
new file mode 100644
index 0000000..8f132d4
--- /dev/null
+++ b/packages/yew/src/file_axis_3_d.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileAxis3DProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileAxis3D(props: &FileAxis3DProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m8 18 4-4" />
+            <path d="M8 10v8h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_badge.rs b/packages/yew/src/file_badge.rs
new file mode 100644
index 0000000..5e1a0c2
--- /dev/null
+++ b/packages/yew/src/file_badge.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileBadgeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileBadge(props: &FileBadgeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22h6a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M5 17a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z" />
+            <path d="M7 16.5 8 22l-3-1-3 1 1-5.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_badge_2.rs b/packages/yew/src/file_badge_2.rs
new file mode 100644
index 0000000..7dffb1f
--- /dev/null
+++ b/packages/yew/src/file_badge_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileBadge2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileBadge2(props: &FileBadge2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <circle cx="12" cy="10" r="3" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m14 12.5 1 5.5-3-1-3 1 1-5.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_box.rs b/packages/yew/src/file_box.rs
new file mode 100644
index 0000000..2730d32
--- /dev/null
+++ b/packages/yew/src/file_box.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileBoxProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileBox(props: &FileBoxProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path
+                d="M3 13.1a2 2 0 0 0-1 1.76v3.24a2 2 0 0 0 .97 1.78L6 21.7a2 2 0 0 0 2.03.01L11 19.9a2 2 0 0 0 1-1.76V14.9a2 2 0 0 0-.97-1.78L8 11.3a2 2 0 0 0-2.03-.01Z"
+            />
+            <path d="M7 17v5" />
+            <path d="M11.7 14.2 7 17l-4.7-2.8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_chart_column.rs b/packages/yew/src/file_chart_column.rs
new file mode 100644
index 0000000..8b29c2a
--- /dev/null
+++ b/packages/yew/src/file_chart_column.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileChartColumnProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileChartColumn(props: &FileChartColumnProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M8 18v-1" />
+            <path d="M12 18v-6" />
+            <path d="M16 18v-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_chart_column_increasing.rs b/packages/yew/src/file_chart_column_increasing.rs
new file mode 100644
index 0000000..f2eae87
--- /dev/null
+++ b/packages/yew/src/file_chart_column_increasing.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileChartColumnIncreasingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileChartColumnIncreasing(props: &FileChartColumnIncreasingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M8 18v-2" />
+            <path d="M12 18v-4" />
+            <path d="M16 18v-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_chart_line.rs b/packages/yew/src/file_chart_line.rs
new file mode 100644
index 0000000..edefaf2
--- /dev/null
+++ b/packages/yew/src/file_chart_line.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileChartLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileChartLine(props: &FileChartLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m16 13-3.5 3.5-2-2L8 17" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_chart_pie.rs b/packages/yew/src/file_chart_pie.rs
new file mode 100644
index 0000000..96e25f8
--- /dev/null
+++ b/packages/yew/src/file_chart_pie.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileChartPieProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileChartPie(props: &FileChartPieProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M16 22h2a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3.5" />
+            <path d="M4.017 11.512a6 6 0 1 0 8.466 8.475" />
+            <path
+                d="M9 16a1 1 0 0 1-1-1v-4c0-.552.45-1.008.995-.917a6 6 0 0 1 4.922 4.922c.091.544-.365.995-.917.995z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_check.rs b/packages/yew/src/file_check.rs
new file mode 100644
index 0000000..52553ab
--- /dev/null
+++ b/packages/yew/src/file_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileCheck(props: &FileCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m9 15 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_check_2.rs b/packages/yew/src/file_check_2.rs
new file mode 100644
index 0000000..b9725f8
--- /dev/null
+++ b/packages/yew/src/file_check_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileCheck2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileCheck2(props: &FileCheck2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m3 15 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_clock.rs b/packages/yew/src/file_clock.rs
new file mode 100644
index 0000000..0a79c04
--- /dev/null
+++ b/packages/yew/src/file_clock.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileClockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileClock(props: &FileClockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 22h2a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <circle cx="8" cy="16" r="6" />
+            <path d="M9.5 17.5 8 16.25V14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_code.rs b/packages/yew/src/file_code.rs
new file mode 100644
index 0000000..a587a6d
--- /dev/null
+++ b/packages/yew/src/file_code.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileCode(props: &FileCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 12.5 8 15l2 2.5" />
+            <path d="m14 12.5 2 2.5-2 2.5" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_code_2.rs b/packages/yew/src/file_code_2.rs
new file mode 100644
index 0000000..b57391a
--- /dev/null
+++ b/packages/yew/src/file_code_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileCode2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileCode2(props: &FileCode2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m5 12-3 3 3 3" />
+            <path d="m9 18 3-3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_cog.rs b/packages/yew/src/file_cog.rs
new file mode 100644
index 0000000..11f813e
--- /dev/null
+++ b/packages/yew/src/file_cog.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileCog(props: &FileCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m3.2 12.9-.9-.4" />
+            <path d="m3.2 15.1-.9.4" />
+            <path d="M4.677 21.5a2 2 0 0 0 1.313.5H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v2.5" />
+            <path d="m4.9 11.2-.4-.9" />
+            <path d="m4.9 16.8-.4.9" />
+            <path d="m7.5 10.3-.4.9" />
+            <path d="m7.5 17.7-.4-.9" />
+            <path d="m9.7 12.5-.9.4" />
+            <path d="m9.7 15.5-.9-.4" />
+            <circle cx="6" cy="14" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_diff.rs b/packages/yew/src/file_diff.rs
new file mode 100644
index 0000000..5115279
--- /dev/null
+++ b/packages/yew/src/file_diff.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileDiffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileDiff(props: &FileDiffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M9 10h6" />
+            <path d="M12 13V7" />
+            <path d="M9 17h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_digit.rs b/packages/yew/src/file_digit.rs
new file mode 100644
index 0000000..66a2b23
--- /dev/null
+++ b/packages/yew/src/file_digit.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileDigitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileDigit(props: &FileDigitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <rect width="4" height="6" x="2" y="12" rx="2" />
+            <path d="M10 12h2v6" />
+            <path d="M10 18h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_down.rs b/packages/yew/src/file_down.rs
new file mode 100644
index 0000000..e28f124
--- /dev/null
+++ b/packages/yew/src/file_down.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileDown(props: &FileDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M12 18v-6" />
+            <path d="m9 15 3 3 3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_heart.rs b/packages/yew/src/file_heart.rs
new file mode 100644
index 0000000..f824981
--- /dev/null
+++ b/packages/yew/src/file_heart.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileHeartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileHeart(props: &FileHeartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v2" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path
+                d="M10.29 10.7a2.43 2.43 0 0 0-2.66-.52c-.29.12-.56.3-.78.53l-.35.34-.35-.34a2.43 2.43 0 0 0-2.65-.53c-.3.12-.56.3-.79.53-.95.94-1 2.53.2 3.74L6.5 18l3.6-3.55c1.2-1.21 1.14-2.8.19-3.74Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_image.rs b/packages/yew/src/file_image.rs
new file mode 100644
index 0000000..3176fe0
--- /dev/null
+++ b/packages/yew/src/file_image.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileImageProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileImage(props: &FileImageProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <circle cx="10" cy="12" r="2" />
+            <path d="m20 17-1.296-1.296a2.41 2.41 0 0 0-3.408 0L9 22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_input.rs b/packages/yew/src/file_input.rs
new file mode 100644
index 0000000..8215a8c
--- /dev/null
+++ b/packages/yew/src/file_input.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileInputProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileInput(props: &FileInputProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M2 15h10" />
+            <path d="m9 18 3-3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_json.rs b/packages/yew/src/file_json.rs
new file mode 100644
index 0000000..7b9f99a
--- /dev/null
+++ b/packages/yew/src/file_json.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileJsonProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileJson(props: &FileJsonProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M10 12a1 1 0 0 0-1 1v1a1 1 0 0 1-1 1 1 1 0 0 1 1 1v1a1 1 0 0 0 1 1" />
+            <path d="M14 18a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-1a1 1 0 0 0-1-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_json_2.rs b/packages/yew/src/file_json_2.rs
new file mode 100644
index 0000000..66ab65e
--- /dev/null
+++ b/packages/yew/src/file_json_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileJson2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileJson2(props: &FileJson2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M4 12a1 1 0 0 0-1 1v1a1 1 0 0 1-1 1 1 1 0 0 1 1 1v1a1 1 0 0 0 1 1" />
+            <path d="M8 18a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-1a1 1 0 0 0-1-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_key.rs b/packages/yew/src/file_key.rs
new file mode 100644
index 0000000..11f38f3
--- /dev/null
+++ b/packages/yew/src/file_key.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileKeyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileKey(props: &FileKeyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <circle cx="10" cy="16" r="2" />
+            <path d="m16 10-4.5 4.5" />
+            <path d="m15 11 1 1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_key_2.rs b/packages/yew/src/file_key_2.rs
new file mode 100644
index 0000000..7638964
--- /dev/null
+++ b/packages/yew/src/file_key_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileKey2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileKey2(props: &FileKey2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v6" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <circle cx="4" cy="16" r="2" />
+            <path d="m10 10-4.5 4.5" />
+            <path d="m9 11 1 1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_lock.rs b/packages/yew/src/file_lock.rs
new file mode 100644
index 0000000..5f27d69
--- /dev/null
+++ b/packages/yew/src/file_lock.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileLockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileLock(props: &FileLockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <rect width="8" height="6" x="8" y="12" rx="1" />
+            <path d="M10 12v-2a2 2 0 1 1 4 0v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_lock_2.rs b/packages/yew/src/file_lock_2.rs
new file mode 100644
index 0000000..6ca1af2
--- /dev/null
+++ b/packages/yew/src/file_lock_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileLock2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileLock2(props: &FileLock2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v1" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <rect width="8" height="5" x="2" y="13" rx="1" />
+            <path d="M8 13v-2a2 2 0 1 0-4 0v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_minus.rs b/packages/yew/src/file_minus.rs
new file mode 100644
index 0000000..63da751
--- /dev/null
+++ b/packages/yew/src/file_minus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileMinus(props: &FileMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M9 15h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_minus_2.rs b/packages/yew/src/file_minus_2.rs
new file mode 100644
index 0000000..5dc85dc
--- /dev/null
+++ b/packages/yew/src/file_minus_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileMinus2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileMinus2(props: &FileMinus2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M3 15h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_music.rs b/packages/yew/src/file_music.rs
new file mode 100644
index 0000000..09976e5
--- /dev/null
+++ b/packages/yew/src/file_music.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileMusicProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileMusic(props: &FileMusicProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v8.4" />
+            <path d="M8 18v-7.7L16 9v7" />
+            <circle cx="14" cy="16" r="2" />
+            <circle cx="6" cy="18" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_output.rs b/packages/yew/src/file_output.rs
new file mode 100644
index 0000000..5bed35a
--- /dev/null
+++ b/packages/yew/src/file_output.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileOutputProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileOutput(props: &FileOutputProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M4 7V4a2 2 0 0 1 2-2 2 2 0 0 0-2 2" />
+            <path d="M4.063 20.999a2 2 0 0 0 2 1L18 22a2 2 0 0 0 2-2V7l-5-5H6" />
+            <path d="m5 11-3 3" />
+            <path d="m5 17-3-3h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_pen.rs b/packages/yew/src/file_pen.rs
new file mode 100644
index 0000000..603c6ce
--- /dev/null
+++ b/packages/yew/src/file_pen.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FilePenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FilePen(props: &FilePenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v9.5" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path
+                d="M13.378 15.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_pen_line.rs b/packages/yew/src/file_pen_line.rs
new file mode 100644
index 0000000..15e8af6
--- /dev/null
+++ b/packages/yew/src/file_pen_line.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FilePenLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FilePenLine(props: &FilePenLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m18 5-2.414-2.414A2 2 0 0 0 14.172 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2"
+            />
+            <path
+                d="M21.378 12.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"
+            />
+            <path d="M8 18h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_plus.rs b/packages/yew/src/file_plus.rs
new file mode 100644
index 0000000..b2c2301
--- /dev/null
+++ b/packages/yew/src/file_plus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FilePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FilePlus(props: &FilePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M9 15h6" />
+            <path d="M12 18v-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_plus_2.rs b/packages/yew/src/file_plus_2.rs
new file mode 100644
index 0000000..5b34a11
--- /dev/null
+++ b/packages/yew/src/file_plus_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FilePlus2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FilePlus2(props: &FilePlus2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M3 15h6" />
+            <path d="M6 12v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_question.rs b/packages/yew/src/file_question.rs
new file mode 100644
index 0000000..c968eab
--- /dev/null
+++ b/packages/yew/src/file_question.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileQuestionProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileQuestion(props: &FileQuestionProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17h.01" />
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z" />
+            <path d="M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_scan.rs b/packages/yew/src/file_scan.rs
new file mode 100644
index 0000000..18bc342
--- /dev/null
+++ b/packages/yew/src/file_scan.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileScanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileScan(props: &FileScanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10V7l-5-5H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M16 14a2 2 0 0 0-2 2" />
+            <path d="M20 14a2 2 0 0 1 2 2" />
+            <path d="M20 22a2 2 0 0 0 2-2" />
+            <path d="M16 22a2 2 0 0 1-2-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_search.rs b/packages/yew/src/file_search.rs
new file mode 100644
index 0000000..c85f3b5
--- /dev/null
+++ b/packages/yew/src/file_search.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileSearch(props: &FileSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M4.268 21a2 2 0 0 0 1.727 1H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3" />
+            <path d="m9 18-1.5-1.5" />
+            <circle cx="5" cy="14" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_search_2.rs b/packages/yew/src/file_search_2.rs
new file mode 100644
index 0000000..b838743
--- /dev/null
+++ b/packages/yew/src/file_search_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileSearch2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileSearch2(props: &FileSearch2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <circle cx="11.5" cy="14.5" r="2.5" />
+            <path d="M13.3 16.3 15 18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_sliders.rs b/packages/yew/src/file_sliders.rs
new file mode 100644
index 0000000..b526c47
--- /dev/null
+++ b/packages/yew/src/file_sliders.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileSlidersProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileSliders(props: &FileSlidersProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M8 12h8" />
+            <path d="M10 11v2" />
+            <path d="M8 17h8" />
+            <path d="M14 16v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_spreadsheet.rs b/packages/yew/src/file_spreadsheet.rs
new file mode 100644
index 0000000..6a3828c
--- /dev/null
+++ b/packages/yew/src/file_spreadsheet.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileSpreadsheetProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileSpreadsheet(props: &FileSpreadsheetProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M8 13h2" />
+            <path d="M14 13h2" />
+            <path d="M8 17h2" />
+            <path d="M14 17h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_stack.rs b/packages/yew/src/file_stack.rs
new file mode 100644
index 0000000..28ca49c
--- /dev/null
+++ b/packages/yew/src/file_stack.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileStackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileStack(props: &FileStackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 7h-3a2 2 0 0 1-2-2V2" />
+            <path
+                d="M21 6v6.5c0 .8-.7 1.5-1.5 1.5h-7c-.8 0-1.5-.7-1.5-1.5v-9c0-.8.7-1.5 1.5-1.5H17Z"
+            />
+            <path d="M7 8v8.8c0 .3.2.6.4.8.2.2.5.4.8.4H15" />
+            <path d="M3 12v8.8c0 .3.2.6.4.8.2.2.5.4.8.4H11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_symlink.rs b/packages/yew/src/file_symlink.rs
new file mode 100644
index 0000000..a3d35d8
--- /dev/null
+++ b/packages/yew/src/file_symlink.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileSymlinkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileSymlink(props: &FileSymlinkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10 18 3-3-3-3" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path
+                d="M4 11V4a2 2 0 0 1 2-2h9l5 5v13a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h7"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_terminal.rs b/packages/yew/src/file_terminal.rs
new file mode 100644
index 0000000..f8f20dd
--- /dev/null
+++ b/packages/yew/src/file_terminal.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileTerminalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileTerminal(props: &FileTerminalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m8 16 2-2-2-2" />
+            <path d="M12 18h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_text.rs b/packages/yew/src/file_text.rs
new file mode 100644
index 0000000..1af2249
--- /dev/null
+++ b/packages/yew/src/file_text.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileText(props: &FileTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M10 9H8" />
+            <path d="M16 13H8" />
+            <path d="M16 17H8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_type.rs b/packages/yew/src/file_type.rs
new file mode 100644
index 0000000..cf32da4
--- /dev/null
+++ b/packages/yew/src/file_type.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileTypeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileType(props: &FileTypeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M9 13v-1h6v1" />
+            <path d="M12 12v6" />
+            <path d="M11 18h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_type_2.rs b/packages/yew/src/file_type_2.rs
new file mode 100644
index 0000000..1afb6f7
--- /dev/null
+++ b/packages/yew/src/file_type_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileType2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileType2(props: &FileType2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M2 13v-1h6v1" />
+            <path d="M5 12v6" />
+            <path d="M4 18h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_up.rs b/packages/yew/src/file_up.rs
new file mode 100644
index 0000000..661aeb5
--- /dev/null
+++ b/packages/yew/src/file_up.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileUp(props: &FileUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M12 12v6" />
+            <path d="m15 15-3-3-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_user.rs b/packages/yew/src/file_user.rs
new file mode 100644
index 0000000..121d668
--- /dev/null
+++ b/packages/yew/src/file_user.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileUserProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileUser(props: &FileUserProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M15 18a3 3 0 1 0-6 0" />
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z" />
+            <circle cx="12" cy="13" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_video.rs b/packages/yew/src/file_video.rs
new file mode 100644
index 0000000..f43baff
--- /dev/null
+++ b/packages/yew/src/file_video.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileVideoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileVideo(props: &FileVideoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m10 11 5 3-5 3v-6Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_video_2.rs b/packages/yew/src/file_video_2.rs
new file mode 100644
index 0000000..1ad6a6d
--- /dev/null
+++ b/packages/yew/src/file_video_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileVideo2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileVideo2(props: &FileVideo2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <rect width="8" height="6" x="2" y="12" rx="1" />
+            <path d="m10 15.5 4 2.5v-6l-4 2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_volume.rs b/packages/yew/src/file_volume.rs
new file mode 100644
index 0000000..34137d9
--- /dev/null
+++ b/packages/yew/src/file_volume.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileVolumeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileVolume(props: &FileVolumeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 11a5 5 0 0 1 0 6" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M4 6.765V4a2 2 0 0 1 2-2h9l5 5v13a2 2 0 0 1-2 2H6a2 2 0 0 1-.93-.23" />
+            <path
+                d="M7 10.51a.5.5 0 0 0-.826-.38l-1.893 1.628A1 1 0 0 1 3.63 12H2.5a.5.5 0 0 0-.5.5v3a.5.5 0 0 0 .5.5h1.129a1 1 0 0 1 .652.242l1.893 1.63a.5.5 0 0 0 .826-.38z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_volume_2.rs b/packages/yew/src/file_volume_2.rs
new file mode 100644
index 0000000..59762ff
--- /dev/null
+++ b/packages/yew/src/file_volume_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileVolume2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileVolume2(props: &FileVolume2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="M8 15h.01" />
+            <path d="M11.5 13.5a2.5 2.5 0 0 1 0 3" />
+            <path d="M15 12a5 5 0 0 1 0 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_warning.rs b/packages/yew/src/file_warning.rs
new file mode 100644
index 0000000..980fb43
--- /dev/null
+++ b/packages/yew/src/file_warning.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileWarningProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileWarning(props: &FileWarningProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M12 9v4" />
+            <path d="M12 17h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_x.rs b/packages/yew/src/file_x.rs
new file mode 100644
index 0000000..94839e1
--- /dev/null
+++ b/packages/yew/src/file_x.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileX(props: &FileXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m14.5 12.5-5 5" />
+            <path d="m9.5 12.5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/file_x_2.rs b/packages/yew/src/file_x_2.rs
new file mode 100644
index 0000000..26c492f
--- /dev/null
+++ b/packages/yew/src/file_x_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FileX2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FileX2(props: &FileX2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4" />
+            <path d="M14 2v4a2 2 0 0 0 2 2h4" />
+            <path d="m8 12.5-5 5" />
+            <path d="m3 12.5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/files.rs b/packages/yew/src/files.rs
new file mode 100644
index 0000000..0d21638
--- /dev/null
+++ b/packages/yew/src/files.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FilesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Files(props: &FilesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 7h-3a2 2 0 0 1-2-2V2" />
+            <path d="M9 18a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h7l4 4v10a2 2 0 0 1-2 2Z" />
+            <path d="M3 7.6v12.8A1.6 1.6 0 0 0 4.6 22h9.8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/film.rs b/packages/yew/src/film.rs
new file mode 100644
index 0000000..85b2a24
--- /dev/null
+++ b/packages/yew/src/film.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FilmProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Film(props: &FilmProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M7 3v18" />
+            <path d="M3 7.5h4" />
+            <path d="M3 12h18" />
+            <path d="M3 16.5h4" />
+            <path d="M17 3v18" />
+            <path d="M17 7.5h4" />
+            <path d="M17 16.5h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/filter.rs b/packages/yew/src/filter.rs
new file mode 100644
index 0000000..9a2f940
--- /dev/null
+++ b/packages/yew/src/filter.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FilterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Filter(props: &FilterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/filter_x.rs b/packages/yew/src/filter_x.rs
new file mode 100644
index 0000000..2972789
--- /dev/null
+++ b/packages/yew/src/filter_x.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FilterXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FilterX(props: &FilterXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.013 3H2l8 9.46V19l4 2v-8.54l.9-1.055" />
+            <path d="m22 3-5 5" />
+            <path d="m17 3 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fingerprint.rs b/packages/yew/src/fingerprint.rs
new file mode 100644
index 0000000..736980a
--- /dev/null
+++ b/packages/yew/src/fingerprint.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FingerprintProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Fingerprint(props: &FingerprintProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 10a2 2 0 0 0-2 2c0 1.02-.1 2.51-.26 4" />
+            <path d="M14 13.12c0 2.38 0 6.38-1 8.88" />
+            <path d="M17.29 21.02c.12-.6.43-2.3.5-3.02" />
+            <path d="M2 12a10 10 0 0 1 18-6" />
+            <path d="M2 16h.01" />
+            <path d="M21.8 16c.2-2 .131-5.354 0-6" />
+            <path d="M5 19.5C5.5 18 6 15 6 12a6 6 0 0 1 .34-2" />
+            <path d="M8.65 22c.21-.66.45-1.32.57-2" />
+            <path d="M9 6.8a6 6 0 0 1 9 5.2v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fire_extinguisher.rs b/packages/yew/src/fire_extinguisher.rs
new file mode 100644
index 0000000..0a9fb7f
--- /dev/null
+++ b/packages/yew/src/fire_extinguisher.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FireExtinguisherProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FireExtinguisher(props: &FireExtinguisherProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 6.5V3a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v3.5" />
+            <path d="M9 18h8" />
+            <path d="M18 3h-3" />
+            <path d="M11 3a6 6 0 0 0-6 6v11" />
+            <path d="M5 13h4" />
+            <path d="M17 10a4 4 0 0 0-8 0v10a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fish.rs b/packages/yew/src/fish.rs
new file mode 100644
index 0000000..b815414
--- /dev/null
+++ b/packages/yew/src/fish.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FishProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Fish(props: &FishProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M6.5 12c.94-3.46 4.94-6 8.5-6 3.56 0 6.06 2.54 7 6-.94 3.47-3.44 6-7 6s-7.56-2.53-8.5-6Z"
+            />
+            <path d="M18 12v.5" />
+            <path d="M16 17.93a9.77 9.77 0 0 1 0-11.86" />
+            <path
+                d="M7 10.67C7 8 5.58 5.97 2.73 5.5c-1 1.5-1 5 .23 6.5-1.24 1.5-1.24 5-.23 6.5C5.58 18.03 7 16 7 13.33"
+            />
+            <path d="M10.46 7.26C10.2 5.88 9.17 4.24 8 3h5.8a2 2 0 0 1 1.98 1.67l.23 1.4" />
+            <path d="m16.01 17.93-.23 1.4A2 2 0 0 1 13.8 21H9.5a5.96 5.96 0 0 0 1.49-3.98" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fish_off.rs b/packages/yew/src/fish_off.rs
new file mode 100644
index 0000000..1b95c10
--- /dev/null
+++ b/packages/yew/src/fish_off.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FishOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FishOff(props: &FishOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M18 12.47v.03m0-.5v.47m-.475 5.056A6.744 6.744 0 0 1 15 18c-3.56 0-7.56-2.53-8.5-6 .348-1.28 1.114-2.433 2.121-3.38m3.444-2.088A8.802 8.802 0 0 1 15 6c3.56 0 6.06 2.54 7 6-.309 1.14-.786 2.177-1.413 3.058"
+            />
+            <path
+                d="M7 10.67C7 8 5.58 5.97 2.73 5.5c-1 1.5-1 5 .23 6.5-1.24 1.5-1.24 5-.23 6.5C5.58 18.03 7 16 7 13.33m7.48-4.372A9.77 9.77 0 0 1 16 6.07m0 11.86a9.77 9.77 0 0 1-1.728-3.618"
+            />
+            <path
+                d="m16.01 17.93-.23 1.4A2 2 0 0 1 13.8 21H9.5a5.96 5.96 0 0 0 1.49-3.98M8.53 3h5.27a2 2 0 0 1 1.98 1.67l.23 1.4M2 2l20 20"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fish_symbol.rs b/packages/yew/src/fish_symbol.rs
new file mode 100644
index 0000000..0233df5
--- /dev/null
+++ b/packages/yew/src/fish_symbol.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FishSymbolProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FishSymbol(props: &FishSymbolProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 16s9-15 20-4C11 23 2 8 2 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flag.rs b/packages/yew/src/flag.rs
new file mode 100644
index 0000000..5e874a3
--- /dev/null
+++ b/packages/yew/src/flag.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlagProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Flag(props: &FlagProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 15s1-1 4-1 5 2 8 2 4-1 4-1V3s-1 1-4 1-5-2-8-2-4 1-4 1z" />
+            <line x1="4" x2="4" y1="22" y2="15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flag_off.rs b/packages/yew/src/flag_off.rs
new file mode 100644
index 0000000..2928f97
--- /dev/null
+++ b/packages/yew/src/flag_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlagOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlagOff(props: &FlagOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2c3 0 5 2 8 2s4-1 4-1v11" />
+            <path d="M4 22V4" />
+            <path d="M4 15s1-1 4-1 5 2 8 2" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flag_triangle_left.rs b/packages/yew/src/flag_triangle_left.rs
new file mode 100644
index 0000000..c65d8b3
--- /dev/null
+++ b/packages/yew/src/flag_triangle_left.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlagTriangleLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlagTriangleLeft(props: &FlagTriangleLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 22V2L7 7l10 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flag_triangle_right.rs b/packages/yew/src/flag_triangle_right.rs
new file mode 100644
index 0000000..d8fd49d
--- /dev/null
+++ b/packages/yew/src/flag_triangle_right.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlagTriangleRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlagTriangleRight(props: &FlagTriangleRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 22V2l10 5-10 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flame.rs b/packages/yew/src/flame.rs
new file mode 100644
index 0000000..d3ce56e
--- /dev/null
+++ b/packages/yew/src/flame.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlameProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Flame(props: &FlameProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M8.5 14.5A2.5 2.5 0 0 0 11 12c0-1.38-.5-2-1-3-1.072-2.143-.224-4.054 2-6 .5 2.5 2 4.9 4 6.5 2 1.6 3 3.5 3 5.5a7 7 0 1 1-14 0c0-1.153.433-2.294 1-3a2.5 2.5 0 0 0 2.5 2.5z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flame_kindling.rs b/packages/yew/src/flame_kindling.rs
new file mode 100644
index 0000000..efc895b
--- /dev/null
+++ b/packages/yew/src/flame_kindling.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlameKindlingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlameKindling(props: &FlameKindlingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 2c1 3 2.5 3.5 3.5 4.5A5 5 0 0 1 17 10a5 5 0 1 1-10 0c0-.3 0-.6.1-.9a2 2 0 1 0 3.3-2C8 4.5 11 2 12 2Z"
+            />
+            <path d="m5 22 14-4" />
+            <path d="m5 18 14 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flashlight.rs b/packages/yew/src/flashlight.rs
new file mode 100644
index 0000000..9b3c175
--- /dev/null
+++ b/packages/yew/src/flashlight.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlashlightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Flashlight(props: &FlashlightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 6c0 2-2 2-2 4v10a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2V10c0-2-2-2-2-4V2h12z" />
+            <line x1="6" x2="18" y1="6" y2="6" />
+            <line x1="12" x2="12" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flashlight_off.rs b/packages/yew/src/flashlight_off.rs
new file mode 100644
index 0000000..8eaa3bb
--- /dev/null
+++ b/packages/yew/src/flashlight_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlashlightOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlashlightOff(props: &FlashlightOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 16v4a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2V10c0-2-2-2-2-4" />
+            <path d="M7 2h11v4c0 2-2 2-2 4v1" />
+            <line x1="11" x2="18" y1="6" y2="6" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flask_conical.rs b/packages/yew/src/flask_conical.rs
new file mode 100644
index 0000000..52f07e6
--- /dev/null
+++ b/packages/yew/src/flask_conical.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlaskConicalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlaskConical(props: &FlaskConicalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10 2v7.527a2 2 0 0 1-.211.896L4.72 20.55a1 1 0 0 0 .9 1.45h12.76a1 1 0 0 0 .9-1.45l-5.069-10.127A2 2 0 0 1 14 9.527V2"
+            />
+            <path d="M8.5 2h7" />
+            <path d="M7 16h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flask_conical_off.rs b/packages/yew/src/flask_conical_off.rs
new file mode 100644
index 0000000..c3c2eb1
--- /dev/null
+++ b/packages/yew/src/flask_conical_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlaskConicalOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlaskConicalOff(props: &FlaskConicalOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10 4.72 20.55a1 1 0 0 0 .9 1.45h12.76a1 1 0 0 0 .9-1.45l-1.272-2.542" />
+            <path d="M10 2v2.343" />
+            <path d="M14 2v6.343" />
+            <path d="M8.5 2h7" />
+            <path d="M7 16h9" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flask_round.rs b/packages/yew/src/flask_round.rs
new file mode 100644
index 0000000..8d81635
--- /dev/null
+++ b/packages/yew/src/flask_round.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlaskRoundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlaskRound(props: &FlaskRoundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v7.31" />
+            <path d="M14 9.3V1.99" />
+            <path d="M8.5 2h7" />
+            <path d="M14 9.3a6.5 6.5 0 1 1-4 0" />
+            <path d="M5.52 16h12.96" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flip_horizontal.rs b/packages/yew/src/flip_horizontal.rs
new file mode 100644
index 0000000..74916cf
--- /dev/null
+++ b/packages/yew/src/flip_horizontal.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlipHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlipHorizontal(props: &FlipHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h3" />
+            <path d="M16 3h3a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-3" />
+            <path d="M12 20v2" />
+            <path d="M12 14v2" />
+            <path d="M12 8v2" />
+            <path d="M12 2v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flip_horizontal_2.rs b/packages/yew/src/flip_horizontal_2.rs
new file mode 100644
index 0000000..b28a386
--- /dev/null
+++ b/packages/yew/src/flip_horizontal_2.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlipHorizontal2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlipHorizontal2(props: &FlipHorizontal2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 7 5 5-5 5V7" />
+            <path d="m21 7-5 5 5 5V7" />
+            <path d="M12 20v2" />
+            <path d="M12 14v2" />
+            <path d="M12 8v2" />
+            <path d="M12 2v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flip_vertical.rs b/packages/yew/src/flip_vertical.rs
new file mode 100644
index 0000000..1fa8890
--- /dev/null
+++ b/packages/yew/src/flip_vertical.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlipVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlipVertical(props: &FlipVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 8V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v3" />
+            <path d="M21 16v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-3" />
+            <path d="M4 12H2" />
+            <path d="M10 12H8" />
+            <path d="M16 12h-2" />
+            <path d="M22 12h-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flip_vertical_2.rs b/packages/yew/src/flip_vertical_2.rs
new file mode 100644
index 0000000..fa2cec2
--- /dev/null
+++ b/packages/yew/src/flip_vertical_2.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlipVertical2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FlipVertical2(props: &FlipVertical2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 3-5 5-5-5h10" />
+            <path d="m17 21-5-5-5 5h10" />
+            <path d="M4 12H2" />
+            <path d="M10 12H8" />
+            <path d="M16 12h-2" />
+            <path d="M22 12h-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flower.rs b/packages/yew/src/flower.rs
new file mode 100644
index 0000000..70437c6
--- /dev/null
+++ b/packages/yew/src/flower.rs
@@ -0,0 +1,55 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FlowerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Flower(props: &FlowerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3" />
+            <path
+                d="M12 16.5A4.5 4.5 0 1 1 7.5 12 4.5 4.5 0 1 1 12 7.5a4.5 4.5 0 1 1 4.5 4.5 4.5 4.5 0 1 1-4.5 4.5"
+            />
+            <path d="M12 7.5V9" />
+            <path d="M7.5 12H9" />
+            <path d="M16.5 12H15" />
+            <path d="M12 16.5V15" />
+            <path d="m8 8 1.88 1.88" />
+            <path d="M14.12 9.88 16 8" />
+            <path d="m8 16 1.88-1.88" />
+            <path d="M14.12 14.12 16 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/flower_2.rs b/packages/yew/src/flower_2.rs
new file mode 100644
index 0000000..f981626
--- /dev/null
+++ b/packages/yew/src/flower_2.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Flower2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Flower2(props: &Flower2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 5a3 3 0 1 1 3 3m-3-3a3 3 0 1 0-3 3m3-3v1M9 8a3 3 0 1 0 3 3M9 8h1m5 0a3 3 0 1 1-3 3m3-3h-1m-2 3v-1"
+            />
+            <circle cx="12" cy="8" r="2" />
+            <path d="M12 10v12" />
+            <path d="M12 22c4.2 0 7-1.667 7-5-4.2 0-7 1.667-7 5Z" />
+            <path d="M12 22c-4.2 0-7-1.667-7-5 4.2 0 7 1.667 7 5Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/focus.rs b/packages/yew/src/focus.rs
new file mode 100644
index 0000000..7ed806c
--- /dev/null
+++ b/packages/yew/src/focus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FocusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Focus(props: &FocusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3" />
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fold_horizontal.rs b/packages/yew/src/fold_horizontal.rs
new file mode 100644
index 0000000..49aaef7
--- /dev/null
+++ b/packages/yew/src/fold_horizontal.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FoldHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FoldHorizontal(props: &FoldHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12h6" />
+            <path d="M22 12h-6" />
+            <path d="M12 2v2" />
+            <path d="M12 8v2" />
+            <path d="M12 14v2" />
+            <path d="M12 20v2" />
+            <path d="m19 9-3 3 3 3" />
+            <path d="m5 15 3-3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fold_vertical.rs b/packages/yew/src/fold_vertical.rs
new file mode 100644
index 0000000..2b5e35f
--- /dev/null
+++ b/packages/yew/src/fold_vertical.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FoldVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FoldVertical(props: &FoldVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-6" />
+            <path d="M12 8V2" />
+            <path d="M4 12H2" />
+            <path d="M10 12H8" />
+            <path d="M16 12h-2" />
+            <path d="M22 12h-2" />
+            <path d="m15 19-3-3-3 3" />
+            <path d="m15 5-3 3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder.rs b/packages/yew/src/folder.rs
new file mode 100644
index 0000000..1a51f1b
--- /dev/null
+++ b/packages/yew/src/folder.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Folder(props: &FolderProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_archive.rs b/packages/yew/src/folder_archive.rs
new file mode 100644
index 0000000..aa4de40
--- /dev/null
+++ b/packages/yew/src/folder_archive.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderArchiveProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderArchive(props: &FolderArchiveProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="15" cy="19" r="2" />
+            <path
+                d="M20.9 19.8A2 2 0 0 0 22 18V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2h5.1"
+            />
+            <path d="M15 11v-1" />
+            <path d="M15 17v-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_check.rs b/packages/yew/src/folder_check.rs
new file mode 100644
index 0000000..c9d3f6e
--- /dev/null
+++ b/packages/yew/src/folder_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderCheck(props: &FolderCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+            <path d="m9 13 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_clock.rs b/packages/yew/src/folder_clock.rs
new file mode 100644
index 0000000..17f0d0b
--- /dev/null
+++ b/packages/yew/src/folder_clock.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderClockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderClock(props: &FolderClockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="16" cy="16" r="6" />
+            <path
+                d="M7 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2"
+            />
+            <path d="M16 14v2l1 1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_closed.rs b/packages/yew/src/folder_closed.rs
new file mode 100644
index 0000000..1f4cca0
--- /dev/null
+++ b/packages/yew/src/folder_closed.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderClosedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderClosed(props: &FolderClosedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+            <path d="M2 10h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_code.rs b/packages/yew/src/folder_code.rs
new file mode 100644
index 0000000..3cd3073
--- /dev/null
+++ b/packages/yew/src/folder_code.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderCode(props: &FolderCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10.5 8 13l2 2.5" />
+            <path d="m14 10.5 2 2.5-2 2.5" />
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_cog.rs b/packages/yew/src/folder_cog.rs
new file mode 100644
index 0000000..f778872
--- /dev/null
+++ b/packages/yew/src/folder_cog.rs
@@ -0,0 +1,55 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderCog(props: &FolderCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3" />
+            <path
+                d="M10.3 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v3.3"
+            />
+            <path d="m21.7 19.4-.9-.3" />
+            <path d="m15.2 16.9-.9-.3" />
+            <path d="m16.6 21.7.3-.9" />
+            <path d="m19.1 15.2.3-.9" />
+            <path d="m19.6 21.7-.4-1" />
+            <path d="m16.8 15.3-.4-1" />
+            <path d="m14.3 19.6 1-.4" />
+            <path d="m20.7 16.8 1-.4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_dot.rs b/packages/yew/src/folder_dot.rs
new file mode 100644
index 0000000..2096bfc
--- /dev/null
+++ b/packages/yew/src/folder_dot.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderDot(props: &FolderDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"
+            />
+            <circle cx="12" cy="13" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_down.rs b/packages/yew/src/folder_down.rs
new file mode 100644
index 0000000..c1348dc
--- /dev/null
+++ b/packages/yew/src/folder_down.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderDown(props: &FolderDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+            <path d="M12 10v6" />
+            <path d="m15 13-3 3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_git.rs b/packages/yew/src/folder_git.rs
new file mode 100644
index 0000000..1d8944e
--- /dev/null
+++ b/packages/yew/src/folder_git.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderGitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderGit(props: &FolderGitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="13" r="2" />
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+            <path d="M14 13h3" />
+            <path d="M7 13h3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_git_2.rs b/packages/yew/src/folder_git_2.rs
new file mode 100644
index 0000000..57b9a57
--- /dev/null
+++ b/packages/yew/src/folder_git_2.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderGit2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderGit2(props: &FolderGit2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M9 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v5"
+            />
+            <circle cx="13" cy="12" r="2" />
+            <path d="M18 19c-2.8 0-5-2.2-5-5v8" />
+            <circle cx="20" cy="19" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_heart.rs b/packages/yew/src/folder_heart.rs
new file mode 100644
index 0000000..b9dde38
--- /dev/null
+++ b/packages/yew/src/folder_heart.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderHeartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderHeart(props: &FolderHeartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v1.5"
+            />
+            <path
+                d="M13.9 17.45c-1.2-1.2-1.14-2.8-.2-3.73a2.43 2.43 0 0 1 3.44 0l.36.34.34-.34a2.43 2.43 0 0 1 3.45-.01c.95.95 1 2.53-.2 3.74L17.5 21Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_input.rs b/packages/yew/src/folder_input.rs
new file mode 100644
index 0000000..6f42363
--- /dev/null
+++ b/packages/yew/src/folder_input.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderInputProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderInput(props: &FolderInputProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-1"
+            />
+            <path d="M2 13h10" />
+            <path d="m9 16 3-3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_kanban.rs b/packages/yew/src/folder_kanban.rs
new file mode 100644
index 0000000..cf60d7f
--- /dev/null
+++ b/packages/yew/src/folder_kanban.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderKanbanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderKanban(props: &FolderKanbanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"
+            />
+            <path d="M8 10v4" />
+            <path d="M12 10v2" />
+            <path d="M16 10v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_key.rs b/packages/yew/src/folder_key.rs
new file mode 100644
index 0000000..feba8ae
--- /dev/null
+++ b/packages/yew/src/folder_key.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderKeyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderKey(props: &FolderKeyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="16" cy="20" r="2" />
+            <path
+                d="M10 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v2"
+            />
+            <path d="m22 14-4.5 4.5" />
+            <path d="m21 15 1 1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_lock.rs b/packages/yew/src/folder_lock.rs
new file mode 100644
index 0000000..ec32536
--- /dev/null
+++ b/packages/yew/src/folder_lock.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderLockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderLock(props: &FolderLockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="5" x="14" y="17" rx="1" />
+            <path
+                d="M10 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v2.5"
+            />
+            <path d="M20 17v-2a2 2 0 1 0-4 0v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_minus.rs b/packages/yew/src/folder_minus.rs
new file mode 100644
index 0000000..019a4ef
--- /dev/null
+++ b/packages/yew/src/folder_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderMinus(props: &FolderMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 13h6" />
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_open.rs b/packages/yew/src/folder_open.rs
new file mode 100644
index 0000000..f17f7c5
--- /dev/null
+++ b/packages/yew/src/folder_open.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderOpen(props: &FolderOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_open_dot.rs b/packages/yew/src/folder_open_dot.rs
new file mode 100644
index 0000000..076c686
--- /dev/null
+++ b/packages/yew/src/folder_open_dot.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderOpenDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderOpenDot(props: &FolderOpenDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m6 14 1.45-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.55 6a2 2 0 0 1-1.94 1.5H4a2 2 0 0 1-2-2V5c0-1.1.9-2 2-2h3.93a2 2 0 0 1 1.66.9l.82 1.2a2 2 0 0 0 1.66.9H18a2 2 0 0 1 2 2v2"
+            />
+            <circle cx="14" cy="15" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_output.rs b/packages/yew/src/folder_output.rs
new file mode 100644
index 0000000..9a68459
--- /dev/null
+++ b/packages/yew/src/folder_output.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderOutputProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderOutput(props: &FolderOutputProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 7.5V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-1.5"
+            />
+            <path d="M2 13h10" />
+            <path d="m5 10-3 3 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_pen.rs b/packages/yew/src/folder_pen.rs
new file mode 100644
index 0000000..43ccdde
--- /dev/null
+++ b/packages/yew/src/folder_pen.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderPenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderPen(props: &FolderPenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 11.5V5a2 2 0 0 1 2-2h3.9c.7 0 1.3.3 1.7.9l.8 1.2c.4.6 1 .9 1.7.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-9.5"
+            />
+            <path
+                d="M11.378 13.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_plus.rs b/packages/yew/src/folder_plus.rs
new file mode 100644
index 0000000..b8989a6
--- /dev/null
+++ b/packages/yew/src/folder_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderPlus(props: &FolderPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 10v6" />
+            <path d="M9 13h6" />
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_root.rs b/packages/yew/src/folder_root.rs
new file mode 100644
index 0000000..2353534
--- /dev/null
+++ b/packages/yew/src/folder_root.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderRootProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderRoot(props: &FolderRootProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"
+            />
+            <circle cx="12" cy="13" r="2" />
+            <path d="M12 15v5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_search.rs b/packages/yew/src/folder_search.rs
new file mode 100644
index 0000000..ac0f790
--- /dev/null
+++ b/packages/yew/src/folder_search.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderSearch(props: &FolderSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.7 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v4.1"
+            />
+            <path d="m21 21-1.9-1.9" />
+            <circle cx="17" cy="17" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_search_2.rs b/packages/yew/src/folder_search_2.rs
new file mode 100644
index 0000000..49f3075
--- /dev/null
+++ b/packages/yew/src/folder_search_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderSearch2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderSearch2(props: &FolderSearch2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11.5" cy="12.5" r="2.5" />
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+            <path d="M13.3 14.3 15 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_symlink.rs b/packages/yew/src/folder_symlink.rs
new file mode 100644
index 0000000..9f067a6
--- /dev/null
+++ b/packages/yew/src/folder_symlink.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderSymlinkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderSymlink(props: &FolderSymlinkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h7"
+            />
+            <path d="m8 16 3-3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_sync.rs b/packages/yew/src/folder_sync.rs
new file mode 100644
index 0000000..31e1b62
--- /dev/null
+++ b/packages/yew/src/folder_sync.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderSyncProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderSync(props: &FolderSyncProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M9 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v.5"
+            />
+            <path d="M12 10v4h4" />
+            <path d="m12 14 1.535-1.605a5 5 0 0 1 8 1.5" />
+            <path d="M22 22v-4h-4" />
+            <path d="m22 18-1.535 1.605a5 5 0 0 1-8-1.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_tree.rs b/packages/yew/src/folder_tree.rs
new file mode 100644
index 0000000..6e1484f
--- /dev/null
+++ b/packages/yew/src/folder_tree.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderTreeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderTree(props: &FolderTreeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 10a1 1 0 0 0 1-1V6a1 1 0 0 0-1-1h-2.5a1 1 0 0 1-.8-.4l-.9-1.2A1 1 0 0 0 15 3h-2a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z"
+            />
+            <path
+                d="M20 21a1 1 0 0 0 1-1v-3a1 1 0 0 0-1-1h-2.9a1 1 0 0 1-.88-.55l-.42-.85a1 1 0 0 0-.92-.6H13a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z"
+            />
+            <path d="M3 5a2 2 0 0 0 2 2h3" />
+            <path d="M3 3v13a2 2 0 0 0 2 2h3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_up.rs b/packages/yew/src/folder_up.rs
new file mode 100644
index 0000000..6ce402e
--- /dev/null
+++ b/packages/yew/src/folder_up.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderUp(props: &FolderUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+            <path d="M12 10v6" />
+            <path d="m9 13 3-3 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folder_x.rs b/packages/yew/src/folder_x.rs
new file mode 100644
index 0000000..c1b007d
--- /dev/null
+++ b/packages/yew/src/folder_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FolderXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn FolderX(props: &FolderXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"
+            />
+            <path d="m9.5 10.5 5 5" />
+            <path d="m14.5 10.5-5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/folders.rs b/packages/yew/src/folders.rs
new file mode 100644
index 0000000..7e50525
--- /dev/null
+++ b/packages/yew/src/folders.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FoldersProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Folders(props: &FoldersProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 17a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-3.9a2 2 0 0 1-1.69-.9l-.81-1.2a2 2 0 0 0-1.67-.9H8a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2Z"
+            />
+            <path d="M2 8v11a2 2 0 0 0 2 2h14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/footprints.rs b/packages/yew/src/footprints.rs
new file mode 100644
index 0000000..53909b6
--- /dev/null
+++ b/packages/yew/src/footprints.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FootprintsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Footprints(props: &FootprintsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 16v-2.38C4 11.5 2.97 10.5 3 8c.03-2.72 1.49-6 4.5-6C9.37 2 10 3.8 10 5.5c0 3.11-2 5.66-2 8.68V16a2 2 0 1 1-4 0Z"
+            />
+            <path
+                d="M20 20v-2.38c0-2.12 1.03-3.12 1-5.62-.03-2.72-1.49-6-4.5-6C14.63 6 14 7.8 14 9.5c0 3.11 2 5.66 2 8.68V20a2 2 0 1 0 4 0Z"
+            />
+            <path d="M16 17h4" />
+            <path d="M4 13h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/forklift.rs b/packages/yew/src/forklift.rs
new file mode 100644
index 0000000..ba19ebb
--- /dev/null
+++ b/packages/yew/src/forklift.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ForkliftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Forklift(props: &ForkliftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12H5a2 2 0 0 0-2 2v5" />
+            <circle cx="13" cy="19" r="2" />
+            <circle cx="5" cy="19" r="2" />
+            <path d="M8 19h3m5-17v17h6M6 12V7c0-1.1.9-2 2-2h3l5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/forward.rs b/packages/yew/src/forward.rs
new file mode 100644
index 0000000..e5d06e8
--- /dev/null
+++ b/packages/yew/src/forward.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ForwardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Forward(props: &ForwardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="15 17 20 12 15 7" />
+            <path d="M4 18v-2a4 4 0 0 1 4-4h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/frame.rs b/packages/yew/src/frame.rs
new file mode 100644
index 0000000..cbf0d31
--- /dev/null
+++ b/packages/yew/src/frame.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FrameProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Frame(props: &FrameProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="22" x2="2" y1="6" y2="6" />
+            <line x1="22" x2="2" y1="18" y2="18" />
+            <line x1="6" x2="6" y1="2" y2="22" />
+            <line x1="18" x2="18" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/framer.rs b/packages/yew/src/framer.rs
new file mode 100644
index 0000000..1584ed0
--- /dev/null
+++ b/packages/yew/src/framer.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FramerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Framer(props: &FramerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 16V9h14V2H5l14 14h-7m-7 0 7 7v-7m-7 0h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/frown.rs b/packages/yew/src/frown.rs
new file mode 100644
index 0000000..7a59224
--- /dev/null
+++ b/packages/yew/src/frown.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FrownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Frown(props: &FrownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M16 16s-1.5-2-4-2-4 2-4 2" />
+            <line x1="9" x2="9.01" y1="9" y2="9" />
+            <line x1="15" x2="15.01" y1="9" y2="9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fuel.rs b/packages/yew/src/fuel.rs
new file mode 100644
index 0000000..e36cf07
--- /dev/null
+++ b/packages/yew/src/fuel.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FuelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Fuel(props: &FuelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="3" x2="15" y1="22" y2="22" />
+            <line x1="4" x2="14" y1="9" y2="9" />
+            <path d="M14 22V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v18" />
+            <path
+                d="M14 13h2a2 2 0 0 1 2 2v2a2 2 0 0 0 2 2a2 2 0 0 0 2-2V9.83a2 2 0 0 0-.59-1.42L18 5"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/fullscreen.rs b/packages/yew/src/fullscreen.rs
new file mode 100644
index 0000000..46254eb
--- /dev/null
+++ b/packages/yew/src/fullscreen.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct FullscreenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Fullscreen(props: &FullscreenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+            <rect width="10" height="8" x="7" y="8" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gallery_horizontal.rs b/packages/yew/src/gallery_horizontal.rs
new file mode 100644
index 0000000..b6c8eb5
--- /dev/null
+++ b/packages/yew/src/gallery_horizontal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GalleryHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GalleryHorizontal(props: &GalleryHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 3v18" />
+            <rect width="12" height="18" x="6" y="3" rx="2" />
+            <path d="M22 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gallery_horizontal_end.rs b/packages/yew/src/gallery_horizontal_end.rs
new file mode 100644
index 0000000..4ca4d70
--- /dev/null
+++ b/packages/yew/src/gallery_horizontal_end.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GalleryHorizontalEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GalleryHorizontalEnd(props: &GalleryHorizontalEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 7v10" />
+            <path d="M6 5v14" />
+            <rect width="12" height="18" x="10" y="3" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gallery_thumbnails.rs b/packages/yew/src/gallery_thumbnails.rs
new file mode 100644
index 0000000..c6249c0
--- /dev/null
+++ b/packages/yew/src/gallery_thumbnails.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GalleryThumbnailsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GalleryThumbnails(props: &GalleryThumbnailsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="14" x="3" y="3" rx="2" />
+            <path d="M4 21h1" />
+            <path d="M9 21h1" />
+            <path d="M14 21h1" />
+            <path d="M19 21h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gallery_vertical.rs b/packages/yew/src/gallery_vertical.rs
new file mode 100644
index 0000000..97aa156
--- /dev/null
+++ b/packages/yew/src/gallery_vertical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GalleryVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GalleryVertical(props: &GalleryVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 2h18" />
+            <rect width="18" height="12" x="3" y="6" rx="2" />
+            <path d="M3 22h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gallery_vertical_end.rs b/packages/yew/src/gallery_vertical_end.rs
new file mode 100644
index 0000000..c42d9c3
--- /dev/null
+++ b/packages/yew/src/gallery_vertical_end.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GalleryVerticalEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GalleryVerticalEnd(props: &GalleryVerticalEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 2h10" />
+            <path d="M5 6h14" />
+            <rect width="18" height="12" x="3" y="10" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gamepad.rs b/packages/yew/src/gamepad.rs
new file mode 100644
index 0000000..1e9fd88
--- /dev/null
+++ b/packages/yew/src/gamepad.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GamepadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Gamepad(props: &GamepadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="6" x2="10" y1="12" y2="12" />
+            <line x1="8" x2="8" y1="10" y2="14" />
+            <line x1="15" x2="15.01" y1="13" y2="13" />
+            <line x1="18" x2="18.01" y1="11" y2="11" />
+            <rect width="20" height="12" x="2" y="6" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gamepad_2.rs b/packages/yew/src/gamepad_2.rs
new file mode 100644
index 0000000..e0fb89e
--- /dev/null
+++ b/packages/yew/src/gamepad_2.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Gamepad2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Gamepad2(props: &Gamepad2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="6" x2="10" y1="11" y2="11" />
+            <line x1="8" x2="8" y1="9" y2="13" />
+            <line x1="15" x2="15.01" y1="12" y2="12" />
+            <line x1="18" x2="18.01" y1="10" y2="10" />
+            <path
+                d="M17.32 5H6.68a4 4 0 0 0-3.978 3.59c-.006.052-.01.101-.017.152C2.604 9.416 2 14.456 2 16a3 3 0 0 0 3 3c1 0 1.5-.5 2-1l1.414-1.414A2 2 0 0 1 9.828 16h4.344a2 2 0 0 1 1.414.586L17 18c.5.5 1 1 2 1a3 3 0 0 0 3-3c0-1.545-.604-6.584-.685-7.258-.007-.05-.011-.1-.017-.151A4 4 0 0 0 17.32 5z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gauge.rs b/packages/yew/src/gauge.rs
new file mode 100644
index 0000000..712e1af
--- /dev/null
+++ b/packages/yew/src/gauge.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GaugeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Gauge(props: &GaugeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 14 4-4" />
+            <path d="M3.34 19a10 10 0 1 1 17.32 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gavel.rs b/packages/yew/src/gavel.rs
new file mode 100644
index 0000000..2ea36ef
--- /dev/null
+++ b/packages/yew/src/gavel.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GavelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Gavel(props: &GavelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14.5 12.5-8 8a2.119 2.119 0 1 1-3-3l8-8" />
+            <path d="m16 16 6-6" />
+            <path d="m8 8 6-6" />
+            <path d="m9 7 8 8" />
+            <path d="m21 11-8-8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gem.rs b/packages/yew/src/gem.rs
new file mode 100644
index 0000000..29b7a7d
--- /dev/null
+++ b/packages/yew/src/gem.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GemProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Gem(props: &GemProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 3h12l4 6-10 13L2 9Z" />
+            <path d="M11 3 8 9l4 13 4-13-3-6" />
+            <path d="M2 9h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ghost.rs b/packages/yew/src/ghost.rs
new file mode 100644
index 0000000..f4d7c9f
--- /dev/null
+++ b/packages/yew/src/ghost.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GhostProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ghost(props: &GhostProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 10h.01" />
+            <path d="M15 10h.01" />
+            <path d="M12 2a8 8 0 0 0-8 8v12l3-3 2.5 2.5L12 19l2.5 2.5L17 19l3 3V10a8 8 0 0 0-8-8z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gift.rs b/packages/yew/src/gift.rs
new file mode 100644
index 0000000..6ca2351
--- /dev/null
+++ b/packages/yew/src/gift.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GiftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Gift(props: &GiftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="3" y="8" width="18" height="4" rx="1" />
+            <path d="M12 8v13" />
+            <path d="M19 12v7a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2v-7" />
+            <path
+                d="M7.5 8a2.5 2.5 0 0 1 0-5A4.8 8 0 0 1 12 8a4.8 8 0 0 1 4.5-5 2.5 2.5 0 0 1 0 5"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_branch.rs b/packages/yew/src/git_branch.rs
new file mode 100644
index 0000000..10f919a
--- /dev/null
+++ b/packages/yew/src/git_branch.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitBranchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitBranch(props: &GitBranchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="6" x2="6" y1="3" y2="15" />
+            <circle cx="18" cy="6" r="3" />
+            <circle cx="6" cy="18" r="3" />
+            <path d="M18 9a9 9 0 0 1-9 9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_branch_plus.rs b/packages/yew/src/git_branch_plus.rs
new file mode 100644
index 0000000..7f2fb75
--- /dev/null
+++ b/packages/yew/src/git_branch_plus.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitBranchPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitBranchPlus(props: &GitBranchPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 3v12" />
+            <path d="M18 9a3 3 0 1 0 0-6 3 3 0 0 0 0 6z" />
+            <path d="M6 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6z" />
+            <path d="M15 6a9 9 0 0 0-9 9" />
+            <path d="M18 15v6" />
+            <path d="M21 18h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_commit_horizontal.rs b/packages/yew/src/git_commit_horizontal.rs
new file mode 100644
index 0000000..3408553
--- /dev/null
+++ b/packages/yew/src/git_commit_horizontal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitCommitHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitCommitHorizontal(props: &GitCommitHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3" />
+            <line x1="3" x2="9" y1="12" y2="12" />
+            <line x1="15" x2="21" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_commit_vertical.rs b/packages/yew/src/git_commit_vertical.rs
new file mode 100644
index 0000000..2646273
--- /dev/null
+++ b/packages/yew/src/git_commit_vertical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitCommitVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitCommitVertical(props: &GitCommitVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v6" />
+            <circle cx="12" cy="12" r="3" />
+            <path d="M12 15v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_compare.rs b/packages/yew/src/git_compare.rs
new file mode 100644
index 0000000..f6688b8
--- /dev/null
+++ b/packages/yew/src/git_compare.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitCompareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitCompare(props: &GitCompareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3" />
+            <circle cx="6" cy="6" r="3" />
+            <path d="M13 6h3a2 2 0 0 1 2 2v7" />
+            <path d="M11 18H8a2 2 0 0 1-2-2V9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_compare_arrows.rs b/packages/yew/src/git_compare_arrows.rs
new file mode 100644
index 0000000..332d2ce
--- /dev/null
+++ b/packages/yew/src/git_compare_arrows.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitCompareArrowsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitCompareArrows(props: &GitCompareArrowsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="5" cy="6" r="3" />
+            <path d="M12 6h5a2 2 0 0 1 2 2v7" />
+            <path d="m15 9-3-3 3-3" />
+            <circle cx="19" cy="18" r="3" />
+            <path d="M12 18H7a2 2 0 0 1-2-2V9" />
+            <path d="m9 15 3 3-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_fork.rs b/packages/yew/src/git_fork.rs
new file mode 100644
index 0000000..390fbbc
--- /dev/null
+++ b/packages/yew/src/git_fork.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitForkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitFork(props: &GitForkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="18" r="3" />
+            <circle cx="6" cy="6" r="3" />
+            <circle cx="18" cy="6" r="3" />
+            <path d="M18 9v2c0 .6-.4 1-1 1H7c-.6 0-1-.4-1-1V9" />
+            <path d="M12 12v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_graph.rs b/packages/yew/src/git_graph.rs
new file mode 100644
index 0000000..2cda5cb
--- /dev/null
+++ b/packages/yew/src/git_graph.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitGraphProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitGraph(props: &GitGraphProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="5" cy="6" r="3" />
+            <path d="M5 9v6" />
+            <circle cx="5" cy="18" r="3" />
+            <path d="M12 3v18" />
+            <circle cx="19" cy="6" r="3" />
+            <path d="M16 15.7A9 9 0 0 0 19 9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_merge.rs b/packages/yew/src/git_merge.rs
new file mode 100644
index 0000000..7ad35ec
--- /dev/null
+++ b/packages/yew/src/git_merge.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitMergeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitMerge(props: &GitMergeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3" />
+            <circle cx="6" cy="6" r="3" />
+            <path d="M6 21V9a9 9 0 0 0 9 9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_pull_request.rs b/packages/yew/src/git_pull_request.rs
new file mode 100644
index 0000000..df81162
--- /dev/null
+++ b/packages/yew/src/git_pull_request.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitPullRequestProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitPullRequest(props: &GitPullRequestProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3" />
+            <circle cx="6" cy="6" r="3" />
+            <path d="M13 6h3a2 2 0 0 1 2 2v7" />
+            <line x1="6" x2="6" y1="9" y2="21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_pull_request_arrow.rs b/packages/yew/src/git_pull_request_arrow.rs
new file mode 100644
index 0000000..12e0ec9
--- /dev/null
+++ b/packages/yew/src/git_pull_request_arrow.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitPullRequestArrowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitPullRequestArrow(props: &GitPullRequestArrowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="5" cy="6" r="3" />
+            <path d="M5 9v12" />
+            <circle cx="19" cy="18" r="3" />
+            <path d="m15 9-3-3 3-3" />
+            <path d="M12 6h5a2 2 0 0 1 2 2v7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_pull_request_closed.rs b/packages/yew/src/git_pull_request_closed.rs
new file mode 100644
index 0000000..fc5cd0a
--- /dev/null
+++ b/packages/yew/src/git_pull_request_closed.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitPullRequestClosedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitPullRequestClosed(props: &GitPullRequestClosedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="6" r="3" />
+            <path d="M6 9v12" />
+            <path d="m21 3-6 6" />
+            <path d="m21 9-6-6" />
+            <path d="M18 11.5V15" />
+            <circle cx="18" cy="18" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_pull_request_create.rs b/packages/yew/src/git_pull_request_create.rs
new file mode 100644
index 0000000..1d90fa0
--- /dev/null
+++ b/packages/yew/src/git_pull_request_create.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitPullRequestCreateProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitPullRequestCreate(props: &GitPullRequestCreateProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="6" r="3" />
+            <path d="M6 9v12" />
+            <path d="M13 6h3a2 2 0 0 1 2 2v3" />
+            <path d="M18 15v6" />
+            <path d="M21 18h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_pull_request_create_arrow.rs b/packages/yew/src/git_pull_request_create_arrow.rs
new file mode 100644
index 0000000..020bfeb
--- /dev/null
+++ b/packages/yew/src/git_pull_request_create_arrow.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitPullRequestCreateArrowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitPullRequestCreateArrow(props: &GitPullRequestCreateArrowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="5" cy="6" r="3" />
+            <path d="M5 9v12" />
+            <path d="m15 9-3-3 3-3" />
+            <path d="M12 6h5a2 2 0 0 1 2 2v3" />
+            <path d="M19 15v6" />
+            <path d="M22 18h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/git_pull_request_draft.rs b/packages/yew/src/git_pull_request_draft.rs
new file mode 100644
index 0000000..8f28236
--- /dev/null
+++ b/packages/yew/src/git_pull_request_draft.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitPullRequestDraftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GitPullRequestDraft(props: &GitPullRequestDraftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="18" r="3" />
+            <circle cx="6" cy="6" r="3" />
+            <path d="M18 6V5" />
+            <path d="M18 11v-1" />
+            <line x1="6" x2="6" y1="9" y2="21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/github.rs b/packages/yew/src/github.rs
new file mode 100644
index 0000000..f74292b
--- /dev/null
+++ b/packages/yew/src/github.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GithubProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Github(props: &GithubProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4"
+            />
+            <path d="M9 18c-4.51 2-5-2-7-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/gitlab.rs b/packages/yew/src/gitlab.rs
new file mode 100644
index 0000000..52a345e
--- /dev/null
+++ b/packages/yew/src/gitlab.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GitlabProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Gitlab(props: &GitlabProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m22 13.29-3.33-10a.42.42 0 0 0-.14-.18.38.38 0 0 0-.22-.11.39.39 0 0 0-.23.07.42.42 0 0 0-.14.18l-2.26 6.67H8.32L6.1 3.26a.42.42 0 0 0-.1-.18.38.38 0 0 0-.26-.08.39.39 0 0 0-.23.07.42.42 0 0 0-.14.18L2 13.29a.74.74 0 0 0 .27.83L12 21l9.69-6.88a.71.71 0 0 0 .31-.83Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/glass_water.rs b/packages/yew/src/glass_water.rs
new file mode 100644
index 0000000..12dd98b
--- /dev/null
+++ b/packages/yew/src/glass_water.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GlassWaterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GlassWater(props: &GlassWaterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M5.116 4.104A1 1 0 0 1 6.11 3h11.78a1 1 0 0 1 .994 1.105L17.19 20.21A2 2 0 0 1 15.2 22H8.8a2 2 0 0 1-2-1.79z"
+            />
+            <path d="M6 12a5 5 0 0 1 6 0 5 5 0 0 0 6 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/glasses.rs b/packages/yew/src/glasses.rs
new file mode 100644
index 0000000..e03c82a
--- /dev/null
+++ b/packages/yew/src/glasses.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GlassesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Glasses(props: &GlassesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="15" r="4" />
+            <circle cx="18" cy="15" r="4" />
+            <path d="M14 15a2 2 0 0 0-2-2 2 2 0 0 0-2 2" />
+            <path d="M2.5 13 5 7c.7-1.3 1.4-2 3-2" />
+            <path d="M21.5 13 19 7c-.7-1.3-1.5-2-3-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/globe.rs b/packages/yew/src/globe.rs
new file mode 100644
index 0000000..0cafd7f
--- /dev/null
+++ b/packages/yew/src/globe.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GlobeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Globe(props: &GlobeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20" />
+            <path d="M2 12h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/globe_lock.rs b/packages/yew/src/globe_lock.rs
new file mode 100644
index 0000000..46d3c41
--- /dev/null
+++ b/packages/yew/src/globe_lock.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GlobeLockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GlobeLock(props: &GlobeLockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.686 15A14.5 14.5 0 0 1 12 22a14.5 14.5 0 0 1 0-20 10 10 0 1 0 9.542 13" />
+            <path d="M2 12h8.5" />
+            <path d="M20 6V4a2 2 0 1 0-4 0v2" />
+            <rect width="8" height="5" x="14" y="6" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/goal.rs b/packages/yew/src/goal.rs
new file mode 100644
index 0000000..5b7bc65
--- /dev/null
+++ b/packages/yew/src/goal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GoalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Goal(props: &GoalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V2l8 4-8 4" />
+            <path d="M20.561 10.222a9 9 0 1 1-12.55-5.29" />
+            <path d="M8.002 9.997a5 5 0 1 0 8.9 2.02" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grab.rs b/packages/yew/src/grab.rs
new file mode 100644
index 0000000..fb72ed0
--- /dev/null
+++ b/packages/yew/src/grab.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GrabProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Grab(props: &GrabProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 11.5V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1.4" />
+            <path d="M14 10V8a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2" />
+            <path d="M10 9.9V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v5" />
+            <path d="M6 14a2 2 0 0 0-2-2a2 2 0 0 0-2 2" />
+            <path d="M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-4a8 8 0 0 1-8-8 2 2 0 1 1 4 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/graduation_cap.rs b/packages/yew/src/graduation_cap.rs
new file mode 100644
index 0000000..576f476
--- /dev/null
+++ b/packages/yew/src/graduation_cap.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GraduationCapProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GraduationCap(props: &GraduationCapProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21.42 10.922a1 1 0 0 0-.019-1.838L12.83 5.18a2 2 0 0 0-1.66 0L2.6 9.08a1 1 0 0 0 0 1.832l8.57 3.908a2 2 0 0 0 1.66 0z"
+            />
+            <path d="M22 10v6" />
+            <path d="M6 12.5V16a6 3 0 0 0 12 0v-3.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grape.rs b/packages/yew/src/grape.rs
new file mode 100644
index 0000000..48dda45
--- /dev/null
+++ b/packages/yew/src/grape.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GrapeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Grape(props: &GrapeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 5V2l-5.89 5.89" />
+            <circle cx="16.6" cy="15.89" r="3" />
+            <circle cx="8.11" cy="7.4" r="3" />
+            <circle cx="12.35" cy="11.65" r="3" />
+            <circle cx="13.91" cy="5.85" r="3" />
+            <circle cx="18.15" cy="10.09" r="3" />
+            <circle cx="6.56" cy="13.2" r="3" />
+            <circle cx="10.8" cy="17.44" r="3" />
+            <circle cx="5" cy="19" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grid_2_x_2.rs b/packages/yew/src/grid_2_x_2.rs
new file mode 100644
index 0000000..6926b41
--- /dev/null
+++ b/packages/yew/src/grid_2_x_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Grid2X2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Grid2X2(props: &Grid2X2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 12h18" />
+            <path d="M12 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grid_2_x_2_check.rs b/packages/yew/src/grid_2_x_2_check.rs
new file mode 100644
index 0000000..c64a074
--- /dev/null
+++ b/packages/yew/src/grid_2_x_2_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Grid2X2CheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Grid2X2Check(props: &Grid2X2CheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"
+            />
+            <path d="m16 19 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grid_2_x_2_plus.rs b/packages/yew/src/grid_2_x_2_plus.rs
new file mode 100644
index 0000000..caa7e3d
--- /dev/null
+++ b/packages/yew/src/grid_2_x_2_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Grid2X2PlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Grid2X2Plus(props: &Grid2X2PlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"
+            />
+            <path d="M16 19h6" />
+            <path d="M19 22v-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grid_2_x_2_x.rs b/packages/yew/src/grid_2_x_2_x.rs
new file mode 100644
index 0000000..eab6a34
--- /dev/null
+++ b/packages/yew/src/grid_2_x_2_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Grid2X2XProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Grid2X2X(props: &Grid2X2XProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"
+            />
+            <path d="m16 16 5 5" />
+            <path d="m16 21 5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grid_3_x_3.rs b/packages/yew/src/grid_3_x_3.rs
new file mode 100644
index 0000000..d3ad50d
--- /dev/null
+++ b/packages/yew/src/grid_3_x_3.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Grid3X3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Grid3X3(props: &Grid3X3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 9h18" />
+            <path d="M3 15h18" />
+            <path d="M9 3v18" />
+            <path d="M15 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grip.rs b/packages/yew/src/grip.rs
new file mode 100644
index 0000000..c186618
--- /dev/null
+++ b/packages/yew/src/grip.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GripProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Grip(props: &GripProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="5" r="1" />
+            <circle cx="19" cy="5" r="1" />
+            <circle cx="5" cy="5" r="1" />
+            <circle cx="12" cy="12" r="1" />
+            <circle cx="19" cy="12" r="1" />
+            <circle cx="5" cy="12" r="1" />
+            <circle cx="12" cy="19" r="1" />
+            <circle cx="19" cy="19" r="1" />
+            <circle cx="5" cy="19" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grip_horizontal.rs b/packages/yew/src/grip_horizontal.rs
new file mode 100644
index 0000000..4944995
--- /dev/null
+++ b/packages/yew/src/grip_horizontal.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GripHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GripHorizontal(props: &GripHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="9" r="1" />
+            <circle cx="19" cy="9" r="1" />
+            <circle cx="5" cy="9" r="1" />
+            <circle cx="12" cy="15" r="1" />
+            <circle cx="19" cy="15" r="1" />
+            <circle cx="5" cy="15" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/grip_vertical.rs b/packages/yew/src/grip_vertical.rs
new file mode 100644
index 0000000..9d2b8f4
--- /dev/null
+++ b/packages/yew/src/grip_vertical.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GripVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn GripVertical(props: &GripVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="9" cy="12" r="1" />
+            <circle cx="9" cy="5" r="1" />
+            <circle cx="9" cy="19" r="1" />
+            <circle cx="15" cy="12" r="1" />
+            <circle cx="15" cy="5" r="1" />
+            <circle cx="15" cy="19" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/group.rs b/packages/yew/src/group.rs
new file mode 100644
index 0000000..f1aa6b4
--- /dev/null
+++ b/packages/yew/src/group.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GroupProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Group(props: &GroupProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5c0-1.1.9-2 2-2h2" />
+            <path d="M17 3h2c1.1 0 2 .9 2 2v2" />
+            <path d="M21 17v2c0 1.1-.9 2-2 2h-2" />
+            <path d="M7 21H5c-1.1 0-2-.9-2-2v-2" />
+            <rect width="7" height="5" x="7" y="7" rx="1" />
+            <rect width="7" height="5" x="10" y="12" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/guitar.rs b/packages/yew/src/guitar.rs
new file mode 100644
index 0000000..8eaca75
--- /dev/null
+++ b/packages/yew/src/guitar.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct GuitarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Guitar(props: &GuitarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11.9 12.1 4.514-4.514" />
+            <path
+                d="M20.1 2.3a1 1 0 0 0-1.4 0l-1.114 1.114A2 2 0 0 0 17 4.828v1.344a2 2 0 0 1-.586 1.414A2 2 0 0 1 17.828 7h1.344a2 2 0 0 0 1.414-.586L21.7 5.3a1 1 0 0 0 0-1.4z"
+            />
+            <path d="m6 16 2 2" />
+            <path
+                d="M8.2 9.9C8.7 8.8 9.8 8 11 8c2.8 0 5 2.2 5 5 0 1.2-.8 2.3-1.9 2.8l-.9.4A2 2 0 0 0 12 18a4 4 0 0 1-4 4c-3.3 0-6-2.7-6-6a4 4 0 0 1 4-4 2 2 0 0 0 1.8-1.2z"
+            />
+            <circle cx="11.5" cy="12.5" r=".5" fill="currentColor" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ham.rs b/packages/yew/src/ham.rs
new file mode 100644
index 0000000..04dd78c
--- /dev/null
+++ b/packages/yew/src/ham.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HamProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ham(props: &HamProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.144 21.144A7.274 10.445 45 1 0 2.856 10.856" />
+            <path
+                d="M13.144 21.144A7.274 4.365 45 0 0 2.856 10.856a7.274 4.365 45 0 0 10.288 10.288"
+            />
+            <path
+                d="M16.565 10.435 18.6 8.4a2.501 2.501 0 1 0 1.65-4.65 2.5 2.5 0 1 0-4.66 1.66l-2.024 2.025"
+            />
+            <path d="m8.5 16.5-1-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hammer.rs b/packages/yew/src/hammer.rs
new file mode 100644
index 0000000..7675b24
--- /dev/null
+++ b/packages/yew/src/hammer.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HammerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Hammer(props: &HammerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 12-8.373 8.373a1 1 0 1 1-3-3L12 9" />
+            <path d="m18 15 4-4" />
+            <path
+                d="m21.5 11.5-1.914-1.914A2 2 0 0 1 19 8.172V7l-2.26-2.26a6 6 0 0 0-4.202-1.756L9 2.96l.92.82A6.18 6.18 0 0 1 12 8.4V10l2 2h1.172a2 2 0 0 1 1.414.586L18.5 14.5"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hand.rs b/packages/yew/src/hand.rs
new file mode 100644
index 0000000..7b9865d
--- /dev/null
+++ b/packages/yew/src/hand.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HandProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Hand(props: &HandProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 11V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2" />
+            <path d="M14 10V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2" />
+            <path d="M10 10.5V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2v8" />
+            <path
+                d="M18 8a2 2 0 1 1 4 0v6a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hand_coins.rs b/packages/yew/src/hand_coins.rs
new file mode 100644
index 0000000..d987d15
--- /dev/null
+++ b/packages/yew/src/hand_coins.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HandCoinsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HandCoins(props: &HandCoinsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 15h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 17" />
+            <path
+                d="m7 21 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9"
+            />
+            <path d="m2 16 6 6" />
+            <circle cx="16" cy="9" r="2.9" />
+            <circle cx="6" cy="5" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hand_heart.rs b/packages/yew/src/hand_heart.rs
new file mode 100644
index 0000000..d4dcf56
--- /dev/null
+++ b/packages/yew/src/hand_heart.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HandHeartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HandHeart(props: &HandHeartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 14h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 16" />
+            <path
+                d="m7 20 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9"
+            />
+            <path d="m2 15 6 6" />
+            <path
+                d="M19.5 8.5c.7-.7 1.5-1.6 1.5-2.7A2.73 2.73 0 0 0 16 4a2.78 2.78 0 0 0-5 1.8c0 1.2.8 2 1.5 2.8L16 12Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hand_helping.rs b/packages/yew/src/hand_helping.rs
new file mode 100644
index 0000000..c116104
--- /dev/null
+++ b/packages/yew/src/hand_helping.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HandHelpingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HandHelping(props: &HandHelpingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 12h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 14" />
+            <path
+                d="m7 18 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9"
+            />
+            <path d="m2 13 6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hand_metal.rs b/packages/yew/src/hand_metal.rs
new file mode 100644
index 0000000..452756c
--- /dev/null
+++ b/packages/yew/src/hand_metal.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HandMetalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HandMetal(props: &HandMetalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 12.5V10a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1.4" />
+            <path d="M14 11V9a2 2 0 1 0-4 0v2" />
+            <path d="M10 10.5V5a2 2 0 1 0-4 0v9" />
+            <path
+                d="m7 15-1.76-1.76a2 2 0 0 0-2.83 2.82l3.6 3.6C7.5 21.14 9.2 22 12 22h2a8 8 0 0 0 8-8V7a2 2 0 1 0-4 0v5"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hand_platter.rs b/packages/yew/src/hand_platter.rs
new file mode 100644
index 0000000..ef12b61
--- /dev/null
+++ b/packages/yew/src/hand_platter.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HandPlatterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HandPlatter(props: &HandPlatterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3V2" />
+            <path
+                d="m15.4 17.4 3.2-2.8a2 2 0 1 1 2.8 2.9l-3.6 3.3c-.7.8-1.7 1.2-2.8 1.2h-4c-1.1 0-2.1-.4-2.8-1.2l-1.302-1.464A1 1 0 0 0 6.151 19H5"
+            />
+            <path d="M2 14h12a2 2 0 0 1 0 4h-2" />
+            <path d="M4 10h16" />
+            <path d="M5 10a7 7 0 0 1 14 0" />
+            <path d="M5 14v6a1 1 0 0 1-1 1H2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/handshake.rs b/packages/yew/src/handshake.rs
new file mode 100644
index 0000000..e9357bb
--- /dev/null
+++ b/packages/yew/src/handshake.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HandshakeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Handshake(props: &HandshakeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11 17 2 2a1 1 0 1 0 3-3" />
+            <path
+                d="m14 14 2.5 2.5a1 1 0 1 0 3-3l-3.88-3.88a3 3 0 0 0-4.24 0l-.88.88a1 1 0 1 1-3-3l2.81-2.81a5.79 5.79 0 0 1 7.06-.87l.47.28a2 2 0 0 0 1.42.25L21 4"
+            />
+            <path d="m21 3 1 11h-2" />
+            <path d="M3 3 2 14l6.5 6.5a1 1 0 1 0 3-3" />
+            <path d="M3 4h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hard_drive.rs b/packages/yew/src/hard_drive.rs
new file mode 100644
index 0000000..d38fd98
--- /dev/null
+++ b/packages/yew/src/hard_drive.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HardDriveProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HardDrive(props: &HardDriveProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="22" x2="2" y1="12" y2="12" />
+            <path
+                d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"
+            />
+            <line x1="6" x2="6.01" y1="16" y2="16" />
+            <line x1="10" x2="10.01" y1="16" y2="16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hard_drive_download.rs b/packages/yew/src/hard_drive_download.rs
new file mode 100644
index 0000000..6d78141
--- /dev/null
+++ b/packages/yew/src/hard_drive_download.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HardDriveDownloadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HardDriveDownload(props: &HardDriveDownloadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v8" />
+            <path d="m16 6-4 4-4-4" />
+            <rect width="20" height="8" x="2" y="14" rx="2" />
+            <path d="M6 18h.01" />
+            <path d="M10 18h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hard_drive_upload.rs b/packages/yew/src/hard_drive_upload.rs
new file mode 100644
index 0000000..68f8bc2
--- /dev/null
+++ b/packages/yew/src/hard_drive_upload.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HardDriveUploadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HardDriveUpload(props: &HardDriveUploadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 6-4-4-4 4" />
+            <path d="M12 2v8" />
+            <rect width="20" height="8" x="2" y="14" rx="2" />
+            <path d="M6 18h.01" />
+            <path d="M10 18h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hard_hat.rs b/packages/yew/src/hard_hat.rs
new file mode 100644
index 0000000..55a4dcd
--- /dev/null
+++ b/packages/yew/src/hard_hat.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HardHatProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HardHat(props: &HardHatProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10V5a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v5" />
+            <path d="M14 6a6 6 0 0 1 6 6v3" />
+            <path d="M4 15v-3a6 6 0 0 1 6-6" />
+            <rect x="2" y="15" width="20" height="4" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hash.rs b/packages/yew/src/hash.rs
new file mode 100644
index 0000000..7a79be0
--- /dev/null
+++ b/packages/yew/src/hash.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Hash(props: &HashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="4" x2="20" y1="9" y2="9" />
+            <line x1="4" x2="20" y1="15" y2="15" />
+            <line x1="10" x2="8" y1="3" y2="21" />
+            <line x1="16" x2="14" y1="3" y2="21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/haze.rs b/packages/yew/src/haze.rs
new file mode 100644
index 0000000..645e8d5
--- /dev/null
+++ b/packages/yew/src/haze.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HazeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Haze(props: &HazeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5.2 6.2 1.4 1.4" />
+            <path d="M2 13h2" />
+            <path d="M20 13h2" />
+            <path d="m17.4 7.6 1.4-1.4" />
+            <path d="M22 17H2" />
+            <path d="M22 21H2" />
+            <path d="M16 13a4 4 0 0 0-8 0" />
+            <path d="M12 5V2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hdmi_port.rs b/packages/yew/src/hdmi_port.rs
new file mode 100644
index 0000000..8555fa4
--- /dev/null
+++ b/packages/yew/src/hdmi_port.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HdmiPortProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HdmiPort(props: &HdmiPortProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M22 9a1 1 0 0 0-1-1H3a1 1 0 0 0-1 1v4a1 1 0 0 0 1 1h1l2 2h12l2-2h1a1 1 0 0 0 1-1Z"
+            />
+            <path d="M7.5 12h9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heading.rs b/packages/yew/src/heading.rs
new file mode 100644
index 0000000..d563cd1
--- /dev/null
+++ b/packages/yew/src/heading.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeadingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heading(props: &HeadingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 12h12" />
+            <path d="M6 20V4" />
+            <path d="M18 20V4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heading_1.rs b/packages/yew/src/heading_1.rs
new file mode 100644
index 0000000..3f3abd6
--- /dev/null
+++ b/packages/yew/src/heading_1.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Heading1Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heading1(props: &Heading1Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8" />
+            <path d="M4 18V6" />
+            <path d="M12 18V6" />
+            <path d="m17 12 3-2v8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heading_2.rs b/packages/yew/src/heading_2.rs
new file mode 100644
index 0000000..d4caf49
--- /dev/null
+++ b/packages/yew/src/heading_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Heading2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heading2(props: &Heading2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8" />
+            <path d="M4 18V6" />
+            <path d="M12 18V6" />
+            <path d="M21 18h-4c0-4 4-3 4-6 0-1.5-2-2.5-4-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heading_3.rs b/packages/yew/src/heading_3.rs
new file mode 100644
index 0000000..663b47e
--- /dev/null
+++ b/packages/yew/src/heading_3.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Heading3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heading3(props: &Heading3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8" />
+            <path d="M4 18V6" />
+            <path d="M12 18V6" />
+            <path d="M17.5 10.5c1.7-1 3.5 0 3.5 1.5a2 2 0 0 1-2 2" />
+            <path d="M17 17.5c2 1.5 4 .3 4-1.5a2 2 0 0 0-2-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heading_4.rs b/packages/yew/src/heading_4.rs
new file mode 100644
index 0000000..7ede113
--- /dev/null
+++ b/packages/yew/src/heading_4.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Heading4Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heading4(props: &Heading4Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 18V6" />
+            <path d="M17 10v3a1 1 0 0 0 1 1h3" />
+            <path d="M21 10v8" />
+            <path d="M4 12h8" />
+            <path d="M4 18V6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heading_5.rs b/packages/yew/src/heading_5.rs
new file mode 100644
index 0000000..f1c9214
--- /dev/null
+++ b/packages/yew/src/heading_5.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Heading5Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heading5(props: &Heading5Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8" />
+            <path d="M4 18V6" />
+            <path d="M12 18V6" />
+            <path d="M17 13v-3h4" />
+            <path d="M17 17.7c.4.2.8.3 1.3.3 1.5 0 2.7-1.1 2.7-2.5S19.8 13 18.3 13H17" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heading_6.rs b/packages/yew/src/heading_6.rs
new file mode 100644
index 0000000..2ba8c88
--- /dev/null
+++ b/packages/yew/src/heading_6.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Heading6Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heading6(props: &Heading6Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12h8" />
+            <path d="M4 18V6" />
+            <path d="M12 18V6" />
+            <circle cx="19" cy="16" r="2" />
+            <path d="M20 10c-2 2-3 3.5-3 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/headphone_off.rs b/packages/yew/src/headphone_off.rs
new file mode 100644
index 0000000..96afb04
--- /dev/null
+++ b/packages/yew/src/headphone_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeadphoneOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HeadphoneOff(props: &HeadphoneOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 14h-1.343" />
+            <path d="M9.128 3.47A9 9 0 0 1 21 12v3.343" />
+            <path d="m2 2 20 20" />
+            <path d="M20.414 20.414A2 2 0 0 1 19 21h-1a2 2 0 0 1-2-2v-3" />
+            <path
+                d="M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 2.636-6.364"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/headphones.rs b/packages/yew/src/headphones.rs
new file mode 100644
index 0000000..28ff183
--- /dev/null
+++ b/packages/yew/src/headphones.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeadphonesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Headphones(props: &HeadphonesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 18 0v7a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/headset.rs b/packages/yew/src/headset.rs
new file mode 100644
index 0000000..eb14a3d
--- /dev/null
+++ b/packages/yew/src/headset.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeadsetProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Headset(props: &HeadsetProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3 11h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-5Zm0 0a9 9 0 1 1 18 0m0 0v5a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3Z"
+            />
+            <path d="M21 16v2a4 4 0 0 1-4 4h-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heart.rs b/packages/yew/src/heart.rs
new file mode 100644
index 0000000..b8ea881
--- /dev/null
+++ b/packages/yew/src/heart.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heart(props: &HeartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heart_crack.rs b/packages/yew/src/heart_crack.rs
new file mode 100644
index 0000000..7924723
--- /dev/null
+++ b/packages/yew/src/heart_crack.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeartCrackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HeartCrack(props: &HeartCrackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"
+            />
+            <path d="m12 13-1-1 2-2-3-3 2-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heart_handshake.rs b/packages/yew/src/heart_handshake.rs
new file mode 100644
index 0000000..fc8aa83
--- /dev/null
+++ b/packages/yew/src/heart_handshake.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeartHandshakeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HeartHandshake(props: &HeartHandshakeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"
+            />
+            <path
+                d="M12 5 9.04 7.96a2.17 2.17 0 0 0 0 3.08c.82.82 2.13.85 3 .07l2.07-1.9a2.82 2.82 0 0 1 3.79 0l2.96 2.66"
+            />
+            <path d="m18 15-2-2" />
+            <path d="m15 18-2-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heart_off.rs b/packages/yew/src/heart_off.rs
new file mode 100644
index 0000000..f853639
--- /dev/null
+++ b/packages/yew/src/heart_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeartOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HeartOff(props: &HeartOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" y1="2" x2="22" y2="22" />
+            <path d="M16.5 16.5 12 21l-7-7c-1.5-1.45-3-3.2-3-5.5a5.5 5.5 0 0 1 2.14-4.35" />
+            <path
+                d="M8.76 3.1c1.15.22 2.13.78 3.24 1.9 1.5-1.5 2.74-2 4.5-2A5.5 5.5 0 0 1 22 8.5c0 2.12-1.3 3.78-2.67 5.17"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heart_pulse.rs b/packages/yew/src/heart_pulse.rs
new file mode 100644
index 0000000..283a393
--- /dev/null
+++ b/packages/yew/src/heart_pulse.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeartPulseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HeartPulse(props: &HeartPulseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"
+            />
+            <path d="M3.22 12H9.5l.5-1 2 4.5 2-7 1.5 3.5h5.27" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/heater.rs b/packages/yew/src/heater.rs
new file mode 100644
index 0000000..d0932ce
--- /dev/null
+++ b/packages/yew/src/heater.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HeaterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Heater(props: &HeaterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 8c2-3-2-3 0-6" />
+            <path d="M15.5 8c2-3-2-3 0-6" />
+            <path d="M6 10h.01" />
+            <path d="M6 14h.01" />
+            <path d="M10 16v-4" />
+            <path d="M14 16v-4" />
+            <path d="M18 16v-4" />
+            <path d="M20 6a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3" />
+            <path d="M5 20v2" />
+            <path d="M19 20v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hexagon.rs b/packages/yew/src/hexagon.rs
new file mode 100644
index 0000000..d88f6c2
--- /dev/null
+++ b/packages/yew/src/hexagon.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HexagonProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Hexagon(props: &HexagonProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/highlighter.rs b/packages/yew/src/highlighter.rs
new file mode 100644
index 0000000..ca0bf28
--- /dev/null
+++ b/packages/yew/src/highlighter.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HighlighterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Highlighter(props: &HighlighterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 11-6 6v3h9l3-3" />
+            <path d="m22 12-4.6 4.6a2 2 0 0 1-2.8 0l-5.2-5.2a2 2 0 0 1 0-2.8L14 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/history.rs b/packages/yew/src/history.rs
new file mode 100644
index 0000000..8a326a8
--- /dev/null
+++ b/packages/yew/src/history.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HistoryProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn History(props: &HistoryProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" />
+            <path d="M3 3v5h5" />
+            <path d="M12 7v5l4 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hop.rs b/packages/yew/src/hop.rs
new file mode 100644
index 0000000..cb7f1eb
--- /dev/null
+++ b/packages/yew/src/hop.rs
@@ -0,0 +1,65 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HopProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Hop(props: &HopProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.82 16.12c1.69.6 3.91.79 5.18.85.55.03 1-.42.97-.97-.06-1.27-.26-3.5-.85-5.18"
+            />
+            <path
+                d="M11.5 6.5c1.64 0 5-.38 6.71-1.07.52-.2.55-.82.12-1.17A10 10 0 0 0 4.26 18.33c.35.43.96.4 1.17-.12.69-1.71 1.07-5.07 1.07-6.71 1.34.45 3.1.9 4.88.62a.88.88 0 0 0 .73-.74c.3-2.14-.15-3.5-.61-4.88"
+            />
+            <path
+                d="M15.62 16.95c.2.85.62 2.76.5 4.28a.77.77 0 0 1-.9.7 16.64 16.64 0 0 1-4.08-1.36"
+            />
+            <path
+                d="M16.13 21.05c1.65.63 3.68.84 4.87.91a.9.9 0 0 0 .96-.96 17.68 17.68 0 0 0-.9-4.87"
+            />
+            <path
+                d="M16.94 15.62c.86.2 2.77.62 4.29.5a.77.77 0 0 0 .7-.9 16.64 16.64 0 0 0-1.36-4.08"
+            />
+            <path
+                d="M17.99 5.52a20.82 20.82 0 0 1 3.15 4.5.8.8 0 0 1-.68 1.13c-2.33.2-5.3-.32-8.27-1.57"
+            />
+            <path d="M4.93 4.93 3 3a.7.7 0 0 1 0-1" />
+            <path
+                d="M9.58 12.18c1.24 2.98 1.77 5.95 1.57 8.28a.8.8 0 0 1-1.13.68 20.82 20.82 0 0 1-4.5-3.15"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hop_off.rs b/packages/yew/src/hop_off.rs
new file mode 100644
index 0000000..c399743
--- /dev/null
+++ b/packages/yew/src/hop_off.rs
@@ -0,0 +1,60 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HopOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HopOff(props: &HopOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.82 16.12c1.69.6 3.91.79 5.18.85.28.01.53-.09.7-.27" />
+            <path
+                d="M11.14 20.57c.52.24 2.44 1.12 4.08 1.37.46.06.86-.25.9-.71.12-1.52-.3-3.43-.5-4.28"
+            />
+            <path d="M16.13 21.05c1.65.63 3.68.84 4.87.91a.9.9 0 0 0 .7-.26" />
+            <path
+                d="M17.99 5.52a20.83 20.83 0 0 1 3.15 4.5.8.8 0 0 1-.68 1.13c-1.17.1-2.5.02-3.9-.25"
+            />
+            <path d="M20.57 11.14c.24.52 1.12 2.44 1.37 4.08.04.3-.08.59-.31.75" />
+            <path
+                d="M4.93 4.93a10 10 0 0 0-.67 13.4c.35.43.96.4 1.17-.12.69-1.71 1.07-5.07 1.07-6.71 1.34.45 3.1.9 4.88.62a.85.85 0 0 0 .48-.24"
+            />
+            <path
+                d="M5.52 17.99c1.05.95 2.91 2.42 4.5 3.15a.8.8 0 0 0 1.13-.68c.2-2.34-.33-5.3-1.57-8.28"
+            />
+            <path d="M8.35 2.68a10 10 0 0 1 9.98 1.58c.43.35.4.96-.12 1.17-1.5.6-4.3.98-6.07 1.05" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hospital.rs b/packages/yew/src/hospital.rs
new file mode 100644
index 0000000..5199714
--- /dev/null
+++ b/packages/yew/src/hospital.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HospitalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Hospital(props: &HospitalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v4" />
+            <path d="M14 14h-4" />
+            <path d="M14 18h-4" />
+            <path d="M14 8h-4" />
+            <path d="M18 12h2a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-9a2 2 0 0 1 2-2h2" />
+            <path d="M18 22V4a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hotel.rs b/packages/yew/src/hotel.rs
new file mode 100644
index 0000000..b45fc49
--- /dev/null
+++ b/packages/yew/src/hotel.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HotelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Hotel(props: &HotelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 22v-6.57" />
+            <path d="M12 11h.01" />
+            <path d="M12 7h.01" />
+            <path d="M14 15.43V22" />
+            <path d="M15 16a5 5 0 0 0-6 0" />
+            <path d="M16 11h.01" />
+            <path d="M16 7h.01" />
+            <path d="M8 11h.01" />
+            <path d="M8 7h.01" />
+            <rect x="4" y="2" width="16" height="20" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/hourglass.rs b/packages/yew/src/hourglass.rs
new file mode 100644
index 0000000..1e4c9b8
--- /dev/null
+++ b/packages/yew/src/hourglass.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HourglassProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Hourglass(props: &HourglassProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 22h14" />
+            <path d="M5 2h14" />
+            <path d="M17 22v-4.172a2 2 0 0 0-.586-1.414L12 12l-4.414 4.414A2 2 0 0 0 7 17.828V22" />
+            <path d="M7 2v4.172a2 2 0 0 0 .586 1.414L12 12l4.414-4.414A2 2 0 0 0 17 6.172V2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/house.rs b/packages/yew/src/house.rs
new file mode 100644
index 0000000..6bad7d6
--- /dev/null
+++ b/packages/yew/src/house.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HouseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn House(props: &HouseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8" />
+            <path
+                d="M3 10a2 2 0 0 1 .709-1.528l7-5.999a2 2 0 0 1 2.582 0l7 5.999A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/house_plug.rs b/packages/yew/src/house_plug.rs
new file mode 100644
index 0000000..5ddd9c8
--- /dev/null
+++ b/packages/yew/src/house_plug.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HousePlugProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HousePlug(props: &HousePlugProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 12V8.964" />
+            <path d="M14 12V8.964" />
+            <path d="M15 12a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2v-2a1 1 0 0 1 1-1z" />
+            <path
+                d="M8.5 21H5a2 2 0 0 1-2-2v-9a2 2 0 0 1 .709-1.528l7-5.999a2 2 0 0 1 2.582 0l7 5.999A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2h-5a2 2 0 0 1-2-2v-2"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/house_plus.rs b/packages/yew/src/house_plus.rs
new file mode 100644
index 0000000..f4280a6
--- /dev/null
+++ b/packages/yew/src/house_plus.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct HousePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn HousePlus(props: &HousePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M13.22 2.416a2 2 0 0 0-2.511.057l-7 5.999A2 2 0 0 0 3 10v9a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7.354"
+            />
+            <path d="M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8" />
+            <path d="M15 6h6" />
+            <path d="M18 3v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ice_cream_bowl.rs b/packages/yew/src/ice_cream_bowl.rs
new file mode 100644
index 0000000..723ef03
--- /dev/null
+++ b/packages/yew/src/ice_cream_bowl.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct IceCreamBowlProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn IceCreamBowl(props: &IceCreamBowlProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 17c5 0 8-2.69 8-6H4c0 3.31 3 6 8 6m-4 4h8m-4-3v3M5.14 11a3.5 3.5 0 1 1 6.71 0"
+            />
+            <path d="M12.14 11a3.5 3.5 0 1 1 6.71 0" />
+            <path d="M15.5 6.5a3.5 3.5 0 1 0-7 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ice_cream_cone.rs b/packages/yew/src/ice_cream_cone.rs
new file mode 100644
index 0000000..47d4965
--- /dev/null
+++ b/packages/yew/src/ice_cream_cone.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct IceCreamConeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn IceCreamCone(props: &IceCreamConeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 11 4.08 10.35a1 1 0 0 0 1.84 0L17 11" />
+            <path d="M17 7A5 5 0 0 0 7 7" />
+            <path d="M17 7a2 2 0 0 1 0 4H7a2 2 0 0 1 0-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/id_card.rs b/packages/yew/src/id_card.rs
new file mode 100644
index 0000000..5f19610
--- /dev/null
+++ b/packages/yew/src/id_card.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct IdCardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn IdCard(props: &IdCardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 10h2" />
+            <path d="M16 14h2" />
+            <path d="M6.17 15a3 3 0 0 1 5.66 0" />
+            <circle cx="9" cy="11" r="2" />
+            <rect x="2" y="5" width="20" height="14" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/image.rs b/packages/yew/src/image.rs
new file mode 100644
index 0000000..0c66550
--- /dev/null
+++ b/packages/yew/src/image.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImageProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Image(props: &ImageProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <circle cx="9" cy="9" r="2" />
+            <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/image_down.rs b/packages/yew/src/image_down.rs
new file mode 100644
index 0000000..1e76dff
--- /dev/null
+++ b/packages/yew/src/image_down.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImageDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ImageDown(props: &ImageDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.3 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10l-3.1-3.1a2 2 0 0 0-2.814.014L6 21"
+            />
+            <path d="m14 19 3 3v-5.5" />
+            <path d="m17 22 3-3" />
+            <circle cx="9" cy="9" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/image_minus.rs b/packages/yew/src/image_minus.rs
new file mode 100644
index 0000000..e31dd8d
--- /dev/null
+++ b/packages/yew/src/image_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImageMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ImageMinus(props: &ImageMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 9v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7" />
+            <line x1="16" x2="22" y1="5" y2="5" />
+            <circle cx="9" cy="9" r="2" />
+            <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/image_off.rs b/packages/yew/src/image_off.rs
new file mode 100644
index 0000000..7d85ef2
--- /dev/null
+++ b/packages/yew/src/image_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImageOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ImageOff(props: &ImageOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="22" y1="2" y2="22" />
+            <path d="M10.41 10.41a2 2 0 1 1-2.83-2.83" />
+            <line x1="13.5" x2="6" y1="13.5" y2="21" />
+            <line x1="18" x2="21" y1="12" y2="15" />
+            <path d="M3.59 3.59A1.99 1.99 0 0 0 3 5v14a2 2 0 0 0 2 2h14c.55 0 1.052-.22 1.41-.59" />
+            <path d="M21 15V5a2 2 0 0 0-2-2H9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/image_play.rs b/packages/yew/src/image_play.rs
new file mode 100644
index 0000000..ff7f3d8
--- /dev/null
+++ b/packages/yew/src/image_play.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImagePlayProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ImagePlay(props: &ImagePlayProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m11 16-5 5" />
+            <path d="M11 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6.5" />
+            <path
+                d="M15.765 22a.5.5 0 0 1-.765-.424V13.38a.5.5 0 0 1 .765-.424l5.878 3.674a1 1 0 0 1 0 1.696z"
+            />
+            <circle cx="9" cy="9" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/image_plus.rs b/packages/yew/src/image_plus.rs
new file mode 100644
index 0000000..5f2e78c
--- /dev/null
+++ b/packages/yew/src/image_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImagePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ImagePlus(props: &ImagePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 5h6" />
+            <path d="M19 2v6" />
+            <path d="M21 11.5V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7.5" />
+            <path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21" />
+            <circle cx="9" cy="9" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/image_up.rs b/packages/yew/src/image_up.rs
new file mode 100644
index 0000000..780d315
--- /dev/null
+++ b/packages/yew/src/image_up.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImageUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ImageUp(props: &ImageUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.3 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10l-3.1-3.1a2 2 0 0 0-2.814.014L6 21"
+            />
+            <path d="m14 19.5 3-3 3 3" />
+            <path d="M17 22v-5.5" />
+            <circle cx="9" cy="9" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/images.rs b/packages/yew/src/images.rs
new file mode 100644
index 0000000..98d9f11
--- /dev/null
+++ b/packages/yew/src/images.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImagesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Images(props: &ImagesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 22H4a2 2 0 0 1-2-2V6" />
+            <path d="m22 13-1.296-1.296a2.41 2.41 0 0 0-3.408 0L11 18" />
+            <circle cx="12" cy="8" r="2" />
+            <rect width="16" height="16" x="6" y="2" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/import.rs b/packages/yew/src/import.rs
new file mode 100644
index 0000000..cc3ecb5
--- /dev/null
+++ b/packages/yew/src/import.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ImportProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Import(props: &ImportProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v12" />
+            <path d="m8 11 4 4 4-4" />
+            <path d="M8 5H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/inbox.rs b/packages/yew/src/inbox.rs
new file mode 100644
index 0000000..9fa8334
--- /dev/null
+++ b/packages/yew/src/inbox.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct InboxProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Inbox(props: &InboxProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="22 12 16 12 14 15 10 15 8 12 2 12" />
+            <path
+                d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/indent_decrease.rs b/packages/yew/src/indent_decrease.rs
new file mode 100644
index 0000000..507daee
--- /dev/null
+++ b/packages/yew/src/indent_decrease.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct IndentDecreaseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn IndentDecrease(props: &IndentDecreaseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12H11" />
+            <path d="M21 18H11" />
+            <path d="M21 6H11" />
+            <path d="m7 8-4 4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/indent_increase.rs b/packages/yew/src/indent_increase.rs
new file mode 100644
index 0000000..dc34d02
--- /dev/null
+++ b/packages/yew/src/indent_increase.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct IndentIncreaseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn IndentIncrease(props: &IndentIncreaseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12H11" />
+            <path d="M21 18H11" />
+            <path d="M21 6H11" />
+            <path d="m3 8 4 4-4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/indian_rupee.rs b/packages/yew/src/indian_rupee.rs
new file mode 100644
index 0000000..2efa5e7
--- /dev/null
+++ b/packages/yew/src/indian_rupee.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct IndianRupeeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn IndianRupee(props: &IndianRupeeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 3h12" />
+            <path d="M6 8h12" />
+            <path d="m6 13 8.5 8" />
+            <path d="M6 13h3" />
+            <path d="M9 13c6.667 0 6.667-10 0-10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/infinity.rs b/packages/yew/src/infinity.rs
new file mode 100644
index 0000000..9684254
--- /dev/null
+++ b/packages/yew/src/infinity.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct InfinityProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Infinity(props: &InfinityProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 12c-2-2.67-4-4-6-4a4 4 0 1 0 0 8c2 0 4-1.33 6-4Zm0 0c2 2.67 4 4 6 4a4 4 0 0 0 0-8c-2 0-4 1.33-6 4Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/info.rs b/packages/yew/src/info.rs
new file mode 100644
index 0000000..b6bec22
--- /dev/null
+++ b/packages/yew/src/info.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct InfoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Info(props: &InfoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M12 16v-4" />
+            <path d="M12 8h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/inspection_panel.rs b/packages/yew/src/inspection_panel.rs
new file mode 100644
index 0000000..6bf4597
--- /dev/null
+++ b/packages/yew/src/inspection_panel.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct InspectionPanelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn InspectionPanel(props: &InspectionPanelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M7 7h.01" />
+            <path d="M17 7h.01" />
+            <path d="M7 17h.01" />
+            <path d="M17 17h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/instagram.rs b/packages/yew/src/instagram.rs
new file mode 100644
index 0000000..241f916
--- /dev/null
+++ b/packages/yew/src/instagram.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct InstagramProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Instagram(props: &InstagramProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="20" x="2" y="2" rx="5" ry="5" />
+            <path d="M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z" />
+            <line x1="17.5" x2="17.51" y1="6.5" y2="6.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/italic.rs b/packages/yew/src/italic.rs
new file mode 100644
index 0000000..5d9a635
--- /dev/null
+++ b/packages/yew/src/italic.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ItalicProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Italic(props: &ItalicProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="19" x2="10" y1="4" y2="4" />
+            <line x1="14" x2="5" y1="20" y2="20" />
+            <line x1="15" x2="9" y1="4" y2="20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/iteration_ccw.rs b/packages/yew/src/iteration_ccw.rs
new file mode 100644
index 0000000..977ea09
--- /dev/null
+++ b/packages/yew/src/iteration_ccw.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct IterationCcwProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn IterationCcw(props: &IterationCcwProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 10c0-4.4-3.6-8-8-8s-8 3.6-8 8 3.6 8 8 8h8" />
+            <polyline points="16 14 20 18 16 22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/iteration_cw.rs b/packages/yew/src/iteration_cw.rs
new file mode 100644
index 0000000..80063bc
--- /dev/null
+++ b/packages/yew/src/iteration_cw.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct IterationCwProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn IterationCw(props: &IterationCwProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10c0-4.4 3.6-8 8-8s8 3.6 8 8-3.6 8-8 8H4" />
+            <polyline points="8 22 4 18 8 14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/japanese_yen.rs b/packages/yew/src/japanese_yen.rs
new file mode 100644
index 0000000..c751d0e
--- /dev/null
+++ b/packages/yew/src/japanese_yen.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct JapaneseYenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn JapaneseYen(props: &JapaneseYenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 9.5V21m0-11.5L6 3m6 6.5L18 3" />
+            <path d="M6 15h12" />
+            <path d="M6 11h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/joystick.rs b/packages/yew/src/joystick.rs
new file mode 100644
index 0000000..c07a556
--- /dev/null
+++ b/packages/yew/src/joystick.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct JoystickProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Joystick(props: &JoystickProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-2Z" />
+            <path d="M6 15v-2" />
+            <path d="M12 15V9" />
+            <circle cx="12" cy="6" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/kanban.rs b/packages/yew/src/kanban.rs
new file mode 100644
index 0000000..8f433eb
--- /dev/null
+++ b/packages/yew/src/kanban.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct KanbanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Kanban(props: &KanbanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 5v11" />
+            <path d="M12 5v6" />
+            <path d="M18 5v14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/key.rs b/packages/yew/src/key.rs
new file mode 100644
index 0000000..1904b79
--- /dev/null
+++ b/packages/yew/src/key.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct KeyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Key(props: &KeyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15.5 7.5 2.3 2.3a1 1 0 0 0 1.4 0l2.1-2.1a1 1 0 0 0 0-1.4L19 4" />
+            <path d="m21 2-9.6 9.6" />
+            <circle cx="7.5" cy="15.5" r="5.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/key_round.rs b/packages/yew/src/key_round.rs
new file mode 100644
index 0000000..ced2963
--- /dev/null
+++ b/packages/yew/src/key_round.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct KeyRoundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn KeyRound(props: &KeyRoundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.586 17.414A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814a6.5 6.5 0 1 0-4-4z"
+            />
+            <circle cx="16.5" cy="7.5" r=".5" fill="currentColor" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/key_square.rs b/packages/yew/src/key_square.rs
new file mode 100644
index 0000000..eb5e616
--- /dev/null
+++ b/packages/yew/src/key_square.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct KeySquareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn KeySquare(props: &KeySquareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12.4 2.7a2.5 2.5 0 0 1 3.4 0l5.5 5.5a2.5 2.5 0 0 1 0 3.4l-3.7 3.7a2.5 2.5 0 0 1-3.4 0L8.7 9.8a2.5 2.5 0 0 1 0-3.4z"
+            />
+            <path d="m14 7 3 3" />
+            <path
+                d="m9.4 10.6-6.814 6.814A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/keyboard.rs b/packages/yew/src/keyboard.rs
new file mode 100644
index 0000000..d956096
--- /dev/null
+++ b/packages/yew/src/keyboard.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct KeyboardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Keyboard(props: &KeyboardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 8h.01" />
+            <path d="M12 12h.01" />
+            <path d="M14 8h.01" />
+            <path d="M16 12h.01" />
+            <path d="M18 8h.01" />
+            <path d="M6 8h.01" />
+            <path d="M7 16h10" />
+            <path d="M8 12h.01" />
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/keyboard_music.rs b/packages/yew/src/keyboard_music.rs
new file mode 100644
index 0000000..2f61583
--- /dev/null
+++ b/packages/yew/src/keyboard_music.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct KeyboardMusicProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn KeyboardMusic(props: &KeyboardMusicProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+            <path d="M6 8h4" />
+            <path d="M14 8h.01" />
+            <path d="M18 8h.01" />
+            <path d="M2 12h20" />
+            <path d="M6 12v4" />
+            <path d="M10 12v4" />
+            <path d="M14 12v4" />
+            <path d="M18 12v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/keyboard_off.rs b/packages/yew/src/keyboard_off.rs
new file mode 100644
index 0000000..6fb9d47
--- /dev/null
+++ b/packages/yew/src/keyboard_off.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct KeyboardOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn KeyboardOff(props: &KeyboardOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M 20 4 A2 2 0 0 1 22 6" />
+            <path d="M 22 6 L 22 16.41" />
+            <path d="M 7 16 L 16 16" />
+            <path d="M 9.69 4 L 20 4" />
+            <path d="M14 8h.01" />
+            <path d="M18 8h.01" />
+            <path d="m2 2 20 20" />
+            <path d="M20 20H4a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2" />
+            <path d="M6 8h.01" />
+            <path d="M8 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lamp.rs b/packages/yew/src/lamp.rs
new file mode 100644
index 0000000..8f6087b
--- /dev/null
+++ b/packages/yew/src/lamp.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LampProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Lamp(props: &LampProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2h8l4 10H4L8 2Z" />
+            <path d="M12 12v6" />
+            <path d="M8 22v-2c0-1.1.9-2 2-2h4a2 2 0 0 1 2 2v2H8Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lamp_ceiling.rs b/packages/yew/src/lamp_ceiling.rs
new file mode 100644
index 0000000..3b62dd3
--- /dev/null
+++ b/packages/yew/src/lamp_ceiling.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LampCeilingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LampCeiling(props: &LampCeilingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v5" />
+            <path d="M6 7h12l4 9H2l4-9Z" />
+            <path d="M9.17 16a3 3 0 1 0 5.66 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lamp_desk.rs b/packages/yew/src/lamp_desk.rs
new file mode 100644
index 0000000..c3a02a0
--- /dev/null
+++ b/packages/yew/src/lamp_desk.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LampDeskProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LampDesk(props: &LampDeskProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14 5-3 3 2 7 8-8-7-2Z" />
+            <path d="m14 5-3 3-3-3 3-3 3 3Z" />
+            <path d="M9.5 6.5 4 12l3 6" />
+            <path d="M3 22v-2c0-1.1.9-2 2-2h4a2 2 0 0 1 2 2v2H3Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lamp_floor.rs b/packages/yew/src/lamp_floor.rs
new file mode 100644
index 0000000..f7fa5a9
--- /dev/null
+++ b/packages/yew/src/lamp_floor.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LampFloorProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LampFloor(props: &LampFloorProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 2h6l3 7H6l3-7Z" />
+            <path d="M12 9v13" />
+            <path d="M9 22h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lamp_wall_down.rs b/packages/yew/src/lamp_wall_down.rs
new file mode 100644
index 0000000..72902d0
--- /dev/null
+++ b/packages/yew/src/lamp_wall_down.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LampWallDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LampWallDown(props: &LampWallDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 13h6l3 7H8l3-7Z" />
+            <path d="M14 13V8a2 2 0 0 0-2-2H8" />
+            <path d="M4 9h2a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2H4v6Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lamp_wall_up.rs b/packages/yew/src/lamp_wall_up.rs
new file mode 100644
index 0000000..241f360
--- /dev/null
+++ b/packages/yew/src/lamp_wall_up.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LampWallUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LampWallUp(props: &LampWallUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 4h6l3 7H8l3-7Z" />
+            <path d="M14 11v5a2 2 0 0 1-2 2H8" />
+            <path d="M4 15h2a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2H4v-6Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/land_plot.rs b/packages/yew/src/land_plot.rs
new file mode 100644
index 0000000..9f156b7
--- /dev/null
+++ b/packages/yew/src/land_plot.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LandPlotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LandPlot(props: &LandPlotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 8 6-3-6-3v10" />
+            <path
+                d="m8 11.99-5.5 3.14a1 1 0 0 0 0 1.74l8.5 4.86a2 2 0 0 0 2 0l8.5-4.86a1 1 0 0 0 0-1.74L16 12"
+            />
+            <path d="m6.49 12.85 11.02 6.3" />
+            <path d="M17.51 12.85 6.5 19.15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/landmark.rs b/packages/yew/src/landmark.rs
new file mode 100644
index 0000000..44e0175
--- /dev/null
+++ b/packages/yew/src/landmark.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LandmarkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Landmark(props: &LandmarkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="3" x2="21" y1="22" y2="22" />
+            <line x1="6" x2="6" y1="18" y2="11" />
+            <line x1="10" x2="10" y1="18" y2="11" />
+            <line x1="14" x2="14" y1="18" y2="11" />
+            <line x1="18" x2="18" y1="18" y2="11" />
+            <polygon points="12 2 20 7 4 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/languages.rs b/packages/yew/src/languages.rs
new file mode 100644
index 0000000..9d34255
--- /dev/null
+++ b/packages/yew/src/languages.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LanguagesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Languages(props: &LanguagesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5 8 6 6" />
+            <path d="m4 14 6-6 2-3" />
+            <path d="M2 5h12" />
+            <path d="M7 2h1" />
+            <path d="m22 22-5-10-5 10" />
+            <path d="M14 18h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/laptop.rs b/packages/yew/src/laptop.rs
new file mode 100644
index 0000000..8a2c120
--- /dev/null
+++ b/packages/yew/src/laptop.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LaptopProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Laptop(props: &LaptopProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/laptop_minimal.rs b/packages/yew/src/laptop_minimal.rs
new file mode 100644
index 0000000..017fa12
--- /dev/null
+++ b/packages/yew/src/laptop_minimal.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LaptopMinimalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LaptopMinimal(props: &LaptopMinimalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="12" x="3" y="4" rx="2" ry="2" />
+            <line x1="2" x2="22" y1="20" y2="20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/laptop_minimal_check.rs b/packages/yew/src/laptop_minimal_check.rs
new file mode 100644
index 0000000..4e4b012
--- /dev/null
+++ b/packages/yew/src/laptop_minimal_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LaptopMinimalCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LaptopMinimalCheck(props: &LaptopMinimalCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h20" />
+            <path d="m9 10 2 2 4-4" />
+            <rect x="3" y="4" width="18" height="12" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lasso.rs b/packages/yew/src/lasso.rs
new file mode 100644
index 0000000..082bb72
--- /dev/null
+++ b/packages/yew/src/lasso.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LassoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Lasso(props: &LassoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 22a5 5 0 0 1-2-4" />
+            <path
+                d="M3.3 14A6.8 6.8 0 0 1 2 10c0-4.4 4.5-8 10-8s10 3.6 10 8-4.5 8-10 8a12 12 0 0 1-5-1"
+            />
+            <path d="M5 18a2 2 0 1 0 0-4 2 2 0 0 0 0 4z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lasso_select.rs b/packages/yew/src/lasso_select.rs
new file mode 100644
index 0000000..bbdb876
--- /dev/null
+++ b/packages/yew/src/lasso_select.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LassoSelectProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LassoSelect(props: &LassoSelectProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 22a5 5 0 0 1-2-4" />
+            <path d="M7 16.93c.96.43 1.96.74 2.99.91" />
+            <path
+                d="M3.34 14A6.8 6.8 0 0 1 2 10c0-4.42 4.48-8 10-8s10 3.58 10 8a7.19 7.19 0 0 1-.33 2"
+            />
+            <path d="M5 18a2 2 0 1 0 0-4 2 2 0 0 0 0 4z" />
+            <path
+                d="M14.33 22h-.09a.35.35 0 0 1-.24-.32v-10a.34.34 0 0 1 .33-.34c.08 0 .15.03.21.08l7.34 6a.33.33 0 0 1-.21.59h-4.49l-2.57 3.85a.35.35 0 0 1-.28.14z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/laugh.rs b/packages/yew/src/laugh.rs
new file mode 100644
index 0000000..3d750f8
--- /dev/null
+++ b/packages/yew/src/laugh.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LaughProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Laugh(props: &LaughProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M18 13a6 6 0 0 1-6 5 6 6 0 0 1-6-5h12Z" />
+            <line x1="9" x2="9.01" y1="9" y2="9" />
+            <line x1="15" x2="15.01" y1="9" y2="9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layers.rs b/packages/yew/src/layers.rs
new file mode 100644
index 0000000..bb0f299
--- /dev/null
+++ b/packages/yew/src/layers.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LayersProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Layers(props: &LayersProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83Z"
+            />
+            <path d="m22 17.65-9.17 4.16a2 2 0 0 1-1.66 0L2 17.65" />
+            <path d="m22 12.65-9.17 4.16a2 2 0 0 1-1.66 0L2 12.65" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layers_2.rs b/packages/yew/src/layers_2.rs
new file mode 100644
index 0000000..8e51497
--- /dev/null
+++ b/packages/yew/src/layers_2.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Layers2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Layers2(props: &Layers2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m16.02 12 5.48 3.13a1 1 0 0 1 0 1.74L13 21.74a2 2 0 0 1-2 0l-8.5-4.87a1 1 0 0 1 0-1.74L7.98 12"
+            />
+            <path
+                d="M13 13.74a2 2 0 0 1-2 0L2.5 8.87a1 1 0 0 1 0-1.74L11 2.26a2 2 0 0 1 2 0l8.5 4.87a1 1 0 0 1 0 1.74Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layers_3.rs b/packages/yew/src/layers_3.rs
new file mode 100644
index 0000000..4f0c433
--- /dev/null
+++ b/packages/yew/src/layers_3.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Layers3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Layers3(props: &Layers3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83Z"
+            />
+            <path
+                d="m6.08 9.5-3.5 1.6a1 1 0 0 0 0 1.81l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9a1 1 0 0 0 0-1.83l-3.5-1.59"
+            />
+            <path
+                d="m6.08 14.5-3.5 1.6a1 1 0 0 0 0 1.81l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9a1 1 0 0 0 0-1.83l-3.5-1.59"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layout_dashboard.rs b/packages/yew/src/layout_dashboard.rs
new file mode 100644
index 0000000..06fabad
--- /dev/null
+++ b/packages/yew/src/layout_dashboard.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LayoutDashboardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LayoutDashboard(props: &LayoutDashboardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="9" x="3" y="3" rx="1" />
+            <rect width="7" height="5" x="14" y="3" rx="1" />
+            <rect width="7" height="9" x="14" y="12" rx="1" />
+            <rect width="7" height="5" x="3" y="16" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layout_grid.rs b/packages/yew/src/layout_grid.rs
new file mode 100644
index 0000000..4ca87e6
--- /dev/null
+++ b/packages/yew/src/layout_grid.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LayoutGridProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LayoutGrid(props: &LayoutGridProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="7" x="3" y="3" rx="1" />
+            <rect width="7" height="7" x="14" y="3" rx="1" />
+            <rect width="7" height="7" x="14" y="14" rx="1" />
+            <rect width="7" height="7" x="3" y="14" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layout_list.rs b/packages/yew/src/layout_list.rs
new file mode 100644
index 0000000..4b4bbde
--- /dev/null
+++ b/packages/yew/src/layout_list.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LayoutListProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LayoutList(props: &LayoutListProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="7" x="3" y="3" rx="1" />
+            <rect width="7" height="7" x="3" y="14" rx="1" />
+            <path d="M14 4h7" />
+            <path d="M14 9h7" />
+            <path d="M14 15h7" />
+            <path d="M14 20h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layout_panel_left.rs b/packages/yew/src/layout_panel_left.rs
new file mode 100644
index 0000000..47d2ec3
--- /dev/null
+++ b/packages/yew/src/layout_panel_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LayoutPanelLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LayoutPanelLeft(props: &LayoutPanelLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="18" x="3" y="3" rx="1" />
+            <rect width="7" height="7" x="14" y="3" rx="1" />
+            <rect width="7" height="7" x="14" y="14" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layout_panel_top.rs b/packages/yew/src/layout_panel_top.rs
new file mode 100644
index 0000000..2a39c69
--- /dev/null
+++ b/packages/yew/src/layout_panel_top.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LayoutPanelTopProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LayoutPanelTop(props: &LayoutPanelTopProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="7" x="3" y="3" rx="1" />
+            <rect width="7" height="7" x="3" y="14" rx="1" />
+            <rect width="7" height="7" x="14" y="14" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/layout_template.rs b/packages/yew/src/layout_template.rs
new file mode 100644
index 0000000..dd0247e
--- /dev/null
+++ b/packages/yew/src/layout_template.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LayoutTemplateProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LayoutTemplate(props: &LayoutTemplateProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="7" x="3" y="3" rx="1" />
+            <rect width="9" height="7" x="3" y="14" rx="1" />
+            <rect width="5" height="7" x="16" y="14" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/leaf.rs b/packages/yew/src/leaf.rs
new file mode 100644
index 0000000..550a4d5
--- /dev/null
+++ b/packages/yew/src/leaf.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LeafProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Leaf(props: &LeafProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11 20A7 7 0 0 1 9.8 6.1C15.5 5 17 4.48 19 2c1 2 2 4.18 2 8 0 5.5-4.78 10-10 10Z"
+            />
+            <path d="M2 21c0-3 1.85-5.36 5.08-6C9.5 14.52 12 13 13 12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/leafy_green.rs b/packages/yew/src/leafy_green.rs
new file mode 100644
index 0000000..80872a7
--- /dev/null
+++ b/packages/yew/src/leafy_green.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LeafyGreenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LeafyGreen(props: &LeafyGreenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 22c1.25-.987 2.27-1.975 3.9-2.2a5.56 5.56 0 0 1 3.8 1.5 4 4 0 0 0 6.187-2.353 3.5 3.5 0 0 0 3.69-5.116A3.5 3.5 0 0 0 20.95 8 3.5 3.5 0 1 0 16 3.05a3.5 3.5 0 0 0-5.831 1.373 3.5 3.5 0 0 0-5.116 3.69 4 4 0 0 0-2.348 6.155C3.499 15.42 4.409 16.712 4.2 18.1 3.926 19.743 3.014 20.732 2 22"
+            />
+            <path d="M2 22 17 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lectern.rs b/packages/yew/src/lectern.rs
new file mode 100644
index 0000000..f6cce6f
--- /dev/null
+++ b/packages/yew/src/lectern.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LecternProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Lectern(props: &LecternProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M16 12h3a2 2 0 0 0 1.902-1.38l1.056-3.333A1 1 0 0 0 21 6H3a1 1 0 0 0-.958 1.287l1.056 3.334A2 2 0 0 0 5 12h3"
+            />
+            <path d="M18 6V3a1 1 0 0 0-1-1h-3" />
+            <rect width="8" height="12" x="8" y="10" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/letter_text.rs b/packages/yew/src/letter_text.rs
new file mode 100644
index 0000000..1056f2e
--- /dev/null
+++ b/packages/yew/src/letter_text.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LetterTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LetterText(props: &LetterTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 12h6" />
+            <path d="M15 6h6" />
+            <path d="m3 13 3.553-7.724a.5.5 0 0 1 .894 0L11 13" />
+            <path d="M3 18h18" />
+            <path d="M4 11h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lib.rs b/packages/yew/src/lib.rs
index 19fc979..a33015a 100644
--- a/packages/yew/src/lib.rs
+++ b/packages/yew/src/lib.rs
@@ -3,3 +3,6163 @@
 //! Lucide is a beautiful & consistent icon toolkit made by the community.
 //!
 //! See [the Rust Lucide book](https://lucide.rustforweb.org/yew.html) for more documenation.
+
+#![allow(ambiguous_glob_reexports)]
+
+#[cfg(feature = "a-arrow-down")]
+mod a_arrow_down;
+#[cfg(feature = "a-arrow-up")]
+mod a_arrow_up;
+#[cfg(feature = "a-large-small")]
+mod a_large_small;
+#[cfg(feature = "accessibility")]
+mod accessibility;
+#[cfg(feature = "activity")]
+mod activity;
+#[cfg(feature = "air-vent")]
+mod air_vent;
+#[cfg(feature = "airplay")]
+mod airplay;
+#[cfg(feature = "alarm-clock")]
+mod alarm_clock;
+#[cfg(feature = "alarm-clock-check")]
+mod alarm_clock_check;
+#[cfg(feature = "alarm-clock-minus")]
+mod alarm_clock_minus;
+#[cfg(feature = "alarm-clock-off")]
+mod alarm_clock_off;
+#[cfg(feature = "alarm-clock-plus")]
+mod alarm_clock_plus;
+#[cfg(feature = "alarm-smoke")]
+mod alarm_smoke;
+#[cfg(feature = "album")]
+mod album;
+#[cfg(feature = "align-center")]
+mod align_center;
+#[cfg(feature = "align-center-horizontal")]
+mod align_center_horizontal;
+#[cfg(feature = "align-center-vertical")]
+mod align_center_vertical;
+#[cfg(feature = "align-end-horizontal")]
+mod align_end_horizontal;
+#[cfg(feature = "align-end-vertical")]
+mod align_end_vertical;
+#[cfg(feature = "align-horizontal-distribute-center")]
+mod align_horizontal_distribute_center;
+#[cfg(feature = "align-horizontal-distribute-end")]
+mod align_horizontal_distribute_end;
+#[cfg(feature = "align-horizontal-distribute-start")]
+mod align_horizontal_distribute_start;
+#[cfg(feature = "align-horizontal-justify-center")]
+mod align_horizontal_justify_center;
+#[cfg(feature = "align-horizontal-justify-end")]
+mod align_horizontal_justify_end;
+#[cfg(feature = "align-horizontal-justify-start")]
+mod align_horizontal_justify_start;
+#[cfg(feature = "align-horizontal-space-around")]
+mod align_horizontal_space_around;
+#[cfg(feature = "align-horizontal-space-between")]
+mod align_horizontal_space_between;
+#[cfg(feature = "align-justify")]
+mod align_justify;
+#[cfg(feature = "align-left")]
+mod align_left;
+#[cfg(feature = "align-right")]
+mod align_right;
+#[cfg(feature = "align-start-horizontal")]
+mod align_start_horizontal;
+#[cfg(feature = "align-start-vertical")]
+mod align_start_vertical;
+#[cfg(feature = "align-vertical-distribute-center")]
+mod align_vertical_distribute_center;
+#[cfg(feature = "align-vertical-distribute-end")]
+mod align_vertical_distribute_end;
+#[cfg(feature = "align-vertical-distribute-start")]
+mod align_vertical_distribute_start;
+#[cfg(feature = "align-vertical-justify-center")]
+mod align_vertical_justify_center;
+#[cfg(feature = "align-vertical-justify-end")]
+mod align_vertical_justify_end;
+#[cfg(feature = "align-vertical-justify-start")]
+mod align_vertical_justify_start;
+#[cfg(feature = "align-vertical-space-around")]
+mod align_vertical_space_around;
+#[cfg(feature = "align-vertical-space-between")]
+mod align_vertical_space_between;
+#[cfg(feature = "ambulance")]
+mod ambulance;
+#[cfg(feature = "ampersand")]
+mod ampersand;
+#[cfg(feature = "ampersands")]
+mod ampersands;
+#[cfg(feature = "amphora")]
+mod amphora;
+#[cfg(feature = "anchor")]
+mod anchor;
+#[cfg(feature = "angry")]
+mod angry;
+#[cfg(feature = "annoyed")]
+mod annoyed;
+#[cfg(feature = "antenna")]
+mod antenna;
+#[cfg(feature = "anvil")]
+mod anvil;
+#[cfg(feature = "aperture")]
+mod aperture;
+#[cfg(feature = "app-window")]
+mod app_window;
+#[cfg(feature = "app-window-mac")]
+mod app_window_mac;
+#[cfg(feature = "apple")]
+mod apple;
+#[cfg(feature = "archive")]
+mod archive;
+#[cfg(feature = "archive-restore")]
+mod archive_restore;
+#[cfg(feature = "archive-x")]
+mod archive_x;
+#[cfg(feature = "armchair")]
+mod armchair;
+#[cfg(feature = "arrow-big-down")]
+mod arrow_big_down;
+#[cfg(feature = "arrow-big-down-dash")]
+mod arrow_big_down_dash;
+#[cfg(feature = "arrow-big-left")]
+mod arrow_big_left;
+#[cfg(feature = "arrow-big-left-dash")]
+mod arrow_big_left_dash;
+#[cfg(feature = "arrow-big-right")]
+mod arrow_big_right;
+#[cfg(feature = "arrow-big-right-dash")]
+mod arrow_big_right_dash;
+#[cfg(feature = "arrow-big-up")]
+mod arrow_big_up;
+#[cfg(feature = "arrow-big-up-dash")]
+mod arrow_big_up_dash;
+#[cfg(feature = "arrow-down")]
+mod arrow_down;
+#[cfg(feature = "arrow-down-0-1")]
+mod arrow_down_0_1;
+#[cfg(feature = "arrow-down-1-0")]
+mod arrow_down_1_0;
+#[cfg(feature = "arrow-down-a-z")]
+mod arrow_down_a_z;
+#[cfg(feature = "arrow-down-from-line")]
+mod arrow_down_from_line;
+#[cfg(feature = "arrow-down-left")]
+mod arrow_down_left;
+#[cfg(feature = "arrow-down-narrow-wide")]
+mod arrow_down_narrow_wide;
+#[cfg(feature = "arrow-down-right")]
+mod arrow_down_right;
+#[cfg(feature = "arrow-down-to-dot")]
+mod arrow_down_to_dot;
+#[cfg(feature = "arrow-down-to-line")]
+mod arrow_down_to_line;
+#[cfg(feature = "arrow-down-up")]
+mod arrow_down_up;
+#[cfg(feature = "arrow-down-wide-narrow")]
+mod arrow_down_wide_narrow;
+#[cfg(feature = "arrow-down-z-a")]
+mod arrow_down_z_a;
+#[cfg(feature = "arrow-left")]
+mod arrow_left;
+#[cfg(feature = "arrow-left-from-line")]
+mod arrow_left_from_line;
+#[cfg(feature = "arrow-left-right")]
+mod arrow_left_right;
+#[cfg(feature = "arrow-left-to-line")]
+mod arrow_left_to_line;
+#[cfg(feature = "arrow-right")]
+mod arrow_right;
+#[cfg(feature = "arrow-right-from-line")]
+mod arrow_right_from_line;
+#[cfg(feature = "arrow-right-left")]
+mod arrow_right_left;
+#[cfg(feature = "arrow-right-to-line")]
+mod arrow_right_to_line;
+#[cfg(feature = "arrow-up")]
+mod arrow_up;
+#[cfg(feature = "arrow-up-0-1")]
+mod arrow_up_0_1;
+#[cfg(feature = "arrow-up-1-0")]
+mod arrow_up_1_0;
+#[cfg(feature = "arrow-up-a-z")]
+mod arrow_up_a_z;
+#[cfg(feature = "arrow-up-down")]
+mod arrow_up_down;
+#[cfg(feature = "arrow-up-from-dot")]
+mod arrow_up_from_dot;
+#[cfg(feature = "arrow-up-from-line")]
+mod arrow_up_from_line;
+#[cfg(feature = "arrow-up-left")]
+mod arrow_up_left;
+#[cfg(feature = "arrow-up-narrow-wide")]
+mod arrow_up_narrow_wide;
+#[cfg(feature = "arrow-up-right")]
+mod arrow_up_right;
+#[cfg(feature = "arrow-up-to-line")]
+mod arrow_up_to_line;
+#[cfg(feature = "arrow-up-wide-narrow")]
+mod arrow_up_wide_narrow;
+#[cfg(feature = "arrow-up-z-a")]
+mod arrow_up_z_a;
+#[cfg(feature = "arrows-up-from-line")]
+mod arrows_up_from_line;
+#[cfg(feature = "asterisk")]
+mod asterisk;
+#[cfg(feature = "at-sign")]
+mod at_sign;
+#[cfg(feature = "atom")]
+mod atom;
+#[cfg(feature = "audio-lines")]
+mod audio_lines;
+#[cfg(feature = "audio-waveform")]
+mod audio_waveform;
+#[cfg(feature = "award")]
+mod award;
+#[cfg(feature = "axe")]
+mod axe;
+#[cfg(feature = "axis-3-d")]
+mod axis_3_d;
+#[cfg(feature = "baby")]
+mod baby;
+#[cfg(feature = "backpack")]
+mod backpack;
+#[cfg(feature = "badge")]
+mod badge;
+#[cfg(feature = "badge-alert")]
+mod badge_alert;
+#[cfg(feature = "badge-cent")]
+mod badge_cent;
+#[cfg(feature = "badge-check")]
+mod badge_check;
+#[cfg(feature = "badge-dollar-sign")]
+mod badge_dollar_sign;
+#[cfg(feature = "badge-euro")]
+mod badge_euro;
+#[cfg(feature = "badge-help")]
+mod badge_help;
+#[cfg(feature = "badge-indian-rupee")]
+mod badge_indian_rupee;
+#[cfg(feature = "badge-info")]
+mod badge_info;
+#[cfg(feature = "badge-japanese-yen")]
+mod badge_japanese_yen;
+#[cfg(feature = "badge-minus")]
+mod badge_minus;
+#[cfg(feature = "badge-percent")]
+mod badge_percent;
+#[cfg(feature = "badge-plus")]
+mod badge_plus;
+#[cfg(feature = "badge-pound-sterling")]
+mod badge_pound_sterling;
+#[cfg(feature = "badge-russian-ruble")]
+mod badge_russian_ruble;
+#[cfg(feature = "badge-swiss-franc")]
+mod badge_swiss_franc;
+#[cfg(feature = "badge-x")]
+mod badge_x;
+#[cfg(feature = "baggage-claim")]
+mod baggage_claim;
+#[cfg(feature = "ban")]
+mod ban;
+#[cfg(feature = "banana")]
+mod banana;
+#[cfg(feature = "bandage")]
+mod bandage;
+#[cfg(feature = "banknote")]
+mod banknote;
+#[cfg(feature = "barcode")]
+mod barcode;
+#[cfg(feature = "baseline")]
+mod baseline;
+#[cfg(feature = "bath")]
+mod bath;
+#[cfg(feature = "battery")]
+mod battery;
+#[cfg(feature = "battery-charging")]
+mod battery_charging;
+#[cfg(feature = "battery-full")]
+mod battery_full;
+#[cfg(feature = "battery-low")]
+mod battery_low;
+#[cfg(feature = "battery-medium")]
+mod battery_medium;
+#[cfg(feature = "battery-warning")]
+mod battery_warning;
+#[cfg(feature = "beaker")]
+mod beaker;
+#[cfg(feature = "bean")]
+mod bean;
+#[cfg(feature = "bean-off")]
+mod bean_off;
+#[cfg(feature = "bed")]
+mod bed;
+#[cfg(feature = "bed-double")]
+mod bed_double;
+#[cfg(feature = "bed-single")]
+mod bed_single;
+#[cfg(feature = "beef")]
+mod beef;
+#[cfg(feature = "beer")]
+mod beer;
+#[cfg(feature = "beer-off")]
+mod beer_off;
+#[cfg(feature = "bell")]
+mod bell;
+#[cfg(feature = "bell-dot")]
+mod bell_dot;
+#[cfg(feature = "bell-electric")]
+mod bell_electric;
+#[cfg(feature = "bell-minus")]
+mod bell_minus;
+#[cfg(feature = "bell-off")]
+mod bell_off;
+#[cfg(feature = "bell-plus")]
+mod bell_plus;
+#[cfg(feature = "bell-ring")]
+mod bell_ring;
+#[cfg(feature = "between-horizontal-end")]
+mod between_horizontal_end;
+#[cfg(feature = "between-horizontal-start")]
+mod between_horizontal_start;
+#[cfg(feature = "between-vertical-end")]
+mod between_vertical_end;
+#[cfg(feature = "between-vertical-start")]
+mod between_vertical_start;
+#[cfg(feature = "biceps-flexed")]
+mod biceps_flexed;
+#[cfg(feature = "bike")]
+mod bike;
+#[cfg(feature = "binary")]
+mod binary;
+#[cfg(feature = "binoculars")]
+mod binoculars;
+#[cfg(feature = "biohazard")]
+mod biohazard;
+#[cfg(feature = "bird")]
+mod bird;
+#[cfg(feature = "bitcoin")]
+mod bitcoin;
+#[cfg(feature = "blend")]
+mod blend;
+#[cfg(feature = "blinds")]
+mod blinds;
+#[cfg(feature = "blocks")]
+mod blocks;
+#[cfg(feature = "bluetooth")]
+mod bluetooth;
+#[cfg(feature = "bluetooth-connected")]
+mod bluetooth_connected;
+#[cfg(feature = "bluetooth-off")]
+mod bluetooth_off;
+#[cfg(feature = "bluetooth-searching")]
+mod bluetooth_searching;
+#[cfg(feature = "bold")]
+mod bold;
+#[cfg(feature = "bolt")]
+mod bolt;
+#[cfg(feature = "bomb")]
+mod bomb;
+#[cfg(feature = "bone")]
+mod bone;
+#[cfg(feature = "book")]
+mod book;
+#[cfg(feature = "book-a")]
+mod book_a;
+#[cfg(feature = "book-audio")]
+mod book_audio;
+#[cfg(feature = "book-check")]
+mod book_check;
+#[cfg(feature = "book-copy")]
+mod book_copy;
+#[cfg(feature = "book-dashed")]
+mod book_dashed;
+#[cfg(feature = "book-down")]
+mod book_down;
+#[cfg(feature = "book-headphones")]
+mod book_headphones;
+#[cfg(feature = "book-heart")]
+mod book_heart;
+#[cfg(feature = "book-image")]
+mod book_image;
+#[cfg(feature = "book-key")]
+mod book_key;
+#[cfg(feature = "book-lock")]
+mod book_lock;
+#[cfg(feature = "book-marked")]
+mod book_marked;
+#[cfg(feature = "book-minus")]
+mod book_minus;
+#[cfg(feature = "book-open")]
+mod book_open;
+#[cfg(feature = "book-open-check")]
+mod book_open_check;
+#[cfg(feature = "book-open-text")]
+mod book_open_text;
+#[cfg(feature = "book-plus")]
+mod book_plus;
+#[cfg(feature = "book-text")]
+mod book_text;
+#[cfg(feature = "book-type")]
+mod book_type;
+#[cfg(feature = "book-up")]
+mod book_up;
+#[cfg(feature = "book-up-2")]
+mod book_up_2;
+#[cfg(feature = "book-user")]
+mod book_user;
+#[cfg(feature = "book-x")]
+mod book_x;
+#[cfg(feature = "bookmark")]
+mod bookmark;
+#[cfg(feature = "bookmark-check")]
+mod bookmark_check;
+#[cfg(feature = "bookmark-minus")]
+mod bookmark_minus;
+#[cfg(feature = "bookmark-plus")]
+mod bookmark_plus;
+#[cfg(feature = "bookmark-x")]
+mod bookmark_x;
+#[cfg(feature = "boom-box")]
+mod boom_box;
+#[cfg(feature = "bot")]
+mod bot;
+#[cfg(feature = "bot-message-square")]
+mod bot_message_square;
+#[cfg(feature = "bot-off")]
+mod bot_off;
+#[cfg(feature = "box")]
+mod r#box;
+#[cfg(feature = "boxes")]
+mod boxes;
+#[cfg(feature = "braces")]
+mod braces;
+#[cfg(feature = "brackets")]
+mod brackets;
+#[cfg(feature = "brain")]
+mod brain;
+#[cfg(feature = "brain-circuit")]
+mod brain_circuit;
+#[cfg(feature = "brain-cog")]
+mod brain_cog;
+#[cfg(feature = "brick-wall")]
+mod brick_wall;
+#[cfg(feature = "briefcase")]
+mod briefcase;
+#[cfg(feature = "briefcase-business")]
+mod briefcase_business;
+#[cfg(feature = "briefcase-conveyor-belt")]
+mod briefcase_conveyor_belt;
+#[cfg(feature = "briefcase-medical")]
+mod briefcase_medical;
+#[cfg(feature = "bring-to-front")]
+mod bring_to_front;
+#[cfg(feature = "brush")]
+mod brush;
+#[cfg(feature = "bug")]
+mod bug;
+#[cfg(feature = "bug-off")]
+mod bug_off;
+#[cfg(feature = "bug-play")]
+mod bug_play;
+#[cfg(feature = "building")]
+mod building;
+#[cfg(feature = "building-2")]
+mod building_2;
+#[cfg(feature = "bus")]
+mod bus;
+#[cfg(feature = "bus-front")]
+mod bus_front;
+#[cfg(feature = "cable")]
+mod cable;
+#[cfg(feature = "cable-car")]
+mod cable_car;
+#[cfg(feature = "cake")]
+mod cake;
+#[cfg(feature = "cake-slice")]
+mod cake_slice;
+#[cfg(feature = "calculator")]
+mod calculator;
+#[cfg(feature = "calendar")]
+mod calendar;
+#[cfg(feature = "calendar-1")]
+mod calendar_1;
+#[cfg(feature = "calendar-arrow-down")]
+mod calendar_arrow_down;
+#[cfg(feature = "calendar-arrow-up")]
+mod calendar_arrow_up;
+#[cfg(feature = "calendar-check")]
+mod calendar_check;
+#[cfg(feature = "calendar-check-2")]
+mod calendar_check_2;
+#[cfg(feature = "calendar-clock")]
+mod calendar_clock;
+#[cfg(feature = "calendar-cog")]
+mod calendar_cog;
+#[cfg(feature = "calendar-days")]
+mod calendar_days;
+#[cfg(feature = "calendar-fold")]
+mod calendar_fold;
+#[cfg(feature = "calendar-heart")]
+mod calendar_heart;
+#[cfg(feature = "calendar-minus")]
+mod calendar_minus;
+#[cfg(feature = "calendar-minus-2")]
+mod calendar_minus_2;
+#[cfg(feature = "calendar-off")]
+mod calendar_off;
+#[cfg(feature = "calendar-plus")]
+mod calendar_plus;
+#[cfg(feature = "calendar-plus-2")]
+mod calendar_plus_2;
+#[cfg(feature = "calendar-range")]
+mod calendar_range;
+#[cfg(feature = "calendar-search")]
+mod calendar_search;
+#[cfg(feature = "calendar-x")]
+mod calendar_x;
+#[cfg(feature = "calendar-x-2")]
+mod calendar_x_2;
+#[cfg(feature = "camera")]
+mod camera;
+#[cfg(feature = "camera-off")]
+mod camera_off;
+#[cfg(feature = "candy")]
+mod candy;
+#[cfg(feature = "candy-cane")]
+mod candy_cane;
+#[cfg(feature = "candy-off")]
+mod candy_off;
+#[cfg(feature = "cannabis")]
+mod cannabis;
+#[cfg(feature = "captions")]
+mod captions;
+#[cfg(feature = "captions-off")]
+mod captions_off;
+#[cfg(feature = "car")]
+mod car;
+#[cfg(feature = "car-front")]
+mod car_front;
+#[cfg(feature = "car-taxi-front")]
+mod car_taxi_front;
+#[cfg(feature = "caravan")]
+mod caravan;
+#[cfg(feature = "carrot")]
+mod carrot;
+#[cfg(feature = "case-lower")]
+mod case_lower;
+#[cfg(feature = "case-sensitive")]
+mod case_sensitive;
+#[cfg(feature = "case-upper")]
+mod case_upper;
+#[cfg(feature = "cassette-tape")]
+mod cassette_tape;
+#[cfg(feature = "cast")]
+mod cast;
+#[cfg(feature = "castle")]
+mod castle;
+#[cfg(feature = "cat")]
+mod cat;
+#[cfg(feature = "cctv")]
+mod cctv;
+#[cfg(feature = "chart-area")]
+mod chart_area;
+#[cfg(feature = "chart-bar")]
+mod chart_bar;
+#[cfg(feature = "chart-bar-big")]
+mod chart_bar_big;
+#[cfg(feature = "chart-bar-decreasing")]
+mod chart_bar_decreasing;
+#[cfg(feature = "chart-bar-increasing")]
+mod chart_bar_increasing;
+#[cfg(feature = "chart-bar-stacked")]
+mod chart_bar_stacked;
+#[cfg(feature = "chart-candlestick")]
+mod chart_candlestick;
+#[cfg(feature = "chart-column")]
+mod chart_column;
+#[cfg(feature = "chart-column-big")]
+mod chart_column_big;
+#[cfg(feature = "chart-column-decreasing")]
+mod chart_column_decreasing;
+#[cfg(feature = "chart-column-increasing")]
+mod chart_column_increasing;
+#[cfg(feature = "chart-column-stacked")]
+mod chart_column_stacked;
+#[cfg(feature = "chart-gantt")]
+mod chart_gantt;
+#[cfg(feature = "chart-line")]
+mod chart_line;
+#[cfg(feature = "chart-network")]
+mod chart_network;
+#[cfg(feature = "chart-no-axes-column")]
+mod chart_no_axes_column;
+#[cfg(feature = "chart-no-axes-column-decreasing")]
+mod chart_no_axes_column_decreasing;
+#[cfg(feature = "chart-no-axes-column-increasing")]
+mod chart_no_axes_column_increasing;
+#[cfg(feature = "chart-no-axes-combined")]
+mod chart_no_axes_combined;
+#[cfg(feature = "chart-no-axes-gantt")]
+mod chart_no_axes_gantt;
+#[cfg(feature = "chart-pie")]
+mod chart_pie;
+#[cfg(feature = "chart-scatter")]
+mod chart_scatter;
+#[cfg(feature = "chart-spline")]
+mod chart_spline;
+#[cfg(feature = "check")]
+mod check;
+#[cfg(feature = "check-check")]
+mod check_check;
+#[cfg(feature = "chef-hat")]
+mod chef_hat;
+#[cfg(feature = "cherry")]
+mod cherry;
+#[cfg(feature = "chevron-down")]
+mod chevron_down;
+#[cfg(feature = "chevron-first")]
+mod chevron_first;
+#[cfg(feature = "chevron-last")]
+mod chevron_last;
+#[cfg(feature = "chevron-left")]
+mod chevron_left;
+#[cfg(feature = "chevron-right")]
+mod chevron_right;
+#[cfg(feature = "chevron-up")]
+mod chevron_up;
+#[cfg(feature = "chevrons-down")]
+mod chevrons_down;
+#[cfg(feature = "chevrons-down-up")]
+mod chevrons_down_up;
+#[cfg(feature = "chevrons-left")]
+mod chevrons_left;
+#[cfg(feature = "chevrons-left-right")]
+mod chevrons_left_right;
+#[cfg(feature = "chevrons-left-right-ellipsis")]
+mod chevrons_left_right_ellipsis;
+#[cfg(feature = "chevrons-right")]
+mod chevrons_right;
+#[cfg(feature = "chevrons-right-left")]
+mod chevrons_right_left;
+#[cfg(feature = "chevrons-up")]
+mod chevrons_up;
+#[cfg(feature = "chevrons-up-down")]
+mod chevrons_up_down;
+#[cfg(feature = "chrome")]
+mod chrome;
+#[cfg(feature = "church")]
+mod church;
+#[cfg(feature = "cigarette")]
+mod cigarette;
+#[cfg(feature = "cigarette-off")]
+mod cigarette_off;
+#[cfg(feature = "circle")]
+mod circle;
+#[cfg(feature = "circle-alert")]
+mod circle_alert;
+#[cfg(feature = "circle-arrow-down")]
+mod circle_arrow_down;
+#[cfg(feature = "circle-arrow-left")]
+mod circle_arrow_left;
+#[cfg(feature = "circle-arrow-out-down-left")]
+mod circle_arrow_out_down_left;
+#[cfg(feature = "circle-arrow-out-down-right")]
+mod circle_arrow_out_down_right;
+#[cfg(feature = "circle-arrow-out-up-left")]
+mod circle_arrow_out_up_left;
+#[cfg(feature = "circle-arrow-out-up-right")]
+mod circle_arrow_out_up_right;
+#[cfg(feature = "circle-arrow-right")]
+mod circle_arrow_right;
+#[cfg(feature = "circle-arrow-up")]
+mod circle_arrow_up;
+#[cfg(feature = "circle-check")]
+mod circle_check;
+#[cfg(feature = "circle-check-big")]
+mod circle_check_big;
+#[cfg(feature = "circle-chevron-down")]
+mod circle_chevron_down;
+#[cfg(feature = "circle-chevron-left")]
+mod circle_chevron_left;
+#[cfg(feature = "circle-chevron-right")]
+mod circle_chevron_right;
+#[cfg(feature = "circle-chevron-up")]
+mod circle_chevron_up;
+#[cfg(feature = "circle-dashed")]
+mod circle_dashed;
+#[cfg(feature = "circle-divide")]
+mod circle_divide;
+#[cfg(feature = "circle-dollar-sign")]
+mod circle_dollar_sign;
+#[cfg(feature = "circle-dot")]
+mod circle_dot;
+#[cfg(feature = "circle-dot-dashed")]
+mod circle_dot_dashed;
+#[cfg(feature = "circle-ellipsis")]
+mod circle_ellipsis;
+#[cfg(feature = "circle-equal")]
+mod circle_equal;
+#[cfg(feature = "circle-fading-arrow-up")]
+mod circle_fading_arrow_up;
+#[cfg(feature = "circle-fading-plus")]
+mod circle_fading_plus;
+#[cfg(feature = "circle-gauge")]
+mod circle_gauge;
+#[cfg(feature = "circle-help")]
+mod circle_help;
+#[cfg(feature = "circle-minus")]
+mod circle_minus;
+#[cfg(feature = "circle-off")]
+mod circle_off;
+#[cfg(feature = "circle-parking")]
+mod circle_parking;
+#[cfg(feature = "circle-parking-off")]
+mod circle_parking_off;
+#[cfg(feature = "circle-pause")]
+mod circle_pause;
+#[cfg(feature = "circle-percent")]
+mod circle_percent;
+#[cfg(feature = "circle-play")]
+mod circle_play;
+#[cfg(feature = "circle-plus")]
+mod circle_plus;
+#[cfg(feature = "circle-power")]
+mod circle_power;
+#[cfg(feature = "circle-slash")]
+mod circle_slash;
+#[cfg(feature = "circle-slash-2")]
+mod circle_slash_2;
+#[cfg(feature = "circle-stop")]
+mod circle_stop;
+#[cfg(feature = "circle-user")]
+mod circle_user;
+#[cfg(feature = "circle-user-round")]
+mod circle_user_round;
+#[cfg(feature = "circle-x")]
+mod circle_x;
+#[cfg(feature = "circuit-board")]
+mod circuit_board;
+#[cfg(feature = "citrus")]
+mod citrus;
+#[cfg(feature = "clapperboard")]
+mod clapperboard;
+#[cfg(feature = "clipboard")]
+mod clipboard;
+#[cfg(feature = "clipboard-check")]
+mod clipboard_check;
+#[cfg(feature = "clipboard-copy")]
+mod clipboard_copy;
+#[cfg(feature = "clipboard-list")]
+mod clipboard_list;
+#[cfg(feature = "clipboard-minus")]
+mod clipboard_minus;
+#[cfg(feature = "clipboard-paste")]
+mod clipboard_paste;
+#[cfg(feature = "clipboard-pen")]
+mod clipboard_pen;
+#[cfg(feature = "clipboard-pen-line")]
+mod clipboard_pen_line;
+#[cfg(feature = "clipboard-plus")]
+mod clipboard_plus;
+#[cfg(feature = "clipboard-type")]
+mod clipboard_type;
+#[cfg(feature = "clipboard-x")]
+mod clipboard_x;
+#[cfg(feature = "clock")]
+mod clock;
+#[cfg(feature = "clock-1")]
+mod clock_1;
+#[cfg(feature = "clock-10")]
+mod clock_10;
+#[cfg(feature = "clock-11")]
+mod clock_11;
+#[cfg(feature = "clock-12")]
+mod clock_12;
+#[cfg(feature = "clock-2")]
+mod clock_2;
+#[cfg(feature = "clock-3")]
+mod clock_3;
+#[cfg(feature = "clock-4")]
+mod clock_4;
+#[cfg(feature = "clock-5")]
+mod clock_5;
+#[cfg(feature = "clock-6")]
+mod clock_6;
+#[cfg(feature = "clock-7")]
+mod clock_7;
+#[cfg(feature = "clock-8")]
+mod clock_8;
+#[cfg(feature = "clock-9")]
+mod clock_9;
+#[cfg(feature = "clock-alert")]
+mod clock_alert;
+#[cfg(feature = "clock-arrow-down")]
+mod clock_arrow_down;
+#[cfg(feature = "clock-arrow-up")]
+mod clock_arrow_up;
+#[cfg(feature = "cloud")]
+mod cloud;
+#[cfg(feature = "cloud-alert")]
+mod cloud_alert;
+#[cfg(feature = "cloud-cog")]
+mod cloud_cog;
+#[cfg(feature = "cloud-download")]
+mod cloud_download;
+#[cfg(feature = "cloud-drizzle")]
+mod cloud_drizzle;
+#[cfg(feature = "cloud-fog")]
+mod cloud_fog;
+#[cfg(feature = "cloud-hail")]
+mod cloud_hail;
+#[cfg(feature = "cloud-lightning")]
+mod cloud_lightning;
+#[cfg(feature = "cloud-moon")]
+mod cloud_moon;
+#[cfg(feature = "cloud-moon-rain")]
+mod cloud_moon_rain;
+#[cfg(feature = "cloud-off")]
+mod cloud_off;
+#[cfg(feature = "cloud-rain")]
+mod cloud_rain;
+#[cfg(feature = "cloud-rain-wind")]
+mod cloud_rain_wind;
+#[cfg(feature = "cloud-snow")]
+mod cloud_snow;
+#[cfg(feature = "cloud-sun")]
+mod cloud_sun;
+#[cfg(feature = "cloud-sun-rain")]
+mod cloud_sun_rain;
+#[cfg(feature = "cloud-upload")]
+mod cloud_upload;
+#[cfg(feature = "cloudy")]
+mod cloudy;
+#[cfg(feature = "clover")]
+mod clover;
+#[cfg(feature = "club")]
+mod club;
+#[cfg(feature = "code")]
+mod code;
+#[cfg(feature = "code-xml")]
+mod code_xml;
+#[cfg(feature = "codepen")]
+mod codepen;
+#[cfg(feature = "codesandbox")]
+mod codesandbox;
+#[cfg(feature = "coffee")]
+mod coffee;
+#[cfg(feature = "cog")]
+mod cog;
+#[cfg(feature = "coins")]
+mod coins;
+#[cfg(feature = "columns-2")]
+mod columns_2;
+#[cfg(feature = "columns-3")]
+mod columns_3;
+#[cfg(feature = "columns-4")]
+mod columns_4;
+#[cfg(feature = "combine")]
+mod combine;
+#[cfg(feature = "command")]
+mod command;
+#[cfg(feature = "compass")]
+mod compass;
+#[cfg(feature = "component")]
+mod component;
+#[cfg(feature = "computer")]
+mod computer;
+#[cfg(feature = "concierge-bell")]
+mod concierge_bell;
+#[cfg(feature = "cone")]
+mod cone;
+#[cfg(feature = "construction")]
+mod construction;
+#[cfg(feature = "contact")]
+mod contact;
+#[cfg(feature = "contact-round")]
+mod contact_round;
+#[cfg(feature = "container")]
+mod container;
+#[cfg(feature = "contrast")]
+mod contrast;
+#[cfg(feature = "cookie")]
+mod cookie;
+#[cfg(feature = "cooking-pot")]
+mod cooking_pot;
+#[cfg(feature = "copy")]
+mod copy;
+#[cfg(feature = "copy-check")]
+mod copy_check;
+#[cfg(feature = "copy-minus")]
+mod copy_minus;
+#[cfg(feature = "copy-plus")]
+mod copy_plus;
+#[cfg(feature = "copy-slash")]
+mod copy_slash;
+#[cfg(feature = "copy-x")]
+mod copy_x;
+#[cfg(feature = "copyleft")]
+mod copyleft;
+#[cfg(feature = "copyright")]
+mod copyright;
+#[cfg(feature = "corner-down-left")]
+mod corner_down_left;
+#[cfg(feature = "corner-down-right")]
+mod corner_down_right;
+#[cfg(feature = "corner-left-down")]
+mod corner_left_down;
+#[cfg(feature = "corner-left-up")]
+mod corner_left_up;
+#[cfg(feature = "corner-right-down")]
+mod corner_right_down;
+#[cfg(feature = "corner-right-up")]
+mod corner_right_up;
+#[cfg(feature = "corner-up-left")]
+mod corner_up_left;
+#[cfg(feature = "corner-up-right")]
+mod corner_up_right;
+#[cfg(feature = "cpu")]
+mod cpu;
+#[cfg(feature = "creative-commons")]
+mod creative_commons;
+#[cfg(feature = "credit-card")]
+mod credit_card;
+#[cfg(feature = "croissant")]
+mod croissant;
+#[cfg(feature = "crop")]
+mod crop;
+#[cfg(feature = "cross")]
+mod cross;
+#[cfg(feature = "crosshair")]
+mod crosshair;
+#[cfg(feature = "crown")]
+mod crown;
+#[cfg(feature = "cuboid")]
+mod cuboid;
+#[cfg(feature = "cup-soda")]
+mod cup_soda;
+#[cfg(feature = "currency")]
+mod currency;
+#[cfg(feature = "cylinder")]
+mod cylinder;
+#[cfg(feature = "dam")]
+mod dam;
+#[cfg(feature = "database")]
+mod database;
+#[cfg(feature = "database-backup")]
+mod database_backup;
+#[cfg(feature = "database-zap")]
+mod database_zap;
+#[cfg(feature = "delete")]
+mod delete;
+#[cfg(feature = "dessert")]
+mod dessert;
+#[cfg(feature = "diameter")]
+mod diameter;
+#[cfg(feature = "diamond")]
+mod diamond;
+#[cfg(feature = "diamond-minus")]
+mod diamond_minus;
+#[cfg(feature = "diamond-percent")]
+mod diamond_percent;
+#[cfg(feature = "diamond-plus")]
+mod diamond_plus;
+#[cfg(feature = "dice-1")]
+mod dice_1;
+#[cfg(feature = "dice-2")]
+mod dice_2;
+#[cfg(feature = "dice-3")]
+mod dice_3;
+#[cfg(feature = "dice-4")]
+mod dice_4;
+#[cfg(feature = "dice-5")]
+mod dice_5;
+#[cfg(feature = "dice-6")]
+mod dice_6;
+#[cfg(feature = "dices")]
+mod dices;
+#[cfg(feature = "diff")]
+mod diff;
+#[cfg(feature = "disc")]
+mod disc;
+#[cfg(feature = "disc-2")]
+mod disc_2;
+#[cfg(feature = "disc-3")]
+mod disc_3;
+#[cfg(feature = "disc-album")]
+mod disc_album;
+#[cfg(feature = "divide")]
+mod divide;
+#[cfg(feature = "dna")]
+mod dna;
+#[cfg(feature = "dna-off")]
+mod dna_off;
+#[cfg(feature = "dock")]
+mod dock;
+#[cfg(feature = "dog")]
+mod dog;
+#[cfg(feature = "dollar-sign")]
+mod dollar_sign;
+#[cfg(feature = "donut")]
+mod donut;
+#[cfg(feature = "door-closed")]
+mod door_closed;
+#[cfg(feature = "door-open")]
+mod door_open;
+#[cfg(feature = "dot")]
+mod dot;
+#[cfg(feature = "download")]
+mod download;
+#[cfg(feature = "drafting-compass")]
+mod drafting_compass;
+#[cfg(feature = "drama")]
+mod drama;
+#[cfg(feature = "dribbble")]
+mod dribbble;
+#[cfg(feature = "drill")]
+mod drill;
+#[cfg(feature = "droplet")]
+mod droplet;
+#[cfg(feature = "droplets")]
+mod droplets;
+#[cfg(feature = "drum")]
+mod drum;
+#[cfg(feature = "drumstick")]
+mod drumstick;
+#[cfg(feature = "dumbbell")]
+mod dumbbell;
+#[cfg(feature = "ear")]
+mod ear;
+#[cfg(feature = "ear-off")]
+mod ear_off;
+#[cfg(feature = "earth")]
+mod earth;
+#[cfg(feature = "earth-lock")]
+mod earth_lock;
+#[cfg(feature = "eclipse")]
+mod eclipse;
+#[cfg(feature = "egg")]
+mod egg;
+#[cfg(feature = "egg-fried")]
+mod egg_fried;
+#[cfg(feature = "egg-off")]
+mod egg_off;
+#[cfg(feature = "ellipsis")]
+mod ellipsis;
+#[cfg(feature = "ellipsis-vertical")]
+mod ellipsis_vertical;
+#[cfg(feature = "equal")]
+mod equal;
+#[cfg(feature = "equal-approximately")]
+mod equal_approximately;
+#[cfg(feature = "equal-not")]
+mod equal_not;
+#[cfg(feature = "eraser")]
+mod eraser;
+#[cfg(feature = "ethernet-port")]
+mod ethernet_port;
+#[cfg(feature = "euro")]
+mod euro;
+#[cfg(feature = "expand")]
+mod expand;
+#[cfg(feature = "external-link")]
+mod external_link;
+#[cfg(feature = "eye")]
+mod eye;
+#[cfg(feature = "eye-closed")]
+mod eye_closed;
+#[cfg(feature = "eye-off")]
+mod eye_off;
+#[cfg(feature = "facebook")]
+mod facebook;
+#[cfg(feature = "factory")]
+mod factory;
+#[cfg(feature = "fan")]
+mod fan;
+#[cfg(feature = "fast-forward")]
+mod fast_forward;
+#[cfg(feature = "feather")]
+mod feather;
+#[cfg(feature = "fence")]
+mod fence;
+#[cfg(feature = "ferris-wheel")]
+mod ferris_wheel;
+#[cfg(feature = "figma")]
+mod figma;
+#[cfg(feature = "file")]
+mod file;
+#[cfg(feature = "file-archive")]
+mod file_archive;
+#[cfg(feature = "file-audio")]
+mod file_audio;
+#[cfg(feature = "file-audio-2")]
+mod file_audio_2;
+#[cfg(feature = "file-axis-3-d")]
+mod file_axis_3_d;
+#[cfg(feature = "file-badge")]
+mod file_badge;
+#[cfg(feature = "file-badge-2")]
+mod file_badge_2;
+#[cfg(feature = "file-box")]
+mod file_box;
+#[cfg(feature = "file-chart-column")]
+mod file_chart_column;
+#[cfg(feature = "file-chart-column-increasing")]
+mod file_chart_column_increasing;
+#[cfg(feature = "file-chart-line")]
+mod file_chart_line;
+#[cfg(feature = "file-chart-pie")]
+mod file_chart_pie;
+#[cfg(feature = "file-check")]
+mod file_check;
+#[cfg(feature = "file-check-2")]
+mod file_check_2;
+#[cfg(feature = "file-clock")]
+mod file_clock;
+#[cfg(feature = "file-code")]
+mod file_code;
+#[cfg(feature = "file-code-2")]
+mod file_code_2;
+#[cfg(feature = "file-cog")]
+mod file_cog;
+#[cfg(feature = "file-diff")]
+mod file_diff;
+#[cfg(feature = "file-digit")]
+mod file_digit;
+#[cfg(feature = "file-down")]
+mod file_down;
+#[cfg(feature = "file-heart")]
+mod file_heart;
+#[cfg(feature = "file-image")]
+mod file_image;
+#[cfg(feature = "file-input")]
+mod file_input;
+#[cfg(feature = "file-json")]
+mod file_json;
+#[cfg(feature = "file-json-2")]
+mod file_json_2;
+#[cfg(feature = "file-key")]
+mod file_key;
+#[cfg(feature = "file-key-2")]
+mod file_key_2;
+#[cfg(feature = "file-lock")]
+mod file_lock;
+#[cfg(feature = "file-lock-2")]
+mod file_lock_2;
+#[cfg(feature = "file-minus")]
+mod file_minus;
+#[cfg(feature = "file-minus-2")]
+mod file_minus_2;
+#[cfg(feature = "file-music")]
+mod file_music;
+#[cfg(feature = "file-output")]
+mod file_output;
+#[cfg(feature = "file-pen")]
+mod file_pen;
+#[cfg(feature = "file-pen-line")]
+mod file_pen_line;
+#[cfg(feature = "file-plus")]
+mod file_plus;
+#[cfg(feature = "file-plus-2")]
+mod file_plus_2;
+#[cfg(feature = "file-question")]
+mod file_question;
+#[cfg(feature = "file-scan")]
+mod file_scan;
+#[cfg(feature = "file-search")]
+mod file_search;
+#[cfg(feature = "file-search-2")]
+mod file_search_2;
+#[cfg(feature = "file-sliders")]
+mod file_sliders;
+#[cfg(feature = "file-spreadsheet")]
+mod file_spreadsheet;
+#[cfg(feature = "file-stack")]
+mod file_stack;
+#[cfg(feature = "file-symlink")]
+mod file_symlink;
+#[cfg(feature = "file-terminal")]
+mod file_terminal;
+#[cfg(feature = "file-text")]
+mod file_text;
+#[cfg(feature = "file-type")]
+mod file_type;
+#[cfg(feature = "file-type-2")]
+mod file_type_2;
+#[cfg(feature = "file-up")]
+mod file_up;
+#[cfg(feature = "file-user")]
+mod file_user;
+#[cfg(feature = "file-video")]
+mod file_video;
+#[cfg(feature = "file-video-2")]
+mod file_video_2;
+#[cfg(feature = "file-volume")]
+mod file_volume;
+#[cfg(feature = "file-volume-2")]
+mod file_volume_2;
+#[cfg(feature = "file-warning")]
+mod file_warning;
+#[cfg(feature = "file-x")]
+mod file_x;
+#[cfg(feature = "file-x-2")]
+mod file_x_2;
+#[cfg(feature = "files")]
+mod files;
+#[cfg(feature = "film")]
+mod film;
+#[cfg(feature = "filter")]
+mod filter;
+#[cfg(feature = "filter-x")]
+mod filter_x;
+#[cfg(feature = "fingerprint")]
+mod fingerprint;
+#[cfg(feature = "fire-extinguisher")]
+mod fire_extinguisher;
+#[cfg(feature = "fish")]
+mod fish;
+#[cfg(feature = "fish-off")]
+mod fish_off;
+#[cfg(feature = "fish-symbol")]
+mod fish_symbol;
+#[cfg(feature = "flag")]
+mod flag;
+#[cfg(feature = "flag-off")]
+mod flag_off;
+#[cfg(feature = "flag-triangle-left")]
+mod flag_triangle_left;
+#[cfg(feature = "flag-triangle-right")]
+mod flag_triangle_right;
+#[cfg(feature = "flame")]
+mod flame;
+#[cfg(feature = "flame-kindling")]
+mod flame_kindling;
+#[cfg(feature = "flashlight")]
+mod flashlight;
+#[cfg(feature = "flashlight-off")]
+mod flashlight_off;
+#[cfg(feature = "flask-conical")]
+mod flask_conical;
+#[cfg(feature = "flask-conical-off")]
+mod flask_conical_off;
+#[cfg(feature = "flask-round")]
+mod flask_round;
+#[cfg(feature = "flip-horizontal")]
+mod flip_horizontal;
+#[cfg(feature = "flip-horizontal-2")]
+mod flip_horizontal_2;
+#[cfg(feature = "flip-vertical")]
+mod flip_vertical;
+#[cfg(feature = "flip-vertical-2")]
+mod flip_vertical_2;
+#[cfg(feature = "flower")]
+mod flower;
+#[cfg(feature = "flower-2")]
+mod flower_2;
+#[cfg(feature = "focus")]
+mod focus;
+#[cfg(feature = "fold-horizontal")]
+mod fold_horizontal;
+#[cfg(feature = "fold-vertical")]
+mod fold_vertical;
+#[cfg(feature = "folder")]
+mod folder;
+#[cfg(feature = "folder-archive")]
+mod folder_archive;
+#[cfg(feature = "folder-check")]
+mod folder_check;
+#[cfg(feature = "folder-clock")]
+mod folder_clock;
+#[cfg(feature = "folder-closed")]
+mod folder_closed;
+#[cfg(feature = "folder-code")]
+mod folder_code;
+#[cfg(feature = "folder-cog")]
+mod folder_cog;
+#[cfg(feature = "folder-dot")]
+mod folder_dot;
+#[cfg(feature = "folder-down")]
+mod folder_down;
+#[cfg(feature = "folder-git")]
+mod folder_git;
+#[cfg(feature = "folder-git-2")]
+mod folder_git_2;
+#[cfg(feature = "folder-heart")]
+mod folder_heart;
+#[cfg(feature = "folder-input")]
+mod folder_input;
+#[cfg(feature = "folder-kanban")]
+mod folder_kanban;
+#[cfg(feature = "folder-key")]
+mod folder_key;
+#[cfg(feature = "folder-lock")]
+mod folder_lock;
+#[cfg(feature = "folder-minus")]
+mod folder_minus;
+#[cfg(feature = "folder-open")]
+mod folder_open;
+#[cfg(feature = "folder-open-dot")]
+mod folder_open_dot;
+#[cfg(feature = "folder-output")]
+mod folder_output;
+#[cfg(feature = "folder-pen")]
+mod folder_pen;
+#[cfg(feature = "folder-plus")]
+mod folder_plus;
+#[cfg(feature = "folder-root")]
+mod folder_root;
+#[cfg(feature = "folder-search")]
+mod folder_search;
+#[cfg(feature = "folder-search-2")]
+mod folder_search_2;
+#[cfg(feature = "folder-symlink")]
+mod folder_symlink;
+#[cfg(feature = "folder-sync")]
+mod folder_sync;
+#[cfg(feature = "folder-tree")]
+mod folder_tree;
+#[cfg(feature = "folder-up")]
+mod folder_up;
+#[cfg(feature = "folder-x")]
+mod folder_x;
+#[cfg(feature = "folders")]
+mod folders;
+#[cfg(feature = "footprints")]
+mod footprints;
+#[cfg(feature = "forklift")]
+mod forklift;
+#[cfg(feature = "forward")]
+mod forward;
+#[cfg(feature = "frame")]
+mod frame;
+#[cfg(feature = "framer")]
+mod framer;
+#[cfg(feature = "frown")]
+mod frown;
+#[cfg(feature = "fuel")]
+mod fuel;
+#[cfg(feature = "fullscreen")]
+mod fullscreen;
+#[cfg(feature = "gallery-horizontal")]
+mod gallery_horizontal;
+#[cfg(feature = "gallery-horizontal-end")]
+mod gallery_horizontal_end;
+#[cfg(feature = "gallery-thumbnails")]
+mod gallery_thumbnails;
+#[cfg(feature = "gallery-vertical")]
+mod gallery_vertical;
+#[cfg(feature = "gallery-vertical-end")]
+mod gallery_vertical_end;
+#[cfg(feature = "gamepad")]
+mod gamepad;
+#[cfg(feature = "gamepad-2")]
+mod gamepad_2;
+#[cfg(feature = "gauge")]
+mod gauge;
+#[cfg(feature = "gavel")]
+mod gavel;
+#[cfg(feature = "gem")]
+mod gem;
+#[cfg(feature = "ghost")]
+mod ghost;
+#[cfg(feature = "gift")]
+mod gift;
+#[cfg(feature = "git-branch")]
+mod git_branch;
+#[cfg(feature = "git-branch-plus")]
+mod git_branch_plus;
+#[cfg(feature = "git-commit-horizontal")]
+mod git_commit_horizontal;
+#[cfg(feature = "git-commit-vertical")]
+mod git_commit_vertical;
+#[cfg(feature = "git-compare")]
+mod git_compare;
+#[cfg(feature = "git-compare-arrows")]
+mod git_compare_arrows;
+#[cfg(feature = "git-fork")]
+mod git_fork;
+#[cfg(feature = "git-graph")]
+mod git_graph;
+#[cfg(feature = "git-merge")]
+mod git_merge;
+#[cfg(feature = "git-pull-request")]
+mod git_pull_request;
+#[cfg(feature = "git-pull-request-arrow")]
+mod git_pull_request_arrow;
+#[cfg(feature = "git-pull-request-closed")]
+mod git_pull_request_closed;
+#[cfg(feature = "git-pull-request-create")]
+mod git_pull_request_create;
+#[cfg(feature = "git-pull-request-create-arrow")]
+mod git_pull_request_create_arrow;
+#[cfg(feature = "git-pull-request-draft")]
+mod git_pull_request_draft;
+#[cfg(feature = "github")]
+mod github;
+#[cfg(feature = "gitlab")]
+mod gitlab;
+#[cfg(feature = "glass-water")]
+mod glass_water;
+#[cfg(feature = "glasses")]
+mod glasses;
+#[cfg(feature = "globe")]
+mod globe;
+#[cfg(feature = "globe-lock")]
+mod globe_lock;
+#[cfg(feature = "goal")]
+mod goal;
+#[cfg(feature = "grab")]
+mod grab;
+#[cfg(feature = "graduation-cap")]
+mod graduation_cap;
+#[cfg(feature = "grape")]
+mod grape;
+#[cfg(feature = "grid-2-x-2")]
+mod grid_2_x_2;
+#[cfg(feature = "grid-2-x-2-check")]
+mod grid_2_x_2_check;
+#[cfg(feature = "grid-2-x-2-plus")]
+mod grid_2_x_2_plus;
+#[cfg(feature = "grid-2-x-2-x")]
+mod grid_2_x_2_x;
+#[cfg(feature = "grid-3-x-3")]
+mod grid_3_x_3;
+#[cfg(feature = "grip")]
+mod grip;
+#[cfg(feature = "grip-horizontal")]
+mod grip_horizontal;
+#[cfg(feature = "grip-vertical")]
+mod grip_vertical;
+#[cfg(feature = "group")]
+mod group;
+#[cfg(feature = "guitar")]
+mod guitar;
+#[cfg(feature = "ham")]
+mod ham;
+#[cfg(feature = "hammer")]
+mod hammer;
+#[cfg(feature = "hand")]
+mod hand;
+#[cfg(feature = "hand-coins")]
+mod hand_coins;
+#[cfg(feature = "hand-heart")]
+mod hand_heart;
+#[cfg(feature = "hand-helping")]
+mod hand_helping;
+#[cfg(feature = "hand-metal")]
+mod hand_metal;
+#[cfg(feature = "hand-platter")]
+mod hand_platter;
+#[cfg(feature = "handshake")]
+mod handshake;
+#[cfg(feature = "hard-drive")]
+mod hard_drive;
+#[cfg(feature = "hard-drive-download")]
+mod hard_drive_download;
+#[cfg(feature = "hard-drive-upload")]
+mod hard_drive_upload;
+#[cfg(feature = "hard-hat")]
+mod hard_hat;
+#[cfg(feature = "hash")]
+mod hash;
+#[cfg(feature = "haze")]
+mod haze;
+#[cfg(feature = "hdmi-port")]
+mod hdmi_port;
+#[cfg(feature = "heading")]
+mod heading;
+#[cfg(feature = "heading-1")]
+mod heading_1;
+#[cfg(feature = "heading-2")]
+mod heading_2;
+#[cfg(feature = "heading-3")]
+mod heading_3;
+#[cfg(feature = "heading-4")]
+mod heading_4;
+#[cfg(feature = "heading-5")]
+mod heading_5;
+#[cfg(feature = "heading-6")]
+mod heading_6;
+#[cfg(feature = "headphone-off")]
+mod headphone_off;
+#[cfg(feature = "headphones")]
+mod headphones;
+#[cfg(feature = "headset")]
+mod headset;
+#[cfg(feature = "heart")]
+mod heart;
+#[cfg(feature = "heart-crack")]
+mod heart_crack;
+#[cfg(feature = "heart-handshake")]
+mod heart_handshake;
+#[cfg(feature = "heart-off")]
+mod heart_off;
+#[cfg(feature = "heart-pulse")]
+mod heart_pulse;
+#[cfg(feature = "heater")]
+mod heater;
+#[cfg(feature = "hexagon")]
+mod hexagon;
+#[cfg(feature = "highlighter")]
+mod highlighter;
+#[cfg(feature = "history")]
+mod history;
+#[cfg(feature = "hop")]
+mod hop;
+#[cfg(feature = "hop-off")]
+mod hop_off;
+#[cfg(feature = "hospital")]
+mod hospital;
+#[cfg(feature = "hotel")]
+mod hotel;
+#[cfg(feature = "hourglass")]
+mod hourglass;
+#[cfg(feature = "house")]
+mod house;
+#[cfg(feature = "house-plug")]
+mod house_plug;
+#[cfg(feature = "house-plus")]
+mod house_plus;
+#[cfg(feature = "ice-cream-bowl")]
+mod ice_cream_bowl;
+#[cfg(feature = "ice-cream-cone")]
+mod ice_cream_cone;
+#[cfg(feature = "id-card")]
+mod id_card;
+#[cfg(feature = "image")]
+mod image;
+#[cfg(feature = "image-down")]
+mod image_down;
+#[cfg(feature = "image-minus")]
+mod image_minus;
+#[cfg(feature = "image-off")]
+mod image_off;
+#[cfg(feature = "image-play")]
+mod image_play;
+#[cfg(feature = "image-plus")]
+mod image_plus;
+#[cfg(feature = "image-up")]
+mod image_up;
+#[cfg(feature = "images")]
+mod images;
+#[cfg(feature = "import")]
+mod import;
+#[cfg(feature = "inbox")]
+mod inbox;
+#[cfg(feature = "indent-decrease")]
+mod indent_decrease;
+#[cfg(feature = "indent-increase")]
+mod indent_increase;
+#[cfg(feature = "indian-rupee")]
+mod indian_rupee;
+#[cfg(feature = "infinity")]
+mod infinity;
+#[cfg(feature = "info")]
+mod info;
+#[cfg(feature = "inspection-panel")]
+mod inspection_panel;
+#[cfg(feature = "instagram")]
+mod instagram;
+#[cfg(feature = "italic")]
+mod italic;
+#[cfg(feature = "iteration-ccw")]
+mod iteration_ccw;
+#[cfg(feature = "iteration-cw")]
+mod iteration_cw;
+#[cfg(feature = "japanese-yen")]
+mod japanese_yen;
+#[cfg(feature = "joystick")]
+mod joystick;
+#[cfg(feature = "kanban")]
+mod kanban;
+#[cfg(feature = "key")]
+mod key;
+#[cfg(feature = "key-round")]
+mod key_round;
+#[cfg(feature = "key-square")]
+mod key_square;
+#[cfg(feature = "keyboard")]
+mod keyboard;
+#[cfg(feature = "keyboard-music")]
+mod keyboard_music;
+#[cfg(feature = "keyboard-off")]
+mod keyboard_off;
+#[cfg(feature = "lamp")]
+mod lamp;
+#[cfg(feature = "lamp-ceiling")]
+mod lamp_ceiling;
+#[cfg(feature = "lamp-desk")]
+mod lamp_desk;
+#[cfg(feature = "lamp-floor")]
+mod lamp_floor;
+#[cfg(feature = "lamp-wall-down")]
+mod lamp_wall_down;
+#[cfg(feature = "lamp-wall-up")]
+mod lamp_wall_up;
+#[cfg(feature = "land-plot")]
+mod land_plot;
+#[cfg(feature = "landmark")]
+mod landmark;
+#[cfg(feature = "languages")]
+mod languages;
+#[cfg(feature = "laptop")]
+mod laptop;
+#[cfg(feature = "laptop-minimal")]
+mod laptop_minimal;
+#[cfg(feature = "laptop-minimal-check")]
+mod laptop_minimal_check;
+#[cfg(feature = "lasso")]
+mod lasso;
+#[cfg(feature = "lasso-select")]
+mod lasso_select;
+#[cfg(feature = "laugh")]
+mod laugh;
+#[cfg(feature = "layers")]
+mod layers;
+#[cfg(feature = "layers-2")]
+mod layers_2;
+#[cfg(feature = "layers-3")]
+mod layers_3;
+#[cfg(feature = "layout-dashboard")]
+mod layout_dashboard;
+#[cfg(feature = "layout-grid")]
+mod layout_grid;
+#[cfg(feature = "layout-list")]
+mod layout_list;
+#[cfg(feature = "layout-panel-left")]
+mod layout_panel_left;
+#[cfg(feature = "layout-panel-top")]
+mod layout_panel_top;
+#[cfg(feature = "layout-template")]
+mod layout_template;
+#[cfg(feature = "leaf")]
+mod leaf;
+#[cfg(feature = "leafy-green")]
+mod leafy_green;
+#[cfg(feature = "lectern")]
+mod lectern;
+#[cfg(feature = "letter-text")]
+mod letter_text;
+#[cfg(feature = "library")]
+mod library;
+#[cfg(feature = "library-big")]
+mod library_big;
+#[cfg(feature = "life-buoy")]
+mod life_buoy;
+#[cfg(feature = "ligature")]
+mod ligature;
+#[cfg(feature = "lightbulb")]
+mod lightbulb;
+#[cfg(feature = "lightbulb-off")]
+mod lightbulb_off;
+#[cfg(feature = "link")]
+mod link;
+#[cfg(feature = "link-2")]
+mod link_2;
+#[cfg(feature = "link-2-off")]
+mod link_2_off;
+#[cfg(feature = "linkedin")]
+mod linkedin;
+#[cfg(feature = "list")]
+mod list;
+#[cfg(feature = "list-check")]
+mod list_check;
+#[cfg(feature = "list-checks")]
+mod list_checks;
+#[cfg(feature = "list-collapse")]
+mod list_collapse;
+#[cfg(feature = "list-end")]
+mod list_end;
+#[cfg(feature = "list-filter")]
+mod list_filter;
+#[cfg(feature = "list-minus")]
+mod list_minus;
+#[cfg(feature = "list-music")]
+mod list_music;
+#[cfg(feature = "list-ordered")]
+mod list_ordered;
+#[cfg(feature = "list-plus")]
+mod list_plus;
+#[cfg(feature = "list-restart")]
+mod list_restart;
+#[cfg(feature = "list-start")]
+mod list_start;
+#[cfg(feature = "list-todo")]
+mod list_todo;
+#[cfg(feature = "list-tree")]
+mod list_tree;
+#[cfg(feature = "list-video")]
+mod list_video;
+#[cfg(feature = "list-x")]
+mod list_x;
+#[cfg(feature = "loader")]
+mod loader;
+#[cfg(feature = "loader-circle")]
+mod loader_circle;
+#[cfg(feature = "loader-pinwheel")]
+mod loader_pinwheel;
+#[cfg(feature = "locate")]
+mod locate;
+#[cfg(feature = "locate-fixed")]
+mod locate_fixed;
+#[cfg(feature = "locate-off")]
+mod locate_off;
+#[cfg(feature = "lock")]
+mod lock;
+#[cfg(feature = "lock-keyhole")]
+mod lock_keyhole;
+#[cfg(feature = "lock-keyhole-open")]
+mod lock_keyhole_open;
+#[cfg(feature = "lock-open")]
+mod lock_open;
+#[cfg(feature = "log-in")]
+mod log_in;
+#[cfg(feature = "log-out")]
+mod log_out;
+#[cfg(feature = "logs")]
+mod logs;
+#[cfg(feature = "lollipop")]
+mod lollipop;
+#[cfg(feature = "luggage")]
+mod luggage;
+#[cfg(feature = "magnet")]
+mod magnet;
+#[cfg(feature = "mail")]
+mod mail;
+#[cfg(feature = "mail-check")]
+mod mail_check;
+#[cfg(feature = "mail-minus")]
+mod mail_minus;
+#[cfg(feature = "mail-open")]
+mod mail_open;
+#[cfg(feature = "mail-plus")]
+mod mail_plus;
+#[cfg(feature = "mail-question")]
+mod mail_question;
+#[cfg(feature = "mail-search")]
+mod mail_search;
+#[cfg(feature = "mail-warning")]
+mod mail_warning;
+#[cfg(feature = "mail-x")]
+mod mail_x;
+#[cfg(feature = "mailbox")]
+mod mailbox;
+#[cfg(feature = "mails")]
+mod mails;
+#[cfg(feature = "map")]
+mod map;
+#[cfg(feature = "map-pin")]
+mod map_pin;
+#[cfg(feature = "map-pin-check")]
+mod map_pin_check;
+#[cfg(feature = "map-pin-check-inside")]
+mod map_pin_check_inside;
+#[cfg(feature = "map-pin-house")]
+mod map_pin_house;
+#[cfg(feature = "map-pin-minus")]
+mod map_pin_minus;
+#[cfg(feature = "map-pin-minus-inside")]
+mod map_pin_minus_inside;
+#[cfg(feature = "map-pin-off")]
+mod map_pin_off;
+#[cfg(feature = "map-pin-plus")]
+mod map_pin_plus;
+#[cfg(feature = "map-pin-plus-inside")]
+mod map_pin_plus_inside;
+#[cfg(feature = "map-pin-x")]
+mod map_pin_x;
+#[cfg(feature = "map-pin-x-inside")]
+mod map_pin_x_inside;
+#[cfg(feature = "map-pinned")]
+mod map_pinned;
+#[cfg(feature = "martini")]
+mod martini;
+#[cfg(feature = "maximize")]
+mod maximize;
+#[cfg(feature = "maximize-2")]
+mod maximize_2;
+#[cfg(feature = "medal")]
+mod medal;
+#[cfg(feature = "megaphone")]
+mod megaphone;
+#[cfg(feature = "megaphone-off")]
+mod megaphone_off;
+#[cfg(feature = "meh")]
+mod meh;
+#[cfg(feature = "memory-stick")]
+mod memory_stick;
+#[cfg(feature = "menu")]
+mod menu;
+#[cfg(feature = "merge")]
+mod merge;
+#[cfg(feature = "message-circle")]
+mod message_circle;
+#[cfg(feature = "message-circle-code")]
+mod message_circle_code;
+#[cfg(feature = "message-circle-dashed")]
+mod message_circle_dashed;
+#[cfg(feature = "message-circle-heart")]
+mod message_circle_heart;
+#[cfg(feature = "message-circle-more")]
+mod message_circle_more;
+#[cfg(feature = "message-circle-off")]
+mod message_circle_off;
+#[cfg(feature = "message-circle-plus")]
+mod message_circle_plus;
+#[cfg(feature = "message-circle-question")]
+mod message_circle_question;
+#[cfg(feature = "message-circle-reply")]
+mod message_circle_reply;
+#[cfg(feature = "message-circle-warning")]
+mod message_circle_warning;
+#[cfg(feature = "message-circle-x")]
+mod message_circle_x;
+#[cfg(feature = "message-square")]
+mod message_square;
+#[cfg(feature = "message-square-code")]
+mod message_square_code;
+#[cfg(feature = "message-square-dashed")]
+mod message_square_dashed;
+#[cfg(feature = "message-square-diff")]
+mod message_square_diff;
+#[cfg(feature = "message-square-dot")]
+mod message_square_dot;
+#[cfg(feature = "message-square-heart")]
+mod message_square_heart;
+#[cfg(feature = "message-square-lock")]
+mod message_square_lock;
+#[cfg(feature = "message-square-more")]
+mod message_square_more;
+#[cfg(feature = "message-square-off")]
+mod message_square_off;
+#[cfg(feature = "message-square-plus")]
+mod message_square_plus;
+#[cfg(feature = "message-square-quote")]
+mod message_square_quote;
+#[cfg(feature = "message-square-reply")]
+mod message_square_reply;
+#[cfg(feature = "message-square-share")]
+mod message_square_share;
+#[cfg(feature = "message-square-text")]
+mod message_square_text;
+#[cfg(feature = "message-square-warning")]
+mod message_square_warning;
+#[cfg(feature = "message-square-x")]
+mod message_square_x;
+#[cfg(feature = "messages-square")]
+mod messages_square;
+#[cfg(feature = "mic")]
+mod mic;
+#[cfg(feature = "mic-off")]
+mod mic_off;
+#[cfg(feature = "mic-vocal")]
+mod mic_vocal;
+#[cfg(feature = "microchip")]
+mod microchip;
+#[cfg(feature = "microscope")]
+mod microscope;
+#[cfg(feature = "microwave")]
+mod microwave;
+#[cfg(feature = "milestone")]
+mod milestone;
+#[cfg(feature = "milk")]
+mod milk;
+#[cfg(feature = "milk-off")]
+mod milk_off;
+#[cfg(feature = "minimize")]
+mod minimize;
+#[cfg(feature = "minimize-2")]
+mod minimize_2;
+#[cfg(feature = "minus")]
+mod minus;
+#[cfg(feature = "monitor")]
+mod monitor;
+#[cfg(feature = "monitor-check")]
+mod monitor_check;
+#[cfg(feature = "monitor-cog")]
+mod monitor_cog;
+#[cfg(feature = "monitor-dot")]
+mod monitor_dot;
+#[cfg(feature = "monitor-down")]
+mod monitor_down;
+#[cfg(feature = "monitor-off")]
+mod monitor_off;
+#[cfg(feature = "monitor-pause")]
+mod monitor_pause;
+#[cfg(feature = "monitor-play")]
+mod monitor_play;
+#[cfg(feature = "monitor-smartphone")]
+mod monitor_smartphone;
+#[cfg(feature = "monitor-speaker")]
+mod monitor_speaker;
+#[cfg(feature = "monitor-stop")]
+mod monitor_stop;
+#[cfg(feature = "monitor-up")]
+mod monitor_up;
+#[cfg(feature = "monitor-x")]
+mod monitor_x;
+#[cfg(feature = "moon")]
+mod moon;
+#[cfg(feature = "moon-star")]
+mod moon_star;
+#[cfg(feature = "mountain")]
+mod mountain;
+#[cfg(feature = "mountain-snow")]
+mod mountain_snow;
+#[cfg(feature = "mouse")]
+mod mouse;
+#[cfg(feature = "mouse-off")]
+mod mouse_off;
+#[cfg(feature = "mouse-pointer")]
+mod mouse_pointer;
+#[cfg(feature = "mouse-pointer-2")]
+mod mouse_pointer_2;
+#[cfg(feature = "mouse-pointer-ban")]
+mod mouse_pointer_ban;
+#[cfg(feature = "mouse-pointer-click")]
+mod mouse_pointer_click;
+#[cfg(feature = "move")]
+mod r#move;
+#[cfg(feature = "move-3-d")]
+mod move_3_d;
+#[cfg(feature = "move-diagonal")]
+mod move_diagonal;
+#[cfg(feature = "move-diagonal-2")]
+mod move_diagonal_2;
+#[cfg(feature = "move-down")]
+mod move_down;
+#[cfg(feature = "move-down-left")]
+mod move_down_left;
+#[cfg(feature = "move-down-right")]
+mod move_down_right;
+#[cfg(feature = "move-horizontal")]
+mod move_horizontal;
+#[cfg(feature = "move-left")]
+mod move_left;
+#[cfg(feature = "move-right")]
+mod move_right;
+#[cfg(feature = "move-up")]
+mod move_up;
+#[cfg(feature = "move-up-left")]
+mod move_up_left;
+#[cfg(feature = "move-up-right")]
+mod move_up_right;
+#[cfg(feature = "move-vertical")]
+mod move_vertical;
+#[cfg(feature = "music")]
+mod music;
+#[cfg(feature = "music-2")]
+mod music_2;
+#[cfg(feature = "music-3")]
+mod music_3;
+#[cfg(feature = "music-4")]
+mod music_4;
+#[cfg(feature = "navigation")]
+mod navigation;
+#[cfg(feature = "navigation-2")]
+mod navigation_2;
+#[cfg(feature = "navigation-2-off")]
+mod navigation_2_off;
+#[cfg(feature = "navigation-off")]
+mod navigation_off;
+#[cfg(feature = "network")]
+mod network;
+#[cfg(feature = "newspaper")]
+mod newspaper;
+#[cfg(feature = "nfc")]
+mod nfc;
+#[cfg(feature = "notebook")]
+mod notebook;
+#[cfg(feature = "notebook-pen")]
+mod notebook_pen;
+#[cfg(feature = "notebook-tabs")]
+mod notebook_tabs;
+#[cfg(feature = "notebook-text")]
+mod notebook_text;
+#[cfg(feature = "notepad-text")]
+mod notepad_text;
+#[cfg(feature = "notepad-text-dashed")]
+mod notepad_text_dashed;
+#[cfg(feature = "nut")]
+mod nut;
+#[cfg(feature = "nut-off")]
+mod nut_off;
+#[cfg(feature = "octagon")]
+mod octagon;
+#[cfg(feature = "octagon-alert")]
+mod octagon_alert;
+#[cfg(feature = "octagon-minus")]
+mod octagon_minus;
+#[cfg(feature = "octagon-pause")]
+mod octagon_pause;
+#[cfg(feature = "octagon-x")]
+mod octagon_x;
+#[cfg(feature = "omega")]
+mod omega;
+#[cfg(feature = "option")]
+mod option;
+#[cfg(feature = "orbit")]
+mod orbit;
+#[cfg(feature = "origami")]
+mod origami;
+#[cfg(feature = "package")]
+mod package;
+#[cfg(feature = "package-2")]
+mod package_2;
+#[cfg(feature = "package-check")]
+mod package_check;
+#[cfg(feature = "package-minus")]
+mod package_minus;
+#[cfg(feature = "package-open")]
+mod package_open;
+#[cfg(feature = "package-plus")]
+mod package_plus;
+#[cfg(feature = "package-search")]
+mod package_search;
+#[cfg(feature = "package-x")]
+mod package_x;
+#[cfg(feature = "paint-bucket")]
+mod paint_bucket;
+#[cfg(feature = "paint-roller")]
+mod paint_roller;
+#[cfg(feature = "paintbrush")]
+mod paintbrush;
+#[cfg(feature = "paintbrush-vertical")]
+mod paintbrush_vertical;
+#[cfg(feature = "palette")]
+mod palette;
+#[cfg(feature = "panel-bottom")]
+mod panel_bottom;
+#[cfg(feature = "panel-bottom-close")]
+mod panel_bottom_close;
+#[cfg(feature = "panel-bottom-dashed")]
+mod panel_bottom_dashed;
+#[cfg(feature = "panel-bottom-open")]
+mod panel_bottom_open;
+#[cfg(feature = "panel-left")]
+mod panel_left;
+#[cfg(feature = "panel-left-close")]
+mod panel_left_close;
+#[cfg(feature = "panel-left-dashed")]
+mod panel_left_dashed;
+#[cfg(feature = "panel-left-open")]
+mod panel_left_open;
+#[cfg(feature = "panel-right")]
+mod panel_right;
+#[cfg(feature = "panel-right-close")]
+mod panel_right_close;
+#[cfg(feature = "panel-right-dashed")]
+mod panel_right_dashed;
+#[cfg(feature = "panel-right-open")]
+mod panel_right_open;
+#[cfg(feature = "panel-top")]
+mod panel_top;
+#[cfg(feature = "panel-top-close")]
+mod panel_top_close;
+#[cfg(feature = "panel-top-dashed")]
+mod panel_top_dashed;
+#[cfg(feature = "panel-top-open")]
+mod panel_top_open;
+#[cfg(feature = "panels-left-bottom")]
+mod panels_left_bottom;
+#[cfg(feature = "panels-right-bottom")]
+mod panels_right_bottom;
+#[cfg(feature = "panels-top-left")]
+mod panels_top_left;
+#[cfg(feature = "paperclip")]
+mod paperclip;
+#[cfg(feature = "parentheses")]
+mod parentheses;
+#[cfg(feature = "parking-meter")]
+mod parking_meter;
+#[cfg(feature = "party-popper")]
+mod party_popper;
+#[cfg(feature = "pause")]
+mod pause;
+#[cfg(feature = "paw-print")]
+mod paw_print;
+#[cfg(feature = "pc-case")]
+mod pc_case;
+#[cfg(feature = "pen")]
+mod pen;
+#[cfg(feature = "pen-line")]
+mod pen_line;
+#[cfg(feature = "pen-off")]
+mod pen_off;
+#[cfg(feature = "pen-tool")]
+mod pen_tool;
+#[cfg(feature = "pencil")]
+mod pencil;
+#[cfg(feature = "pencil-line")]
+mod pencil_line;
+#[cfg(feature = "pencil-off")]
+mod pencil_off;
+#[cfg(feature = "pencil-ruler")]
+mod pencil_ruler;
+#[cfg(feature = "pentagon")]
+mod pentagon;
+#[cfg(feature = "percent")]
+mod percent;
+#[cfg(feature = "person-standing")]
+mod person_standing;
+#[cfg(feature = "philippine-peso")]
+mod philippine_peso;
+#[cfg(feature = "phone")]
+mod phone;
+#[cfg(feature = "phone-call")]
+mod phone_call;
+#[cfg(feature = "phone-forwarded")]
+mod phone_forwarded;
+#[cfg(feature = "phone-incoming")]
+mod phone_incoming;
+#[cfg(feature = "phone-missed")]
+mod phone_missed;
+#[cfg(feature = "phone-off")]
+mod phone_off;
+#[cfg(feature = "phone-outgoing")]
+mod phone_outgoing;
+#[cfg(feature = "pi")]
+mod pi;
+#[cfg(feature = "piano")]
+mod piano;
+#[cfg(feature = "pickaxe")]
+mod pickaxe;
+#[cfg(feature = "picture-in-picture")]
+mod picture_in_picture;
+#[cfg(feature = "picture-in-picture-2")]
+mod picture_in_picture_2;
+#[cfg(feature = "piggy-bank")]
+mod piggy_bank;
+#[cfg(feature = "pilcrow")]
+mod pilcrow;
+#[cfg(feature = "pilcrow-left")]
+mod pilcrow_left;
+#[cfg(feature = "pilcrow-right")]
+mod pilcrow_right;
+#[cfg(feature = "pill")]
+mod pill;
+#[cfg(feature = "pill-bottle")]
+mod pill_bottle;
+#[cfg(feature = "pin")]
+mod pin;
+#[cfg(feature = "pin-off")]
+mod pin_off;
+#[cfg(feature = "pipette")]
+mod pipette;
+#[cfg(feature = "pizza")]
+mod pizza;
+#[cfg(feature = "plane")]
+mod plane;
+#[cfg(feature = "plane-landing")]
+mod plane_landing;
+#[cfg(feature = "plane-takeoff")]
+mod plane_takeoff;
+#[cfg(feature = "play")]
+mod play;
+#[cfg(feature = "plug")]
+mod plug;
+#[cfg(feature = "plug-2")]
+mod plug_2;
+#[cfg(feature = "plug-zap")]
+mod plug_zap;
+#[cfg(feature = "plus")]
+mod plus;
+#[cfg(feature = "pocket")]
+mod pocket;
+#[cfg(feature = "pocket-knife")]
+mod pocket_knife;
+#[cfg(feature = "podcast")]
+mod podcast;
+#[cfg(feature = "pointer")]
+mod pointer;
+#[cfg(feature = "pointer-off")]
+mod pointer_off;
+#[cfg(feature = "popcorn")]
+mod popcorn;
+#[cfg(feature = "popsicle")]
+mod popsicle;
+#[cfg(feature = "pound-sterling")]
+mod pound_sterling;
+#[cfg(feature = "power")]
+mod power;
+#[cfg(feature = "power-off")]
+mod power_off;
+#[cfg(feature = "presentation")]
+mod presentation;
+#[cfg(feature = "printer")]
+mod printer;
+#[cfg(feature = "printer-check")]
+mod printer_check;
+#[cfg(feature = "projector")]
+mod projector;
+#[cfg(feature = "proportions")]
+mod proportions;
+#[cfg(feature = "puzzle")]
+mod puzzle;
+#[cfg(feature = "pyramid")]
+mod pyramid;
+#[cfg(feature = "qr-code")]
+mod qr_code;
+#[cfg(feature = "quote")]
+mod quote;
+#[cfg(feature = "rabbit")]
+mod rabbit;
+#[cfg(feature = "radar")]
+mod radar;
+#[cfg(feature = "radiation")]
+mod radiation;
+#[cfg(feature = "radical")]
+mod radical;
+#[cfg(feature = "radio")]
+mod radio;
+#[cfg(feature = "radio-receiver")]
+mod radio_receiver;
+#[cfg(feature = "radio-tower")]
+mod radio_tower;
+#[cfg(feature = "radius")]
+mod radius;
+#[cfg(feature = "rail-symbol")]
+mod rail_symbol;
+#[cfg(feature = "rainbow")]
+mod rainbow;
+#[cfg(feature = "rat")]
+mod rat;
+#[cfg(feature = "ratio")]
+mod ratio;
+#[cfg(feature = "receipt")]
+mod receipt;
+#[cfg(feature = "receipt-cent")]
+mod receipt_cent;
+#[cfg(feature = "receipt-euro")]
+mod receipt_euro;
+#[cfg(feature = "receipt-indian-rupee")]
+mod receipt_indian_rupee;
+#[cfg(feature = "receipt-japanese-yen")]
+mod receipt_japanese_yen;
+#[cfg(feature = "receipt-pound-sterling")]
+mod receipt_pound_sterling;
+#[cfg(feature = "receipt-russian-ruble")]
+mod receipt_russian_ruble;
+#[cfg(feature = "receipt-swiss-franc")]
+mod receipt_swiss_franc;
+#[cfg(feature = "receipt-text")]
+mod receipt_text;
+#[cfg(feature = "rectangle-ellipsis")]
+mod rectangle_ellipsis;
+#[cfg(feature = "rectangle-horizontal")]
+mod rectangle_horizontal;
+#[cfg(feature = "rectangle-vertical")]
+mod rectangle_vertical;
+#[cfg(feature = "recycle")]
+mod recycle;
+#[cfg(feature = "redo")]
+mod redo;
+#[cfg(feature = "redo-2")]
+mod redo_2;
+#[cfg(feature = "redo-dot")]
+mod redo_dot;
+#[cfg(feature = "refresh-ccw")]
+mod refresh_ccw;
+#[cfg(feature = "refresh-ccw-dot")]
+mod refresh_ccw_dot;
+#[cfg(feature = "refresh-cw")]
+mod refresh_cw;
+#[cfg(feature = "refresh-cw-off")]
+mod refresh_cw_off;
+#[cfg(feature = "refrigerator")]
+mod refrigerator;
+#[cfg(feature = "regex")]
+mod regex;
+#[cfg(feature = "remove-formatting")]
+mod remove_formatting;
+#[cfg(feature = "repeat")]
+mod repeat;
+#[cfg(feature = "repeat-1")]
+mod repeat_1;
+#[cfg(feature = "repeat-2")]
+mod repeat_2;
+#[cfg(feature = "replace")]
+mod replace;
+#[cfg(feature = "replace-all")]
+mod replace_all;
+#[cfg(feature = "reply")]
+mod reply;
+#[cfg(feature = "reply-all")]
+mod reply_all;
+#[cfg(feature = "rewind")]
+mod rewind;
+#[cfg(feature = "ribbon")]
+mod ribbon;
+#[cfg(feature = "rocket")]
+mod rocket;
+#[cfg(feature = "rocking-chair")]
+mod rocking_chair;
+#[cfg(feature = "roller-coaster")]
+mod roller_coaster;
+#[cfg(feature = "rotate-3-d")]
+mod rotate_3_d;
+#[cfg(feature = "rotate-ccw")]
+mod rotate_ccw;
+#[cfg(feature = "rotate-ccw-square")]
+mod rotate_ccw_square;
+#[cfg(feature = "rotate-cw")]
+mod rotate_cw;
+#[cfg(feature = "rotate-cw-square")]
+mod rotate_cw_square;
+#[cfg(feature = "route")]
+mod route;
+#[cfg(feature = "route-off")]
+mod route_off;
+#[cfg(feature = "router")]
+mod router;
+#[cfg(feature = "rows-2")]
+mod rows_2;
+#[cfg(feature = "rows-3")]
+mod rows_3;
+#[cfg(feature = "rows-4")]
+mod rows_4;
+#[cfg(feature = "rss")]
+mod rss;
+#[cfg(feature = "ruler")]
+mod ruler;
+#[cfg(feature = "russian-ruble")]
+mod russian_ruble;
+#[cfg(feature = "sailboat")]
+mod sailboat;
+#[cfg(feature = "salad")]
+mod salad;
+#[cfg(feature = "sandwich")]
+mod sandwich;
+#[cfg(feature = "satellite")]
+mod satellite;
+#[cfg(feature = "satellite-dish")]
+mod satellite_dish;
+#[cfg(feature = "save")]
+mod save;
+#[cfg(feature = "save-all")]
+mod save_all;
+#[cfg(feature = "save-off")]
+mod save_off;
+#[cfg(feature = "scale")]
+mod scale;
+#[cfg(feature = "scale-3-d")]
+mod scale_3_d;
+#[cfg(feature = "scaling")]
+mod scaling;
+#[cfg(feature = "scan")]
+mod scan;
+#[cfg(feature = "scan-barcode")]
+mod scan_barcode;
+#[cfg(feature = "scan-eye")]
+mod scan_eye;
+#[cfg(feature = "scan-face")]
+mod scan_face;
+#[cfg(feature = "scan-line")]
+mod scan_line;
+#[cfg(feature = "scan-qr-code")]
+mod scan_qr_code;
+#[cfg(feature = "scan-search")]
+mod scan_search;
+#[cfg(feature = "scan-text")]
+mod scan_text;
+#[cfg(feature = "school")]
+mod school;
+#[cfg(feature = "scissors")]
+mod scissors;
+#[cfg(feature = "scissors-line-dashed")]
+mod scissors_line_dashed;
+#[cfg(feature = "screen-share")]
+mod screen_share;
+#[cfg(feature = "screen-share-off")]
+mod screen_share_off;
+#[cfg(feature = "scroll")]
+mod scroll;
+#[cfg(feature = "scroll-text")]
+mod scroll_text;
+#[cfg(feature = "search")]
+mod search;
+#[cfg(feature = "search-check")]
+mod search_check;
+#[cfg(feature = "search-code")]
+mod search_code;
+#[cfg(feature = "search-slash")]
+mod search_slash;
+#[cfg(feature = "search-x")]
+mod search_x;
+#[cfg(feature = "section")]
+mod section;
+#[cfg(feature = "send")]
+mod send;
+#[cfg(feature = "send-horizontal")]
+mod send_horizontal;
+#[cfg(feature = "send-to-back")]
+mod send_to_back;
+#[cfg(feature = "separator-horizontal")]
+mod separator_horizontal;
+#[cfg(feature = "separator-vertical")]
+mod separator_vertical;
+#[cfg(feature = "server")]
+mod server;
+#[cfg(feature = "server-cog")]
+mod server_cog;
+#[cfg(feature = "server-crash")]
+mod server_crash;
+#[cfg(feature = "server-off")]
+mod server_off;
+#[cfg(feature = "settings")]
+mod settings;
+#[cfg(feature = "settings-2")]
+mod settings_2;
+#[cfg(feature = "shapes")]
+mod shapes;
+#[cfg(feature = "share")]
+mod share;
+#[cfg(feature = "share-2")]
+mod share_2;
+#[cfg(feature = "sheet")]
+mod sheet;
+#[cfg(feature = "shell")]
+mod shell;
+#[cfg(feature = "shield")]
+mod shield;
+#[cfg(feature = "shield-alert")]
+mod shield_alert;
+#[cfg(feature = "shield-ban")]
+mod shield_ban;
+#[cfg(feature = "shield-check")]
+mod shield_check;
+#[cfg(feature = "shield-ellipsis")]
+mod shield_ellipsis;
+#[cfg(feature = "shield-half")]
+mod shield_half;
+#[cfg(feature = "shield-minus")]
+mod shield_minus;
+#[cfg(feature = "shield-off")]
+mod shield_off;
+#[cfg(feature = "shield-plus")]
+mod shield_plus;
+#[cfg(feature = "shield-question")]
+mod shield_question;
+#[cfg(feature = "shield-x")]
+mod shield_x;
+#[cfg(feature = "ship")]
+mod ship;
+#[cfg(feature = "ship-wheel")]
+mod ship_wheel;
+#[cfg(feature = "shirt")]
+mod shirt;
+#[cfg(feature = "shopping-bag")]
+mod shopping_bag;
+#[cfg(feature = "shopping-basket")]
+mod shopping_basket;
+#[cfg(feature = "shopping-cart")]
+mod shopping_cart;
+#[cfg(feature = "shovel")]
+mod shovel;
+#[cfg(feature = "shower-head")]
+mod shower_head;
+#[cfg(feature = "shrink")]
+mod shrink;
+#[cfg(feature = "shrub")]
+mod shrub;
+#[cfg(feature = "shuffle")]
+mod shuffle;
+#[cfg(feature = "sigma")]
+mod sigma;
+#[cfg(feature = "signal")]
+mod signal;
+#[cfg(feature = "signal-high")]
+mod signal_high;
+#[cfg(feature = "signal-low")]
+mod signal_low;
+#[cfg(feature = "signal-medium")]
+mod signal_medium;
+#[cfg(feature = "signal-zero")]
+mod signal_zero;
+#[cfg(feature = "signature")]
+mod signature;
+#[cfg(feature = "signpost")]
+mod signpost;
+#[cfg(feature = "signpost-big")]
+mod signpost_big;
+#[cfg(feature = "siren")]
+mod siren;
+#[cfg(feature = "skip-back")]
+mod skip_back;
+#[cfg(feature = "skip-forward")]
+mod skip_forward;
+#[cfg(feature = "skull")]
+mod skull;
+#[cfg(feature = "slack")]
+mod slack;
+#[cfg(feature = "slash")]
+mod slash;
+#[cfg(feature = "slice")]
+mod slice;
+#[cfg(feature = "sliders-horizontal")]
+mod sliders_horizontal;
+#[cfg(feature = "sliders-vertical")]
+mod sliders_vertical;
+#[cfg(feature = "smartphone")]
+mod smartphone;
+#[cfg(feature = "smartphone-charging")]
+mod smartphone_charging;
+#[cfg(feature = "smartphone-nfc")]
+mod smartphone_nfc;
+#[cfg(feature = "smile")]
+mod smile;
+#[cfg(feature = "smile-plus")]
+mod smile_plus;
+#[cfg(feature = "snail")]
+mod snail;
+#[cfg(feature = "snowflake")]
+mod snowflake;
+#[cfg(feature = "sofa")]
+mod sofa;
+#[cfg(feature = "soup")]
+mod soup;
+#[cfg(feature = "space")]
+mod space;
+#[cfg(feature = "spade")]
+mod spade;
+#[cfg(feature = "sparkle")]
+mod sparkle;
+#[cfg(feature = "sparkles")]
+mod sparkles;
+#[cfg(feature = "speaker")]
+mod speaker;
+#[cfg(feature = "speech")]
+mod speech;
+#[cfg(feature = "spell-check")]
+mod spell_check;
+#[cfg(feature = "spell-check-2")]
+mod spell_check_2;
+#[cfg(feature = "spline")]
+mod spline;
+#[cfg(feature = "split")]
+mod split;
+#[cfg(feature = "spray-can")]
+mod spray_can;
+#[cfg(feature = "sprout")]
+mod sprout;
+#[cfg(feature = "square")]
+mod square;
+#[cfg(feature = "square-activity")]
+mod square_activity;
+#[cfg(feature = "square-arrow-down")]
+mod square_arrow_down;
+#[cfg(feature = "square-arrow-down-left")]
+mod square_arrow_down_left;
+#[cfg(feature = "square-arrow-down-right")]
+mod square_arrow_down_right;
+#[cfg(feature = "square-arrow-left")]
+mod square_arrow_left;
+#[cfg(feature = "square-arrow-out-down-left")]
+mod square_arrow_out_down_left;
+#[cfg(feature = "square-arrow-out-down-right")]
+mod square_arrow_out_down_right;
+#[cfg(feature = "square-arrow-out-up-left")]
+mod square_arrow_out_up_left;
+#[cfg(feature = "square-arrow-out-up-right")]
+mod square_arrow_out_up_right;
+#[cfg(feature = "square-arrow-right")]
+mod square_arrow_right;
+#[cfg(feature = "square-arrow-up")]
+mod square_arrow_up;
+#[cfg(feature = "square-arrow-up-left")]
+mod square_arrow_up_left;
+#[cfg(feature = "square-arrow-up-right")]
+mod square_arrow_up_right;
+#[cfg(feature = "square-asterisk")]
+mod square_asterisk;
+#[cfg(feature = "square-bottom-dashed-scissors")]
+mod square_bottom_dashed_scissors;
+#[cfg(feature = "square-chart-gantt")]
+mod square_chart_gantt;
+#[cfg(feature = "square-check")]
+mod square_check;
+#[cfg(feature = "square-check-big")]
+mod square_check_big;
+#[cfg(feature = "square-chevron-down")]
+mod square_chevron_down;
+#[cfg(feature = "square-chevron-left")]
+mod square_chevron_left;
+#[cfg(feature = "square-chevron-right")]
+mod square_chevron_right;
+#[cfg(feature = "square-chevron-up")]
+mod square_chevron_up;
+#[cfg(feature = "square-code")]
+mod square_code;
+#[cfg(feature = "square-dashed")]
+mod square_dashed;
+#[cfg(feature = "square-dashed-bottom")]
+mod square_dashed_bottom;
+#[cfg(feature = "square-dashed-bottom-code")]
+mod square_dashed_bottom_code;
+#[cfg(feature = "square-dashed-kanban")]
+mod square_dashed_kanban;
+#[cfg(feature = "square-dashed-mouse-pointer")]
+mod square_dashed_mouse_pointer;
+#[cfg(feature = "square-divide")]
+mod square_divide;
+#[cfg(feature = "square-dot")]
+mod square_dot;
+#[cfg(feature = "square-equal")]
+mod square_equal;
+#[cfg(feature = "square-function")]
+mod square_function;
+#[cfg(feature = "square-kanban")]
+mod square_kanban;
+#[cfg(feature = "square-library")]
+mod square_library;
+#[cfg(feature = "square-m")]
+mod square_m;
+#[cfg(feature = "square-menu")]
+mod square_menu;
+#[cfg(feature = "square-minus")]
+mod square_minus;
+#[cfg(feature = "square-mouse-pointer")]
+mod square_mouse_pointer;
+#[cfg(feature = "square-parking")]
+mod square_parking;
+#[cfg(feature = "square-parking-off")]
+mod square_parking_off;
+#[cfg(feature = "square-pen")]
+mod square_pen;
+#[cfg(feature = "square-percent")]
+mod square_percent;
+#[cfg(feature = "square-pi")]
+mod square_pi;
+#[cfg(feature = "square-pilcrow")]
+mod square_pilcrow;
+#[cfg(feature = "square-play")]
+mod square_play;
+#[cfg(feature = "square-plus")]
+mod square_plus;
+#[cfg(feature = "square-power")]
+mod square_power;
+#[cfg(feature = "square-radical")]
+mod square_radical;
+#[cfg(feature = "square-scissors")]
+mod square_scissors;
+#[cfg(feature = "square-sigma")]
+mod square_sigma;
+#[cfg(feature = "square-slash")]
+mod square_slash;
+#[cfg(feature = "square-split-horizontal")]
+mod square_split_horizontal;
+#[cfg(feature = "square-split-vertical")]
+mod square_split_vertical;
+#[cfg(feature = "square-square")]
+mod square_square;
+#[cfg(feature = "square-stack")]
+mod square_stack;
+#[cfg(feature = "square-terminal")]
+mod square_terminal;
+#[cfg(feature = "square-user")]
+mod square_user;
+#[cfg(feature = "square-user-round")]
+mod square_user_round;
+#[cfg(feature = "square-x")]
+mod square_x;
+#[cfg(feature = "squircle")]
+mod squircle;
+#[cfg(feature = "squirrel")]
+mod squirrel;
+#[cfg(feature = "stamp")]
+mod stamp;
+#[cfg(feature = "star")]
+mod star;
+#[cfg(feature = "star-half")]
+mod star_half;
+#[cfg(feature = "star-off")]
+mod star_off;
+#[cfg(feature = "step-back")]
+mod step_back;
+#[cfg(feature = "step-forward")]
+mod step_forward;
+#[cfg(feature = "stethoscope")]
+mod stethoscope;
+#[cfg(feature = "sticker")]
+mod sticker;
+#[cfg(feature = "sticky-note")]
+mod sticky_note;
+#[cfg(feature = "store")]
+mod store;
+#[cfg(feature = "stretch-horizontal")]
+mod stretch_horizontal;
+#[cfg(feature = "stretch-vertical")]
+mod stretch_vertical;
+#[cfg(feature = "strikethrough")]
+mod strikethrough;
+#[cfg(feature = "subscript")]
+mod subscript;
+#[cfg(feature = "sun")]
+mod sun;
+#[cfg(feature = "sun-dim")]
+mod sun_dim;
+#[cfg(feature = "sun-medium")]
+mod sun_medium;
+#[cfg(feature = "sun-moon")]
+mod sun_moon;
+#[cfg(feature = "sun-snow")]
+mod sun_snow;
+#[cfg(feature = "sunrise")]
+mod sunrise;
+#[cfg(feature = "sunset")]
+mod sunset;
+#[cfg(feature = "superscript")]
+mod superscript;
+#[cfg(feature = "swatch-book")]
+mod swatch_book;
+#[cfg(feature = "swiss-franc")]
+mod swiss_franc;
+#[cfg(feature = "switch-camera")]
+mod switch_camera;
+#[cfg(feature = "sword")]
+mod sword;
+#[cfg(feature = "swords")]
+mod swords;
+#[cfg(feature = "syringe")]
+mod syringe;
+#[cfg(feature = "table")]
+mod table;
+#[cfg(feature = "table-2")]
+mod table_2;
+#[cfg(feature = "table-cells-merge")]
+mod table_cells_merge;
+#[cfg(feature = "table-cells-split")]
+mod table_cells_split;
+#[cfg(feature = "table-columns-split")]
+mod table_columns_split;
+#[cfg(feature = "table-of-contents")]
+mod table_of_contents;
+#[cfg(feature = "table-properties")]
+mod table_properties;
+#[cfg(feature = "table-rows-split")]
+mod table_rows_split;
+#[cfg(feature = "tablet")]
+mod tablet;
+#[cfg(feature = "tablet-smartphone")]
+mod tablet_smartphone;
+#[cfg(feature = "tablets")]
+mod tablets;
+#[cfg(feature = "tag")]
+mod tag;
+#[cfg(feature = "tags")]
+mod tags;
+#[cfg(feature = "tally-1")]
+mod tally_1;
+#[cfg(feature = "tally-2")]
+mod tally_2;
+#[cfg(feature = "tally-3")]
+mod tally_3;
+#[cfg(feature = "tally-4")]
+mod tally_4;
+#[cfg(feature = "tally-5")]
+mod tally_5;
+#[cfg(feature = "tangent")]
+mod tangent;
+#[cfg(feature = "target")]
+mod target;
+#[cfg(feature = "telescope")]
+mod telescope;
+#[cfg(feature = "tent")]
+mod tent;
+#[cfg(feature = "tent-tree")]
+mod tent_tree;
+#[cfg(feature = "terminal")]
+mod terminal;
+#[cfg(feature = "test-tube")]
+mod test_tube;
+#[cfg(feature = "test-tube-diagonal")]
+mod test_tube_diagonal;
+#[cfg(feature = "test-tubes")]
+mod test_tubes;
+#[cfg(feature = "text")]
+mod text;
+#[cfg(feature = "text-cursor")]
+mod text_cursor;
+#[cfg(feature = "text-cursor-input")]
+mod text_cursor_input;
+#[cfg(feature = "text-quote")]
+mod text_quote;
+#[cfg(feature = "text-search")]
+mod text_search;
+#[cfg(feature = "text-select")]
+mod text_select;
+#[cfg(feature = "theater")]
+mod theater;
+#[cfg(feature = "thermometer")]
+mod thermometer;
+#[cfg(feature = "thermometer-snowflake")]
+mod thermometer_snowflake;
+#[cfg(feature = "thermometer-sun")]
+mod thermometer_sun;
+#[cfg(feature = "thumbs-down")]
+mod thumbs_down;
+#[cfg(feature = "thumbs-up")]
+mod thumbs_up;
+#[cfg(feature = "ticket")]
+mod ticket;
+#[cfg(feature = "ticket-check")]
+mod ticket_check;
+#[cfg(feature = "ticket-minus")]
+mod ticket_minus;
+#[cfg(feature = "ticket-percent")]
+mod ticket_percent;
+#[cfg(feature = "ticket-plus")]
+mod ticket_plus;
+#[cfg(feature = "ticket-slash")]
+mod ticket_slash;
+#[cfg(feature = "ticket-x")]
+mod ticket_x;
+#[cfg(feature = "tickets")]
+mod tickets;
+#[cfg(feature = "tickets-plane")]
+mod tickets_plane;
+#[cfg(feature = "timer")]
+mod timer;
+#[cfg(feature = "timer-off")]
+mod timer_off;
+#[cfg(feature = "timer-reset")]
+mod timer_reset;
+#[cfg(feature = "toggle-left")]
+mod toggle_left;
+#[cfg(feature = "toggle-right")]
+mod toggle_right;
+#[cfg(feature = "toilet")]
+mod toilet;
+#[cfg(feature = "tornado")]
+mod tornado;
+#[cfg(feature = "torus")]
+mod torus;
+#[cfg(feature = "touchpad")]
+mod touchpad;
+#[cfg(feature = "touchpad-off")]
+mod touchpad_off;
+#[cfg(feature = "tower-control")]
+mod tower_control;
+#[cfg(feature = "toy-brick")]
+mod toy_brick;
+#[cfg(feature = "tractor")]
+mod tractor;
+#[cfg(feature = "traffic-cone")]
+mod traffic_cone;
+#[cfg(feature = "train-front")]
+mod train_front;
+#[cfg(feature = "train-front-tunnel")]
+mod train_front_tunnel;
+#[cfg(feature = "train-track")]
+mod train_track;
+#[cfg(feature = "tram-front")]
+mod tram_front;
+#[cfg(feature = "trash")]
+mod trash;
+#[cfg(feature = "trash-2")]
+mod trash_2;
+#[cfg(feature = "tree-deciduous")]
+mod tree_deciduous;
+#[cfg(feature = "tree-palm")]
+mod tree_palm;
+#[cfg(feature = "tree-pine")]
+mod tree_pine;
+#[cfg(feature = "trees")]
+mod trees;
+#[cfg(feature = "trello")]
+mod trello;
+#[cfg(feature = "trending-down")]
+mod trending_down;
+#[cfg(feature = "trending-up")]
+mod trending_up;
+#[cfg(feature = "trending-up-down")]
+mod trending_up_down;
+#[cfg(feature = "triangle")]
+mod triangle;
+#[cfg(feature = "triangle-alert")]
+mod triangle_alert;
+#[cfg(feature = "triangle-right")]
+mod triangle_right;
+#[cfg(feature = "trophy")]
+mod trophy;
+#[cfg(feature = "truck")]
+mod truck;
+#[cfg(feature = "turtle")]
+mod turtle;
+#[cfg(feature = "tv")]
+mod tv;
+#[cfg(feature = "tv-minimal")]
+mod tv_minimal;
+#[cfg(feature = "tv-minimal-play")]
+mod tv_minimal_play;
+#[cfg(feature = "twitch")]
+mod twitch;
+#[cfg(feature = "twitter")]
+mod twitter;
+#[cfg(feature = "type")]
+mod r#type;
+#[cfg(feature = "type-outline")]
+mod type_outline;
+#[cfg(feature = "umbrella")]
+mod umbrella;
+#[cfg(feature = "umbrella-off")]
+mod umbrella_off;
+#[cfg(feature = "underline")]
+mod underline;
+#[cfg(feature = "undo")]
+mod undo;
+#[cfg(feature = "undo-2")]
+mod undo_2;
+#[cfg(feature = "undo-dot")]
+mod undo_dot;
+#[cfg(feature = "unfold-horizontal")]
+mod unfold_horizontal;
+#[cfg(feature = "unfold-vertical")]
+mod unfold_vertical;
+#[cfg(feature = "ungroup")]
+mod ungroup;
+#[cfg(feature = "university")]
+mod university;
+#[cfg(feature = "unlink")]
+mod unlink;
+#[cfg(feature = "unlink-2")]
+mod unlink_2;
+#[cfg(feature = "unplug")]
+mod unplug;
+#[cfg(feature = "upload")]
+mod upload;
+#[cfg(feature = "usb")]
+mod usb;
+#[cfg(feature = "user")]
+mod user;
+#[cfg(feature = "user-check")]
+mod user_check;
+#[cfg(feature = "user-cog")]
+mod user_cog;
+#[cfg(feature = "user-minus")]
+mod user_minus;
+#[cfg(feature = "user-pen")]
+mod user_pen;
+#[cfg(feature = "user-plus")]
+mod user_plus;
+#[cfg(feature = "user-round")]
+mod user_round;
+#[cfg(feature = "user-round-check")]
+mod user_round_check;
+#[cfg(feature = "user-round-cog")]
+mod user_round_cog;
+#[cfg(feature = "user-round-minus")]
+mod user_round_minus;
+#[cfg(feature = "user-round-pen")]
+mod user_round_pen;
+#[cfg(feature = "user-round-plus")]
+mod user_round_plus;
+#[cfg(feature = "user-round-search")]
+mod user_round_search;
+#[cfg(feature = "user-round-x")]
+mod user_round_x;
+#[cfg(feature = "user-search")]
+mod user_search;
+#[cfg(feature = "user-x")]
+mod user_x;
+#[cfg(feature = "users")]
+mod users;
+#[cfg(feature = "users-round")]
+mod users_round;
+#[cfg(feature = "utensils")]
+mod utensils;
+#[cfg(feature = "utensils-crossed")]
+mod utensils_crossed;
+#[cfg(feature = "utility-pole")]
+mod utility_pole;
+#[cfg(feature = "variable")]
+mod variable;
+#[cfg(feature = "vault")]
+mod vault;
+#[cfg(feature = "vegan")]
+mod vegan;
+#[cfg(feature = "venetian-mask")]
+mod venetian_mask;
+#[cfg(feature = "vibrate")]
+mod vibrate;
+#[cfg(feature = "vibrate-off")]
+mod vibrate_off;
+#[cfg(feature = "video")]
+mod video;
+#[cfg(feature = "video-off")]
+mod video_off;
+#[cfg(feature = "videotape")]
+mod videotape;
+#[cfg(feature = "view")]
+mod view;
+#[cfg(feature = "voicemail")]
+mod voicemail;
+#[cfg(feature = "volleyball")]
+mod volleyball;
+#[cfg(feature = "volume")]
+mod volume;
+#[cfg(feature = "volume-1")]
+mod volume_1;
+#[cfg(feature = "volume-2")]
+mod volume_2;
+#[cfg(feature = "volume-off")]
+mod volume_off;
+#[cfg(feature = "volume-x")]
+mod volume_x;
+#[cfg(feature = "vote")]
+mod vote;
+#[cfg(feature = "wallet")]
+mod wallet;
+#[cfg(feature = "wallet-cards")]
+mod wallet_cards;
+#[cfg(feature = "wallet-minimal")]
+mod wallet_minimal;
+#[cfg(feature = "wallpaper")]
+mod wallpaper;
+#[cfg(feature = "wand")]
+mod wand;
+#[cfg(feature = "wand-sparkles")]
+mod wand_sparkles;
+#[cfg(feature = "warehouse")]
+mod warehouse;
+#[cfg(feature = "washing-machine")]
+mod washing_machine;
+#[cfg(feature = "watch")]
+mod watch;
+#[cfg(feature = "waves")]
+mod waves;
+#[cfg(feature = "waypoints")]
+mod waypoints;
+#[cfg(feature = "webcam")]
+mod webcam;
+#[cfg(feature = "webhook")]
+mod webhook;
+#[cfg(feature = "webhook-off")]
+mod webhook_off;
+#[cfg(feature = "weight")]
+mod weight;
+#[cfg(feature = "wheat")]
+mod wheat;
+#[cfg(feature = "wheat-off")]
+mod wheat_off;
+#[cfg(feature = "whole-word")]
+mod whole_word;
+#[cfg(feature = "wifi")]
+mod wifi;
+#[cfg(feature = "wifi-high")]
+mod wifi_high;
+#[cfg(feature = "wifi-low")]
+mod wifi_low;
+#[cfg(feature = "wifi-off")]
+mod wifi_off;
+#[cfg(feature = "wifi-zero")]
+mod wifi_zero;
+#[cfg(feature = "wind")]
+mod wind;
+#[cfg(feature = "wind-arrow-down")]
+mod wind_arrow_down;
+#[cfg(feature = "wine")]
+mod wine;
+#[cfg(feature = "wine-off")]
+mod wine_off;
+#[cfg(feature = "workflow")]
+mod workflow;
+#[cfg(feature = "worm")]
+mod worm;
+#[cfg(feature = "wrap-text")]
+mod wrap_text;
+#[cfg(feature = "wrench")]
+mod wrench;
+#[cfg(feature = "x")]
+mod x;
+#[cfg(feature = "youtube")]
+mod youtube;
+#[cfg(feature = "zap")]
+mod zap;
+#[cfg(feature = "zap-off")]
+mod zap_off;
+#[cfg(feature = "zoom-in")]
+mod zoom_in;
+#[cfg(feature = "zoom-out")]
+mod zoom_out;
+
+#[cfg(feature = "a-arrow-down")]
+pub use a_arrow_down::*;
+#[cfg(feature = "a-arrow-up")]
+pub use a_arrow_up::*;
+#[cfg(feature = "a-large-small")]
+pub use a_large_small::*;
+#[cfg(feature = "accessibility")]
+pub use accessibility::*;
+#[cfg(feature = "activity")]
+pub use activity::*;
+#[cfg(feature = "air-vent")]
+pub use air_vent::*;
+#[cfg(feature = "airplay")]
+pub use airplay::*;
+#[cfg(feature = "alarm-clock")]
+pub use alarm_clock::*;
+#[cfg(feature = "alarm-clock-check")]
+pub use alarm_clock_check::*;
+#[cfg(feature = "alarm-clock-minus")]
+pub use alarm_clock_minus::*;
+#[cfg(feature = "alarm-clock-off")]
+pub use alarm_clock_off::*;
+#[cfg(feature = "alarm-clock-plus")]
+pub use alarm_clock_plus::*;
+#[cfg(feature = "alarm-smoke")]
+pub use alarm_smoke::*;
+#[cfg(feature = "album")]
+pub use album::*;
+#[cfg(feature = "align-center")]
+pub use align_center::*;
+#[cfg(feature = "align-center-horizontal")]
+pub use align_center_horizontal::*;
+#[cfg(feature = "align-center-vertical")]
+pub use align_center_vertical::*;
+#[cfg(feature = "align-end-horizontal")]
+pub use align_end_horizontal::*;
+#[cfg(feature = "align-end-vertical")]
+pub use align_end_vertical::*;
+#[cfg(feature = "align-horizontal-distribute-center")]
+pub use align_horizontal_distribute_center::*;
+#[cfg(feature = "align-horizontal-distribute-end")]
+pub use align_horizontal_distribute_end::*;
+#[cfg(feature = "align-horizontal-distribute-start")]
+pub use align_horizontal_distribute_start::*;
+#[cfg(feature = "align-horizontal-justify-center")]
+pub use align_horizontal_justify_center::*;
+#[cfg(feature = "align-horizontal-justify-end")]
+pub use align_horizontal_justify_end::*;
+#[cfg(feature = "align-horizontal-justify-start")]
+pub use align_horizontal_justify_start::*;
+#[cfg(feature = "align-horizontal-space-around")]
+pub use align_horizontal_space_around::*;
+#[cfg(feature = "align-horizontal-space-between")]
+pub use align_horizontal_space_between::*;
+#[cfg(feature = "align-justify")]
+pub use align_justify::*;
+#[cfg(feature = "align-left")]
+pub use align_left::*;
+#[cfg(feature = "align-right")]
+pub use align_right::*;
+#[cfg(feature = "align-start-horizontal")]
+pub use align_start_horizontal::*;
+#[cfg(feature = "align-start-vertical")]
+pub use align_start_vertical::*;
+#[cfg(feature = "align-vertical-distribute-center")]
+pub use align_vertical_distribute_center::*;
+#[cfg(feature = "align-vertical-distribute-end")]
+pub use align_vertical_distribute_end::*;
+#[cfg(feature = "align-vertical-distribute-start")]
+pub use align_vertical_distribute_start::*;
+#[cfg(feature = "align-vertical-justify-center")]
+pub use align_vertical_justify_center::*;
+#[cfg(feature = "align-vertical-justify-end")]
+pub use align_vertical_justify_end::*;
+#[cfg(feature = "align-vertical-justify-start")]
+pub use align_vertical_justify_start::*;
+#[cfg(feature = "align-vertical-space-around")]
+pub use align_vertical_space_around::*;
+#[cfg(feature = "align-vertical-space-between")]
+pub use align_vertical_space_between::*;
+#[cfg(feature = "ambulance")]
+pub use ambulance::*;
+#[cfg(feature = "ampersand")]
+pub use ampersand::*;
+#[cfg(feature = "ampersands")]
+pub use ampersands::*;
+#[cfg(feature = "amphora")]
+pub use amphora::*;
+#[cfg(feature = "anchor")]
+pub use anchor::*;
+#[cfg(feature = "angry")]
+pub use angry::*;
+#[cfg(feature = "annoyed")]
+pub use annoyed::*;
+#[cfg(feature = "antenna")]
+pub use antenna::*;
+#[cfg(feature = "anvil")]
+pub use anvil::*;
+#[cfg(feature = "aperture")]
+pub use aperture::*;
+#[cfg(feature = "app-window")]
+pub use app_window::*;
+#[cfg(feature = "app-window-mac")]
+pub use app_window_mac::*;
+#[cfg(feature = "apple")]
+pub use apple::*;
+#[cfg(feature = "archive")]
+pub use archive::*;
+#[cfg(feature = "archive-restore")]
+pub use archive_restore::*;
+#[cfg(feature = "archive-x")]
+pub use archive_x::*;
+#[cfg(feature = "armchair")]
+pub use armchair::*;
+#[cfg(feature = "arrow-big-down")]
+pub use arrow_big_down::*;
+#[cfg(feature = "arrow-big-down-dash")]
+pub use arrow_big_down_dash::*;
+#[cfg(feature = "arrow-big-left")]
+pub use arrow_big_left::*;
+#[cfg(feature = "arrow-big-left-dash")]
+pub use arrow_big_left_dash::*;
+#[cfg(feature = "arrow-big-right")]
+pub use arrow_big_right::*;
+#[cfg(feature = "arrow-big-right-dash")]
+pub use arrow_big_right_dash::*;
+#[cfg(feature = "arrow-big-up")]
+pub use arrow_big_up::*;
+#[cfg(feature = "arrow-big-up-dash")]
+pub use arrow_big_up_dash::*;
+#[cfg(feature = "arrow-down")]
+pub use arrow_down::*;
+#[cfg(feature = "arrow-down-0-1")]
+pub use arrow_down_0_1::*;
+#[cfg(feature = "arrow-down-1-0")]
+pub use arrow_down_1_0::*;
+#[cfg(feature = "arrow-down-a-z")]
+pub use arrow_down_a_z::*;
+#[cfg(feature = "arrow-down-from-line")]
+pub use arrow_down_from_line::*;
+#[cfg(feature = "arrow-down-left")]
+pub use arrow_down_left::*;
+#[cfg(feature = "arrow-down-narrow-wide")]
+pub use arrow_down_narrow_wide::*;
+#[cfg(feature = "arrow-down-right")]
+pub use arrow_down_right::*;
+#[cfg(feature = "arrow-down-to-dot")]
+pub use arrow_down_to_dot::*;
+#[cfg(feature = "arrow-down-to-line")]
+pub use arrow_down_to_line::*;
+#[cfg(feature = "arrow-down-up")]
+pub use arrow_down_up::*;
+#[cfg(feature = "arrow-down-wide-narrow")]
+pub use arrow_down_wide_narrow::*;
+#[cfg(feature = "arrow-down-z-a")]
+pub use arrow_down_z_a::*;
+#[cfg(feature = "arrow-left")]
+pub use arrow_left::*;
+#[cfg(feature = "arrow-left-from-line")]
+pub use arrow_left_from_line::*;
+#[cfg(feature = "arrow-left-right")]
+pub use arrow_left_right::*;
+#[cfg(feature = "arrow-left-to-line")]
+pub use arrow_left_to_line::*;
+#[cfg(feature = "arrow-right")]
+pub use arrow_right::*;
+#[cfg(feature = "arrow-right-from-line")]
+pub use arrow_right_from_line::*;
+#[cfg(feature = "arrow-right-left")]
+pub use arrow_right_left::*;
+#[cfg(feature = "arrow-right-to-line")]
+pub use arrow_right_to_line::*;
+#[cfg(feature = "arrow-up")]
+pub use arrow_up::*;
+#[cfg(feature = "arrow-up-0-1")]
+pub use arrow_up_0_1::*;
+#[cfg(feature = "arrow-up-1-0")]
+pub use arrow_up_1_0::*;
+#[cfg(feature = "arrow-up-a-z")]
+pub use arrow_up_a_z::*;
+#[cfg(feature = "arrow-up-down")]
+pub use arrow_up_down::*;
+#[cfg(feature = "arrow-up-from-dot")]
+pub use arrow_up_from_dot::*;
+#[cfg(feature = "arrow-up-from-line")]
+pub use arrow_up_from_line::*;
+#[cfg(feature = "arrow-up-left")]
+pub use arrow_up_left::*;
+#[cfg(feature = "arrow-up-narrow-wide")]
+pub use arrow_up_narrow_wide::*;
+#[cfg(feature = "arrow-up-right")]
+pub use arrow_up_right::*;
+#[cfg(feature = "arrow-up-to-line")]
+pub use arrow_up_to_line::*;
+#[cfg(feature = "arrow-up-wide-narrow")]
+pub use arrow_up_wide_narrow::*;
+#[cfg(feature = "arrow-up-z-a")]
+pub use arrow_up_z_a::*;
+#[cfg(feature = "arrows-up-from-line")]
+pub use arrows_up_from_line::*;
+#[cfg(feature = "asterisk")]
+pub use asterisk::*;
+#[cfg(feature = "at-sign")]
+pub use at_sign::*;
+#[cfg(feature = "atom")]
+pub use atom::*;
+#[cfg(feature = "audio-lines")]
+pub use audio_lines::*;
+#[cfg(feature = "audio-waveform")]
+pub use audio_waveform::*;
+#[cfg(feature = "award")]
+pub use award::*;
+#[cfg(feature = "axe")]
+pub use axe::*;
+#[cfg(feature = "axis-3-d")]
+pub use axis_3_d::*;
+#[cfg(feature = "baby")]
+pub use baby::*;
+#[cfg(feature = "backpack")]
+pub use backpack::*;
+#[cfg(feature = "badge")]
+pub use badge::*;
+#[cfg(feature = "badge-alert")]
+pub use badge_alert::*;
+#[cfg(feature = "badge-cent")]
+pub use badge_cent::*;
+#[cfg(feature = "badge-check")]
+pub use badge_check::*;
+#[cfg(feature = "badge-dollar-sign")]
+pub use badge_dollar_sign::*;
+#[cfg(feature = "badge-euro")]
+pub use badge_euro::*;
+#[cfg(feature = "badge-help")]
+pub use badge_help::*;
+#[cfg(feature = "badge-indian-rupee")]
+pub use badge_indian_rupee::*;
+#[cfg(feature = "badge-info")]
+pub use badge_info::*;
+#[cfg(feature = "badge-japanese-yen")]
+pub use badge_japanese_yen::*;
+#[cfg(feature = "badge-minus")]
+pub use badge_minus::*;
+#[cfg(feature = "badge-percent")]
+pub use badge_percent::*;
+#[cfg(feature = "badge-plus")]
+pub use badge_plus::*;
+#[cfg(feature = "badge-pound-sterling")]
+pub use badge_pound_sterling::*;
+#[cfg(feature = "badge-russian-ruble")]
+pub use badge_russian_ruble::*;
+#[cfg(feature = "badge-swiss-franc")]
+pub use badge_swiss_franc::*;
+#[cfg(feature = "badge-x")]
+pub use badge_x::*;
+#[cfg(feature = "baggage-claim")]
+pub use baggage_claim::*;
+#[cfg(feature = "ban")]
+pub use ban::*;
+#[cfg(feature = "banana")]
+pub use banana::*;
+#[cfg(feature = "bandage")]
+pub use bandage::*;
+#[cfg(feature = "banknote")]
+pub use banknote::*;
+#[cfg(feature = "barcode")]
+pub use barcode::*;
+#[cfg(feature = "baseline")]
+pub use baseline::*;
+#[cfg(feature = "bath")]
+pub use bath::*;
+#[cfg(feature = "battery")]
+pub use battery::*;
+#[cfg(feature = "battery-charging")]
+pub use battery_charging::*;
+#[cfg(feature = "battery-full")]
+pub use battery_full::*;
+#[cfg(feature = "battery-low")]
+pub use battery_low::*;
+#[cfg(feature = "battery-medium")]
+pub use battery_medium::*;
+#[cfg(feature = "battery-warning")]
+pub use battery_warning::*;
+#[cfg(feature = "beaker")]
+pub use beaker::*;
+#[cfg(feature = "bean")]
+pub use bean::*;
+#[cfg(feature = "bean-off")]
+pub use bean_off::*;
+#[cfg(feature = "bed")]
+pub use bed::*;
+#[cfg(feature = "bed-double")]
+pub use bed_double::*;
+#[cfg(feature = "bed-single")]
+pub use bed_single::*;
+#[cfg(feature = "beef")]
+pub use beef::*;
+#[cfg(feature = "beer")]
+pub use beer::*;
+#[cfg(feature = "beer-off")]
+pub use beer_off::*;
+#[cfg(feature = "bell")]
+pub use bell::*;
+#[cfg(feature = "bell-dot")]
+pub use bell_dot::*;
+#[cfg(feature = "bell-electric")]
+pub use bell_electric::*;
+#[cfg(feature = "bell-minus")]
+pub use bell_minus::*;
+#[cfg(feature = "bell-off")]
+pub use bell_off::*;
+#[cfg(feature = "bell-plus")]
+pub use bell_plus::*;
+#[cfg(feature = "bell-ring")]
+pub use bell_ring::*;
+#[cfg(feature = "between-horizontal-end")]
+pub use between_horizontal_end::*;
+#[cfg(feature = "between-horizontal-start")]
+pub use between_horizontal_start::*;
+#[cfg(feature = "between-vertical-end")]
+pub use between_vertical_end::*;
+#[cfg(feature = "between-vertical-start")]
+pub use between_vertical_start::*;
+#[cfg(feature = "biceps-flexed")]
+pub use biceps_flexed::*;
+#[cfg(feature = "bike")]
+pub use bike::*;
+#[cfg(feature = "binary")]
+pub use binary::*;
+#[cfg(feature = "binoculars")]
+pub use binoculars::*;
+#[cfg(feature = "biohazard")]
+pub use biohazard::*;
+#[cfg(feature = "bird")]
+pub use bird::*;
+#[cfg(feature = "bitcoin")]
+pub use bitcoin::*;
+#[cfg(feature = "blend")]
+pub use blend::*;
+#[cfg(feature = "blinds")]
+pub use blinds::*;
+#[cfg(feature = "blocks")]
+pub use blocks::*;
+#[cfg(feature = "bluetooth")]
+pub use bluetooth::*;
+#[cfg(feature = "bluetooth-connected")]
+pub use bluetooth_connected::*;
+#[cfg(feature = "bluetooth-off")]
+pub use bluetooth_off::*;
+#[cfg(feature = "bluetooth-searching")]
+pub use bluetooth_searching::*;
+#[cfg(feature = "bold")]
+pub use bold::*;
+#[cfg(feature = "bolt")]
+pub use bolt::*;
+#[cfg(feature = "bomb")]
+pub use bomb::*;
+#[cfg(feature = "bone")]
+pub use bone::*;
+#[cfg(feature = "book")]
+pub use book::*;
+#[cfg(feature = "book-a")]
+pub use book_a::*;
+#[cfg(feature = "book-audio")]
+pub use book_audio::*;
+#[cfg(feature = "book-check")]
+pub use book_check::*;
+#[cfg(feature = "book-copy")]
+pub use book_copy::*;
+#[cfg(feature = "book-dashed")]
+pub use book_dashed::*;
+#[cfg(feature = "book-down")]
+pub use book_down::*;
+#[cfg(feature = "book-headphones")]
+pub use book_headphones::*;
+#[cfg(feature = "book-heart")]
+pub use book_heart::*;
+#[cfg(feature = "book-image")]
+pub use book_image::*;
+#[cfg(feature = "book-key")]
+pub use book_key::*;
+#[cfg(feature = "book-lock")]
+pub use book_lock::*;
+#[cfg(feature = "book-marked")]
+pub use book_marked::*;
+#[cfg(feature = "book-minus")]
+pub use book_minus::*;
+#[cfg(feature = "book-open")]
+pub use book_open::*;
+#[cfg(feature = "book-open-check")]
+pub use book_open_check::*;
+#[cfg(feature = "book-open-text")]
+pub use book_open_text::*;
+#[cfg(feature = "book-plus")]
+pub use book_plus::*;
+#[cfg(feature = "book-text")]
+pub use book_text::*;
+#[cfg(feature = "book-type")]
+pub use book_type::*;
+#[cfg(feature = "book-up")]
+pub use book_up::*;
+#[cfg(feature = "book-up-2")]
+pub use book_up_2::*;
+#[cfg(feature = "book-user")]
+pub use book_user::*;
+#[cfg(feature = "book-x")]
+pub use book_x::*;
+#[cfg(feature = "bookmark")]
+pub use bookmark::*;
+#[cfg(feature = "bookmark-check")]
+pub use bookmark_check::*;
+#[cfg(feature = "bookmark-minus")]
+pub use bookmark_minus::*;
+#[cfg(feature = "bookmark-plus")]
+pub use bookmark_plus::*;
+#[cfg(feature = "bookmark-x")]
+pub use bookmark_x::*;
+#[cfg(feature = "boom-box")]
+pub use boom_box::*;
+#[cfg(feature = "bot")]
+pub use bot::*;
+#[cfg(feature = "bot-message-square")]
+pub use bot_message_square::*;
+#[cfg(feature = "bot-off")]
+pub use bot_off::*;
+#[cfg(feature = "boxes")]
+pub use boxes::*;
+#[cfg(feature = "braces")]
+pub use braces::*;
+#[cfg(feature = "brackets")]
+pub use brackets::*;
+#[cfg(feature = "brain")]
+pub use brain::*;
+#[cfg(feature = "brain-circuit")]
+pub use brain_circuit::*;
+#[cfg(feature = "brain-cog")]
+pub use brain_cog::*;
+#[cfg(feature = "brick-wall")]
+pub use brick_wall::*;
+#[cfg(feature = "briefcase")]
+pub use briefcase::*;
+#[cfg(feature = "briefcase-business")]
+pub use briefcase_business::*;
+#[cfg(feature = "briefcase-conveyor-belt")]
+pub use briefcase_conveyor_belt::*;
+#[cfg(feature = "briefcase-medical")]
+pub use briefcase_medical::*;
+#[cfg(feature = "bring-to-front")]
+pub use bring_to_front::*;
+#[cfg(feature = "brush")]
+pub use brush::*;
+#[cfg(feature = "bug")]
+pub use bug::*;
+#[cfg(feature = "bug-off")]
+pub use bug_off::*;
+#[cfg(feature = "bug-play")]
+pub use bug_play::*;
+#[cfg(feature = "building")]
+pub use building::*;
+#[cfg(feature = "building-2")]
+pub use building_2::*;
+#[cfg(feature = "bus")]
+pub use bus::*;
+#[cfg(feature = "bus-front")]
+pub use bus_front::*;
+#[cfg(feature = "cable")]
+pub use cable::*;
+#[cfg(feature = "cable-car")]
+pub use cable_car::*;
+#[cfg(feature = "cake")]
+pub use cake::*;
+#[cfg(feature = "cake-slice")]
+pub use cake_slice::*;
+#[cfg(feature = "calculator")]
+pub use calculator::*;
+#[cfg(feature = "calendar")]
+pub use calendar::*;
+#[cfg(feature = "calendar-1")]
+pub use calendar_1::*;
+#[cfg(feature = "calendar-arrow-down")]
+pub use calendar_arrow_down::*;
+#[cfg(feature = "calendar-arrow-up")]
+pub use calendar_arrow_up::*;
+#[cfg(feature = "calendar-check")]
+pub use calendar_check::*;
+#[cfg(feature = "calendar-check-2")]
+pub use calendar_check_2::*;
+#[cfg(feature = "calendar-clock")]
+pub use calendar_clock::*;
+#[cfg(feature = "calendar-cog")]
+pub use calendar_cog::*;
+#[cfg(feature = "calendar-days")]
+pub use calendar_days::*;
+#[cfg(feature = "calendar-fold")]
+pub use calendar_fold::*;
+#[cfg(feature = "calendar-heart")]
+pub use calendar_heart::*;
+#[cfg(feature = "calendar-minus")]
+pub use calendar_minus::*;
+#[cfg(feature = "calendar-minus-2")]
+pub use calendar_minus_2::*;
+#[cfg(feature = "calendar-off")]
+pub use calendar_off::*;
+#[cfg(feature = "calendar-plus")]
+pub use calendar_plus::*;
+#[cfg(feature = "calendar-plus-2")]
+pub use calendar_plus_2::*;
+#[cfg(feature = "calendar-range")]
+pub use calendar_range::*;
+#[cfg(feature = "calendar-search")]
+pub use calendar_search::*;
+#[cfg(feature = "calendar-x")]
+pub use calendar_x::*;
+#[cfg(feature = "calendar-x-2")]
+pub use calendar_x_2::*;
+#[cfg(feature = "camera")]
+pub use camera::*;
+#[cfg(feature = "camera-off")]
+pub use camera_off::*;
+#[cfg(feature = "candy")]
+pub use candy::*;
+#[cfg(feature = "candy-cane")]
+pub use candy_cane::*;
+#[cfg(feature = "candy-off")]
+pub use candy_off::*;
+#[cfg(feature = "cannabis")]
+pub use cannabis::*;
+#[cfg(feature = "captions")]
+pub use captions::*;
+#[cfg(feature = "captions-off")]
+pub use captions_off::*;
+#[cfg(feature = "car")]
+pub use car::*;
+#[cfg(feature = "car-front")]
+pub use car_front::*;
+#[cfg(feature = "car-taxi-front")]
+pub use car_taxi_front::*;
+#[cfg(feature = "caravan")]
+pub use caravan::*;
+#[cfg(feature = "carrot")]
+pub use carrot::*;
+#[cfg(feature = "case-lower")]
+pub use case_lower::*;
+#[cfg(feature = "case-sensitive")]
+pub use case_sensitive::*;
+#[cfg(feature = "case-upper")]
+pub use case_upper::*;
+#[cfg(feature = "cassette-tape")]
+pub use cassette_tape::*;
+#[cfg(feature = "cast")]
+pub use cast::*;
+#[cfg(feature = "castle")]
+pub use castle::*;
+#[cfg(feature = "cat")]
+pub use cat::*;
+#[cfg(feature = "cctv")]
+pub use cctv::*;
+#[cfg(feature = "chart-area")]
+pub use chart_area::*;
+#[cfg(feature = "chart-bar")]
+pub use chart_bar::*;
+#[cfg(feature = "chart-bar-big")]
+pub use chart_bar_big::*;
+#[cfg(feature = "chart-bar-decreasing")]
+pub use chart_bar_decreasing::*;
+#[cfg(feature = "chart-bar-increasing")]
+pub use chart_bar_increasing::*;
+#[cfg(feature = "chart-bar-stacked")]
+pub use chart_bar_stacked::*;
+#[cfg(feature = "chart-candlestick")]
+pub use chart_candlestick::*;
+#[cfg(feature = "chart-column")]
+pub use chart_column::*;
+#[cfg(feature = "chart-column-big")]
+pub use chart_column_big::*;
+#[cfg(feature = "chart-column-decreasing")]
+pub use chart_column_decreasing::*;
+#[cfg(feature = "chart-column-increasing")]
+pub use chart_column_increasing::*;
+#[cfg(feature = "chart-column-stacked")]
+pub use chart_column_stacked::*;
+#[cfg(feature = "chart-gantt")]
+pub use chart_gantt::*;
+#[cfg(feature = "chart-line")]
+pub use chart_line::*;
+#[cfg(feature = "chart-network")]
+pub use chart_network::*;
+#[cfg(feature = "chart-no-axes-column")]
+pub use chart_no_axes_column::*;
+#[cfg(feature = "chart-no-axes-column-decreasing")]
+pub use chart_no_axes_column_decreasing::*;
+#[cfg(feature = "chart-no-axes-column-increasing")]
+pub use chart_no_axes_column_increasing::*;
+#[cfg(feature = "chart-no-axes-combined")]
+pub use chart_no_axes_combined::*;
+#[cfg(feature = "chart-no-axes-gantt")]
+pub use chart_no_axes_gantt::*;
+#[cfg(feature = "chart-pie")]
+pub use chart_pie::*;
+#[cfg(feature = "chart-scatter")]
+pub use chart_scatter::*;
+#[cfg(feature = "chart-spline")]
+pub use chart_spline::*;
+#[cfg(feature = "check")]
+pub use check::*;
+#[cfg(feature = "check-check")]
+pub use check_check::*;
+#[cfg(feature = "chef-hat")]
+pub use chef_hat::*;
+#[cfg(feature = "cherry")]
+pub use cherry::*;
+#[cfg(feature = "chevron-down")]
+pub use chevron_down::*;
+#[cfg(feature = "chevron-first")]
+pub use chevron_first::*;
+#[cfg(feature = "chevron-last")]
+pub use chevron_last::*;
+#[cfg(feature = "chevron-left")]
+pub use chevron_left::*;
+#[cfg(feature = "chevron-right")]
+pub use chevron_right::*;
+#[cfg(feature = "chevron-up")]
+pub use chevron_up::*;
+#[cfg(feature = "chevrons-down")]
+pub use chevrons_down::*;
+#[cfg(feature = "chevrons-down-up")]
+pub use chevrons_down_up::*;
+#[cfg(feature = "chevrons-left")]
+pub use chevrons_left::*;
+#[cfg(feature = "chevrons-left-right")]
+pub use chevrons_left_right::*;
+#[cfg(feature = "chevrons-left-right-ellipsis")]
+pub use chevrons_left_right_ellipsis::*;
+#[cfg(feature = "chevrons-right")]
+pub use chevrons_right::*;
+#[cfg(feature = "chevrons-right-left")]
+pub use chevrons_right_left::*;
+#[cfg(feature = "chevrons-up")]
+pub use chevrons_up::*;
+#[cfg(feature = "chevrons-up-down")]
+pub use chevrons_up_down::*;
+#[cfg(feature = "chrome")]
+pub use chrome::*;
+#[cfg(feature = "church")]
+pub use church::*;
+#[cfg(feature = "cigarette")]
+pub use cigarette::*;
+#[cfg(feature = "cigarette-off")]
+pub use cigarette_off::*;
+#[cfg(feature = "circle")]
+pub use circle::*;
+#[cfg(feature = "circle-alert")]
+pub use circle_alert::*;
+#[cfg(feature = "circle-arrow-down")]
+pub use circle_arrow_down::*;
+#[cfg(feature = "circle-arrow-left")]
+pub use circle_arrow_left::*;
+#[cfg(feature = "circle-arrow-out-down-left")]
+pub use circle_arrow_out_down_left::*;
+#[cfg(feature = "circle-arrow-out-down-right")]
+pub use circle_arrow_out_down_right::*;
+#[cfg(feature = "circle-arrow-out-up-left")]
+pub use circle_arrow_out_up_left::*;
+#[cfg(feature = "circle-arrow-out-up-right")]
+pub use circle_arrow_out_up_right::*;
+#[cfg(feature = "circle-arrow-right")]
+pub use circle_arrow_right::*;
+#[cfg(feature = "circle-arrow-up")]
+pub use circle_arrow_up::*;
+#[cfg(feature = "circle-check")]
+pub use circle_check::*;
+#[cfg(feature = "circle-check-big")]
+pub use circle_check_big::*;
+#[cfg(feature = "circle-chevron-down")]
+pub use circle_chevron_down::*;
+#[cfg(feature = "circle-chevron-left")]
+pub use circle_chevron_left::*;
+#[cfg(feature = "circle-chevron-right")]
+pub use circle_chevron_right::*;
+#[cfg(feature = "circle-chevron-up")]
+pub use circle_chevron_up::*;
+#[cfg(feature = "circle-dashed")]
+pub use circle_dashed::*;
+#[cfg(feature = "circle-divide")]
+pub use circle_divide::*;
+#[cfg(feature = "circle-dollar-sign")]
+pub use circle_dollar_sign::*;
+#[cfg(feature = "circle-dot")]
+pub use circle_dot::*;
+#[cfg(feature = "circle-dot-dashed")]
+pub use circle_dot_dashed::*;
+#[cfg(feature = "circle-ellipsis")]
+pub use circle_ellipsis::*;
+#[cfg(feature = "circle-equal")]
+pub use circle_equal::*;
+#[cfg(feature = "circle-fading-arrow-up")]
+pub use circle_fading_arrow_up::*;
+#[cfg(feature = "circle-fading-plus")]
+pub use circle_fading_plus::*;
+#[cfg(feature = "circle-gauge")]
+pub use circle_gauge::*;
+#[cfg(feature = "circle-help")]
+pub use circle_help::*;
+#[cfg(feature = "circle-minus")]
+pub use circle_minus::*;
+#[cfg(feature = "circle-off")]
+pub use circle_off::*;
+#[cfg(feature = "circle-parking")]
+pub use circle_parking::*;
+#[cfg(feature = "circle-parking-off")]
+pub use circle_parking_off::*;
+#[cfg(feature = "circle-pause")]
+pub use circle_pause::*;
+#[cfg(feature = "circle-percent")]
+pub use circle_percent::*;
+#[cfg(feature = "circle-play")]
+pub use circle_play::*;
+#[cfg(feature = "circle-plus")]
+pub use circle_plus::*;
+#[cfg(feature = "circle-power")]
+pub use circle_power::*;
+#[cfg(feature = "circle-slash")]
+pub use circle_slash::*;
+#[cfg(feature = "circle-slash-2")]
+pub use circle_slash_2::*;
+#[cfg(feature = "circle-stop")]
+pub use circle_stop::*;
+#[cfg(feature = "circle-user")]
+pub use circle_user::*;
+#[cfg(feature = "circle-user-round")]
+pub use circle_user_round::*;
+#[cfg(feature = "circle-x")]
+pub use circle_x::*;
+#[cfg(feature = "circuit-board")]
+pub use circuit_board::*;
+#[cfg(feature = "citrus")]
+pub use citrus::*;
+#[cfg(feature = "clapperboard")]
+pub use clapperboard::*;
+#[cfg(feature = "clipboard")]
+pub use clipboard::*;
+#[cfg(feature = "clipboard-check")]
+pub use clipboard_check::*;
+#[cfg(feature = "clipboard-copy")]
+pub use clipboard_copy::*;
+#[cfg(feature = "clipboard-list")]
+pub use clipboard_list::*;
+#[cfg(feature = "clipboard-minus")]
+pub use clipboard_minus::*;
+#[cfg(feature = "clipboard-paste")]
+pub use clipboard_paste::*;
+#[cfg(feature = "clipboard-pen")]
+pub use clipboard_pen::*;
+#[cfg(feature = "clipboard-pen-line")]
+pub use clipboard_pen_line::*;
+#[cfg(feature = "clipboard-plus")]
+pub use clipboard_plus::*;
+#[cfg(feature = "clipboard-type")]
+pub use clipboard_type::*;
+#[cfg(feature = "clipboard-x")]
+pub use clipboard_x::*;
+#[cfg(feature = "clock")]
+pub use clock::*;
+#[cfg(feature = "clock-1")]
+pub use clock_1::*;
+#[cfg(feature = "clock-10")]
+pub use clock_10::*;
+#[cfg(feature = "clock-11")]
+pub use clock_11::*;
+#[cfg(feature = "clock-12")]
+pub use clock_12::*;
+#[cfg(feature = "clock-2")]
+pub use clock_2::*;
+#[cfg(feature = "clock-3")]
+pub use clock_3::*;
+#[cfg(feature = "clock-4")]
+pub use clock_4::*;
+#[cfg(feature = "clock-5")]
+pub use clock_5::*;
+#[cfg(feature = "clock-6")]
+pub use clock_6::*;
+#[cfg(feature = "clock-7")]
+pub use clock_7::*;
+#[cfg(feature = "clock-8")]
+pub use clock_8::*;
+#[cfg(feature = "clock-9")]
+pub use clock_9::*;
+#[cfg(feature = "clock-alert")]
+pub use clock_alert::*;
+#[cfg(feature = "clock-arrow-down")]
+pub use clock_arrow_down::*;
+#[cfg(feature = "clock-arrow-up")]
+pub use clock_arrow_up::*;
+#[cfg(feature = "cloud")]
+pub use cloud::*;
+#[cfg(feature = "cloud-alert")]
+pub use cloud_alert::*;
+#[cfg(feature = "cloud-cog")]
+pub use cloud_cog::*;
+#[cfg(feature = "cloud-download")]
+pub use cloud_download::*;
+#[cfg(feature = "cloud-drizzle")]
+pub use cloud_drizzle::*;
+#[cfg(feature = "cloud-fog")]
+pub use cloud_fog::*;
+#[cfg(feature = "cloud-hail")]
+pub use cloud_hail::*;
+#[cfg(feature = "cloud-lightning")]
+pub use cloud_lightning::*;
+#[cfg(feature = "cloud-moon")]
+pub use cloud_moon::*;
+#[cfg(feature = "cloud-moon-rain")]
+pub use cloud_moon_rain::*;
+#[cfg(feature = "cloud-off")]
+pub use cloud_off::*;
+#[cfg(feature = "cloud-rain")]
+pub use cloud_rain::*;
+#[cfg(feature = "cloud-rain-wind")]
+pub use cloud_rain_wind::*;
+#[cfg(feature = "cloud-snow")]
+pub use cloud_snow::*;
+#[cfg(feature = "cloud-sun")]
+pub use cloud_sun::*;
+#[cfg(feature = "cloud-sun-rain")]
+pub use cloud_sun_rain::*;
+#[cfg(feature = "cloud-upload")]
+pub use cloud_upload::*;
+#[cfg(feature = "cloudy")]
+pub use cloudy::*;
+#[cfg(feature = "clover")]
+pub use clover::*;
+#[cfg(feature = "club")]
+pub use club::*;
+#[cfg(feature = "code")]
+pub use code::*;
+#[cfg(feature = "code-xml")]
+pub use code_xml::*;
+#[cfg(feature = "codepen")]
+pub use codepen::*;
+#[cfg(feature = "codesandbox")]
+pub use codesandbox::*;
+#[cfg(feature = "coffee")]
+pub use coffee::*;
+#[cfg(feature = "cog")]
+pub use cog::*;
+#[cfg(feature = "coins")]
+pub use coins::*;
+#[cfg(feature = "columns-2")]
+pub use columns_2::*;
+#[cfg(feature = "columns-3")]
+pub use columns_3::*;
+#[cfg(feature = "columns-4")]
+pub use columns_4::*;
+#[cfg(feature = "combine")]
+pub use combine::*;
+#[cfg(feature = "command")]
+pub use command::*;
+#[cfg(feature = "compass")]
+pub use compass::*;
+#[cfg(feature = "component")]
+pub use component::*;
+#[cfg(feature = "computer")]
+pub use computer::*;
+#[cfg(feature = "concierge-bell")]
+pub use concierge_bell::*;
+#[cfg(feature = "cone")]
+pub use cone::*;
+#[cfg(feature = "construction")]
+pub use construction::*;
+#[cfg(feature = "contact")]
+pub use contact::*;
+#[cfg(feature = "contact-round")]
+pub use contact_round::*;
+#[cfg(feature = "container")]
+pub use container::*;
+#[cfg(feature = "contrast")]
+pub use contrast::*;
+#[cfg(feature = "cookie")]
+pub use cookie::*;
+#[cfg(feature = "cooking-pot")]
+pub use cooking_pot::*;
+#[cfg(feature = "copy")]
+pub use copy::*;
+#[cfg(feature = "copy-check")]
+pub use copy_check::*;
+#[cfg(feature = "copy-minus")]
+pub use copy_minus::*;
+#[cfg(feature = "copy-plus")]
+pub use copy_plus::*;
+#[cfg(feature = "copy-slash")]
+pub use copy_slash::*;
+#[cfg(feature = "copy-x")]
+pub use copy_x::*;
+#[cfg(feature = "copyleft")]
+pub use copyleft::*;
+#[cfg(feature = "copyright")]
+pub use copyright::*;
+#[cfg(feature = "corner-down-left")]
+pub use corner_down_left::*;
+#[cfg(feature = "corner-down-right")]
+pub use corner_down_right::*;
+#[cfg(feature = "corner-left-down")]
+pub use corner_left_down::*;
+#[cfg(feature = "corner-left-up")]
+pub use corner_left_up::*;
+#[cfg(feature = "corner-right-down")]
+pub use corner_right_down::*;
+#[cfg(feature = "corner-right-up")]
+pub use corner_right_up::*;
+#[cfg(feature = "corner-up-left")]
+pub use corner_up_left::*;
+#[cfg(feature = "corner-up-right")]
+pub use corner_up_right::*;
+#[cfg(feature = "cpu")]
+pub use cpu::*;
+#[cfg(feature = "creative-commons")]
+pub use creative_commons::*;
+#[cfg(feature = "credit-card")]
+pub use credit_card::*;
+#[cfg(feature = "croissant")]
+pub use croissant::*;
+#[cfg(feature = "crop")]
+pub use crop::*;
+#[cfg(feature = "cross")]
+pub use cross::*;
+#[cfg(feature = "crosshair")]
+pub use crosshair::*;
+#[cfg(feature = "crown")]
+pub use crown::*;
+#[cfg(feature = "cuboid")]
+pub use cuboid::*;
+#[cfg(feature = "cup-soda")]
+pub use cup_soda::*;
+#[cfg(feature = "currency")]
+pub use currency::*;
+#[cfg(feature = "cylinder")]
+pub use cylinder::*;
+#[cfg(feature = "dam")]
+pub use dam::*;
+#[cfg(feature = "database")]
+pub use database::*;
+#[cfg(feature = "database-backup")]
+pub use database_backup::*;
+#[cfg(feature = "database-zap")]
+pub use database_zap::*;
+#[cfg(feature = "delete")]
+pub use delete::*;
+#[cfg(feature = "dessert")]
+pub use dessert::*;
+#[cfg(feature = "diameter")]
+pub use diameter::*;
+#[cfg(feature = "diamond")]
+pub use diamond::*;
+#[cfg(feature = "diamond-minus")]
+pub use diamond_minus::*;
+#[cfg(feature = "diamond-percent")]
+pub use diamond_percent::*;
+#[cfg(feature = "diamond-plus")]
+pub use diamond_plus::*;
+#[cfg(feature = "dice-1")]
+pub use dice_1::*;
+#[cfg(feature = "dice-2")]
+pub use dice_2::*;
+#[cfg(feature = "dice-3")]
+pub use dice_3::*;
+#[cfg(feature = "dice-4")]
+pub use dice_4::*;
+#[cfg(feature = "dice-5")]
+pub use dice_5::*;
+#[cfg(feature = "dice-6")]
+pub use dice_6::*;
+#[cfg(feature = "dices")]
+pub use dices::*;
+#[cfg(feature = "diff")]
+pub use diff::*;
+#[cfg(feature = "disc")]
+pub use disc::*;
+#[cfg(feature = "disc-2")]
+pub use disc_2::*;
+#[cfg(feature = "disc-3")]
+pub use disc_3::*;
+#[cfg(feature = "disc-album")]
+pub use disc_album::*;
+#[cfg(feature = "divide")]
+pub use divide::*;
+#[cfg(feature = "dna")]
+pub use dna::*;
+#[cfg(feature = "dna-off")]
+pub use dna_off::*;
+#[cfg(feature = "dock")]
+pub use dock::*;
+#[cfg(feature = "dog")]
+pub use dog::*;
+#[cfg(feature = "dollar-sign")]
+pub use dollar_sign::*;
+#[cfg(feature = "donut")]
+pub use donut::*;
+#[cfg(feature = "door-closed")]
+pub use door_closed::*;
+#[cfg(feature = "door-open")]
+pub use door_open::*;
+#[cfg(feature = "dot")]
+pub use dot::*;
+#[cfg(feature = "download")]
+pub use download::*;
+#[cfg(feature = "drafting-compass")]
+pub use drafting_compass::*;
+#[cfg(feature = "drama")]
+pub use drama::*;
+#[cfg(feature = "dribbble")]
+pub use dribbble::*;
+#[cfg(feature = "drill")]
+pub use drill::*;
+#[cfg(feature = "droplet")]
+pub use droplet::*;
+#[cfg(feature = "droplets")]
+pub use droplets::*;
+#[cfg(feature = "drum")]
+pub use drum::*;
+#[cfg(feature = "drumstick")]
+pub use drumstick::*;
+#[cfg(feature = "dumbbell")]
+pub use dumbbell::*;
+#[cfg(feature = "ear")]
+pub use ear::*;
+#[cfg(feature = "ear-off")]
+pub use ear_off::*;
+#[cfg(feature = "earth")]
+pub use earth::*;
+#[cfg(feature = "earth-lock")]
+pub use earth_lock::*;
+#[cfg(feature = "eclipse")]
+pub use eclipse::*;
+#[cfg(feature = "egg")]
+pub use egg::*;
+#[cfg(feature = "egg-fried")]
+pub use egg_fried::*;
+#[cfg(feature = "egg-off")]
+pub use egg_off::*;
+#[cfg(feature = "ellipsis")]
+pub use ellipsis::*;
+#[cfg(feature = "ellipsis-vertical")]
+pub use ellipsis_vertical::*;
+#[cfg(feature = "equal")]
+pub use equal::*;
+#[cfg(feature = "equal-approximately")]
+pub use equal_approximately::*;
+#[cfg(feature = "equal-not")]
+pub use equal_not::*;
+#[cfg(feature = "eraser")]
+pub use eraser::*;
+#[cfg(feature = "ethernet-port")]
+pub use ethernet_port::*;
+#[cfg(feature = "euro")]
+pub use euro::*;
+#[cfg(feature = "expand")]
+pub use expand::*;
+#[cfg(feature = "external-link")]
+pub use external_link::*;
+#[cfg(feature = "eye")]
+pub use eye::*;
+#[cfg(feature = "eye-closed")]
+pub use eye_closed::*;
+#[cfg(feature = "eye-off")]
+pub use eye_off::*;
+#[cfg(feature = "facebook")]
+pub use facebook::*;
+#[cfg(feature = "factory")]
+pub use factory::*;
+#[cfg(feature = "fan")]
+pub use fan::*;
+#[cfg(feature = "fast-forward")]
+pub use fast_forward::*;
+#[cfg(feature = "feather")]
+pub use feather::*;
+#[cfg(feature = "fence")]
+pub use fence::*;
+#[cfg(feature = "ferris-wheel")]
+pub use ferris_wheel::*;
+#[cfg(feature = "figma")]
+pub use figma::*;
+#[cfg(feature = "file")]
+pub use file::*;
+#[cfg(feature = "file-archive")]
+pub use file_archive::*;
+#[cfg(feature = "file-audio")]
+pub use file_audio::*;
+#[cfg(feature = "file-audio-2")]
+pub use file_audio_2::*;
+#[cfg(feature = "file-axis-3-d")]
+pub use file_axis_3_d::*;
+#[cfg(feature = "file-badge")]
+pub use file_badge::*;
+#[cfg(feature = "file-badge-2")]
+pub use file_badge_2::*;
+#[cfg(feature = "file-box")]
+pub use file_box::*;
+#[cfg(feature = "file-chart-column")]
+pub use file_chart_column::*;
+#[cfg(feature = "file-chart-column-increasing")]
+pub use file_chart_column_increasing::*;
+#[cfg(feature = "file-chart-line")]
+pub use file_chart_line::*;
+#[cfg(feature = "file-chart-pie")]
+pub use file_chart_pie::*;
+#[cfg(feature = "file-check")]
+pub use file_check::*;
+#[cfg(feature = "file-check-2")]
+pub use file_check_2::*;
+#[cfg(feature = "file-clock")]
+pub use file_clock::*;
+#[cfg(feature = "file-code")]
+pub use file_code::*;
+#[cfg(feature = "file-code-2")]
+pub use file_code_2::*;
+#[cfg(feature = "file-cog")]
+pub use file_cog::*;
+#[cfg(feature = "file-diff")]
+pub use file_diff::*;
+#[cfg(feature = "file-digit")]
+pub use file_digit::*;
+#[cfg(feature = "file-down")]
+pub use file_down::*;
+#[cfg(feature = "file-heart")]
+pub use file_heart::*;
+#[cfg(feature = "file-image")]
+pub use file_image::*;
+#[cfg(feature = "file-input")]
+pub use file_input::*;
+#[cfg(feature = "file-json")]
+pub use file_json::*;
+#[cfg(feature = "file-json-2")]
+pub use file_json_2::*;
+#[cfg(feature = "file-key")]
+pub use file_key::*;
+#[cfg(feature = "file-key-2")]
+pub use file_key_2::*;
+#[cfg(feature = "file-lock")]
+pub use file_lock::*;
+#[cfg(feature = "file-lock-2")]
+pub use file_lock_2::*;
+#[cfg(feature = "file-minus")]
+pub use file_minus::*;
+#[cfg(feature = "file-minus-2")]
+pub use file_minus_2::*;
+#[cfg(feature = "file-music")]
+pub use file_music::*;
+#[cfg(feature = "file-output")]
+pub use file_output::*;
+#[cfg(feature = "file-pen")]
+pub use file_pen::*;
+#[cfg(feature = "file-pen-line")]
+pub use file_pen_line::*;
+#[cfg(feature = "file-plus")]
+pub use file_plus::*;
+#[cfg(feature = "file-plus-2")]
+pub use file_plus_2::*;
+#[cfg(feature = "file-question")]
+pub use file_question::*;
+#[cfg(feature = "file-scan")]
+pub use file_scan::*;
+#[cfg(feature = "file-search")]
+pub use file_search::*;
+#[cfg(feature = "file-search-2")]
+pub use file_search_2::*;
+#[cfg(feature = "file-sliders")]
+pub use file_sliders::*;
+#[cfg(feature = "file-spreadsheet")]
+pub use file_spreadsheet::*;
+#[cfg(feature = "file-stack")]
+pub use file_stack::*;
+#[cfg(feature = "file-symlink")]
+pub use file_symlink::*;
+#[cfg(feature = "file-terminal")]
+pub use file_terminal::*;
+#[cfg(feature = "file-text")]
+pub use file_text::*;
+#[cfg(feature = "file-type")]
+pub use file_type::*;
+#[cfg(feature = "file-type-2")]
+pub use file_type_2::*;
+#[cfg(feature = "file-up")]
+pub use file_up::*;
+#[cfg(feature = "file-user")]
+pub use file_user::*;
+#[cfg(feature = "file-video")]
+pub use file_video::*;
+#[cfg(feature = "file-video-2")]
+pub use file_video_2::*;
+#[cfg(feature = "file-volume")]
+pub use file_volume::*;
+#[cfg(feature = "file-volume-2")]
+pub use file_volume_2::*;
+#[cfg(feature = "file-warning")]
+pub use file_warning::*;
+#[cfg(feature = "file-x")]
+pub use file_x::*;
+#[cfg(feature = "file-x-2")]
+pub use file_x_2::*;
+#[cfg(feature = "files")]
+pub use files::*;
+#[cfg(feature = "film")]
+pub use film::*;
+#[cfg(feature = "filter")]
+pub use filter::*;
+#[cfg(feature = "filter-x")]
+pub use filter_x::*;
+#[cfg(feature = "fingerprint")]
+pub use fingerprint::*;
+#[cfg(feature = "fire-extinguisher")]
+pub use fire_extinguisher::*;
+#[cfg(feature = "fish")]
+pub use fish::*;
+#[cfg(feature = "fish-off")]
+pub use fish_off::*;
+#[cfg(feature = "fish-symbol")]
+pub use fish_symbol::*;
+#[cfg(feature = "flag")]
+pub use flag::*;
+#[cfg(feature = "flag-off")]
+pub use flag_off::*;
+#[cfg(feature = "flag-triangle-left")]
+pub use flag_triangle_left::*;
+#[cfg(feature = "flag-triangle-right")]
+pub use flag_triangle_right::*;
+#[cfg(feature = "flame")]
+pub use flame::*;
+#[cfg(feature = "flame-kindling")]
+pub use flame_kindling::*;
+#[cfg(feature = "flashlight")]
+pub use flashlight::*;
+#[cfg(feature = "flashlight-off")]
+pub use flashlight_off::*;
+#[cfg(feature = "flask-conical")]
+pub use flask_conical::*;
+#[cfg(feature = "flask-conical-off")]
+pub use flask_conical_off::*;
+#[cfg(feature = "flask-round")]
+pub use flask_round::*;
+#[cfg(feature = "flip-horizontal")]
+pub use flip_horizontal::*;
+#[cfg(feature = "flip-horizontal-2")]
+pub use flip_horizontal_2::*;
+#[cfg(feature = "flip-vertical")]
+pub use flip_vertical::*;
+#[cfg(feature = "flip-vertical-2")]
+pub use flip_vertical_2::*;
+#[cfg(feature = "flower")]
+pub use flower::*;
+#[cfg(feature = "flower-2")]
+pub use flower_2::*;
+#[cfg(feature = "focus")]
+pub use focus::*;
+#[cfg(feature = "fold-horizontal")]
+pub use fold_horizontal::*;
+#[cfg(feature = "fold-vertical")]
+pub use fold_vertical::*;
+#[cfg(feature = "folder")]
+pub use folder::*;
+#[cfg(feature = "folder-archive")]
+pub use folder_archive::*;
+#[cfg(feature = "folder-check")]
+pub use folder_check::*;
+#[cfg(feature = "folder-clock")]
+pub use folder_clock::*;
+#[cfg(feature = "folder-closed")]
+pub use folder_closed::*;
+#[cfg(feature = "folder-code")]
+pub use folder_code::*;
+#[cfg(feature = "folder-cog")]
+pub use folder_cog::*;
+#[cfg(feature = "folder-dot")]
+pub use folder_dot::*;
+#[cfg(feature = "folder-down")]
+pub use folder_down::*;
+#[cfg(feature = "folder-git")]
+pub use folder_git::*;
+#[cfg(feature = "folder-git-2")]
+pub use folder_git_2::*;
+#[cfg(feature = "folder-heart")]
+pub use folder_heart::*;
+#[cfg(feature = "folder-input")]
+pub use folder_input::*;
+#[cfg(feature = "folder-kanban")]
+pub use folder_kanban::*;
+#[cfg(feature = "folder-key")]
+pub use folder_key::*;
+#[cfg(feature = "folder-lock")]
+pub use folder_lock::*;
+#[cfg(feature = "folder-minus")]
+pub use folder_minus::*;
+#[cfg(feature = "folder-open")]
+pub use folder_open::*;
+#[cfg(feature = "folder-open-dot")]
+pub use folder_open_dot::*;
+#[cfg(feature = "folder-output")]
+pub use folder_output::*;
+#[cfg(feature = "folder-pen")]
+pub use folder_pen::*;
+#[cfg(feature = "folder-plus")]
+pub use folder_plus::*;
+#[cfg(feature = "folder-root")]
+pub use folder_root::*;
+#[cfg(feature = "folder-search")]
+pub use folder_search::*;
+#[cfg(feature = "folder-search-2")]
+pub use folder_search_2::*;
+#[cfg(feature = "folder-symlink")]
+pub use folder_symlink::*;
+#[cfg(feature = "folder-sync")]
+pub use folder_sync::*;
+#[cfg(feature = "folder-tree")]
+pub use folder_tree::*;
+#[cfg(feature = "folder-up")]
+pub use folder_up::*;
+#[cfg(feature = "folder-x")]
+pub use folder_x::*;
+#[cfg(feature = "folders")]
+pub use folders::*;
+#[cfg(feature = "footprints")]
+pub use footprints::*;
+#[cfg(feature = "forklift")]
+pub use forklift::*;
+#[cfg(feature = "forward")]
+pub use forward::*;
+#[cfg(feature = "frame")]
+pub use frame::*;
+#[cfg(feature = "framer")]
+pub use framer::*;
+#[cfg(feature = "frown")]
+pub use frown::*;
+#[cfg(feature = "fuel")]
+pub use fuel::*;
+#[cfg(feature = "fullscreen")]
+pub use fullscreen::*;
+#[cfg(feature = "gallery-horizontal")]
+pub use gallery_horizontal::*;
+#[cfg(feature = "gallery-horizontal-end")]
+pub use gallery_horizontal_end::*;
+#[cfg(feature = "gallery-thumbnails")]
+pub use gallery_thumbnails::*;
+#[cfg(feature = "gallery-vertical")]
+pub use gallery_vertical::*;
+#[cfg(feature = "gallery-vertical-end")]
+pub use gallery_vertical_end::*;
+#[cfg(feature = "gamepad")]
+pub use gamepad::*;
+#[cfg(feature = "gamepad-2")]
+pub use gamepad_2::*;
+#[cfg(feature = "gauge")]
+pub use gauge::*;
+#[cfg(feature = "gavel")]
+pub use gavel::*;
+#[cfg(feature = "gem")]
+pub use gem::*;
+#[cfg(feature = "ghost")]
+pub use ghost::*;
+#[cfg(feature = "gift")]
+pub use gift::*;
+#[cfg(feature = "git-branch")]
+pub use git_branch::*;
+#[cfg(feature = "git-branch-plus")]
+pub use git_branch_plus::*;
+#[cfg(feature = "git-commit-horizontal")]
+pub use git_commit_horizontal::*;
+#[cfg(feature = "git-commit-vertical")]
+pub use git_commit_vertical::*;
+#[cfg(feature = "git-compare")]
+pub use git_compare::*;
+#[cfg(feature = "git-compare-arrows")]
+pub use git_compare_arrows::*;
+#[cfg(feature = "git-fork")]
+pub use git_fork::*;
+#[cfg(feature = "git-graph")]
+pub use git_graph::*;
+#[cfg(feature = "git-merge")]
+pub use git_merge::*;
+#[cfg(feature = "git-pull-request")]
+pub use git_pull_request::*;
+#[cfg(feature = "git-pull-request-arrow")]
+pub use git_pull_request_arrow::*;
+#[cfg(feature = "git-pull-request-closed")]
+pub use git_pull_request_closed::*;
+#[cfg(feature = "git-pull-request-create")]
+pub use git_pull_request_create::*;
+#[cfg(feature = "git-pull-request-create-arrow")]
+pub use git_pull_request_create_arrow::*;
+#[cfg(feature = "git-pull-request-draft")]
+pub use git_pull_request_draft::*;
+#[cfg(feature = "github")]
+pub use github::*;
+#[cfg(feature = "gitlab")]
+pub use gitlab::*;
+#[cfg(feature = "glass-water")]
+pub use glass_water::*;
+#[cfg(feature = "glasses")]
+pub use glasses::*;
+#[cfg(feature = "globe")]
+pub use globe::*;
+#[cfg(feature = "globe-lock")]
+pub use globe_lock::*;
+#[cfg(feature = "goal")]
+pub use goal::*;
+#[cfg(feature = "grab")]
+pub use grab::*;
+#[cfg(feature = "graduation-cap")]
+pub use graduation_cap::*;
+#[cfg(feature = "grape")]
+pub use grape::*;
+#[cfg(feature = "grid-2-x-2")]
+pub use grid_2_x_2::*;
+#[cfg(feature = "grid-2-x-2-check")]
+pub use grid_2_x_2_check::*;
+#[cfg(feature = "grid-2-x-2-plus")]
+pub use grid_2_x_2_plus::*;
+#[cfg(feature = "grid-2-x-2-x")]
+pub use grid_2_x_2_x::*;
+#[cfg(feature = "grid-3-x-3")]
+pub use grid_3_x_3::*;
+#[cfg(feature = "grip")]
+pub use grip::*;
+#[cfg(feature = "grip-horizontal")]
+pub use grip_horizontal::*;
+#[cfg(feature = "grip-vertical")]
+pub use grip_vertical::*;
+#[cfg(feature = "group")]
+pub use group::*;
+#[cfg(feature = "guitar")]
+pub use guitar::*;
+#[cfg(feature = "ham")]
+pub use ham::*;
+#[cfg(feature = "hammer")]
+pub use hammer::*;
+#[cfg(feature = "hand")]
+pub use hand::*;
+#[cfg(feature = "hand-coins")]
+pub use hand_coins::*;
+#[cfg(feature = "hand-heart")]
+pub use hand_heart::*;
+#[cfg(feature = "hand-helping")]
+pub use hand_helping::*;
+#[cfg(feature = "hand-metal")]
+pub use hand_metal::*;
+#[cfg(feature = "hand-platter")]
+pub use hand_platter::*;
+#[cfg(feature = "handshake")]
+pub use handshake::*;
+#[cfg(feature = "hard-drive")]
+pub use hard_drive::*;
+#[cfg(feature = "hard-drive-download")]
+pub use hard_drive_download::*;
+#[cfg(feature = "hard-drive-upload")]
+pub use hard_drive_upload::*;
+#[cfg(feature = "hard-hat")]
+pub use hard_hat::*;
+#[cfg(feature = "hash")]
+pub use hash::*;
+#[cfg(feature = "haze")]
+pub use haze::*;
+#[cfg(feature = "hdmi-port")]
+pub use hdmi_port::*;
+#[cfg(feature = "heading")]
+pub use heading::*;
+#[cfg(feature = "heading-1")]
+pub use heading_1::*;
+#[cfg(feature = "heading-2")]
+pub use heading_2::*;
+#[cfg(feature = "heading-3")]
+pub use heading_3::*;
+#[cfg(feature = "heading-4")]
+pub use heading_4::*;
+#[cfg(feature = "heading-5")]
+pub use heading_5::*;
+#[cfg(feature = "heading-6")]
+pub use heading_6::*;
+#[cfg(feature = "headphone-off")]
+pub use headphone_off::*;
+#[cfg(feature = "headphones")]
+pub use headphones::*;
+#[cfg(feature = "headset")]
+pub use headset::*;
+#[cfg(feature = "heart")]
+pub use heart::*;
+#[cfg(feature = "heart-crack")]
+pub use heart_crack::*;
+#[cfg(feature = "heart-handshake")]
+pub use heart_handshake::*;
+#[cfg(feature = "heart-off")]
+pub use heart_off::*;
+#[cfg(feature = "heart-pulse")]
+pub use heart_pulse::*;
+#[cfg(feature = "heater")]
+pub use heater::*;
+#[cfg(feature = "hexagon")]
+pub use hexagon::*;
+#[cfg(feature = "highlighter")]
+pub use highlighter::*;
+#[cfg(feature = "history")]
+pub use history::*;
+#[cfg(feature = "hop")]
+pub use hop::*;
+#[cfg(feature = "hop-off")]
+pub use hop_off::*;
+#[cfg(feature = "hospital")]
+pub use hospital::*;
+#[cfg(feature = "hotel")]
+pub use hotel::*;
+#[cfg(feature = "hourglass")]
+pub use hourglass::*;
+#[cfg(feature = "house")]
+pub use house::*;
+#[cfg(feature = "house-plug")]
+pub use house_plug::*;
+#[cfg(feature = "house-plus")]
+pub use house_plus::*;
+#[cfg(feature = "ice-cream-bowl")]
+pub use ice_cream_bowl::*;
+#[cfg(feature = "ice-cream-cone")]
+pub use ice_cream_cone::*;
+#[cfg(feature = "id-card")]
+pub use id_card::*;
+#[cfg(feature = "image")]
+pub use image::*;
+#[cfg(feature = "image-down")]
+pub use image_down::*;
+#[cfg(feature = "image-minus")]
+pub use image_minus::*;
+#[cfg(feature = "image-off")]
+pub use image_off::*;
+#[cfg(feature = "image-play")]
+pub use image_play::*;
+#[cfg(feature = "image-plus")]
+pub use image_plus::*;
+#[cfg(feature = "image-up")]
+pub use image_up::*;
+#[cfg(feature = "images")]
+pub use images::*;
+#[cfg(feature = "import")]
+pub use import::*;
+#[cfg(feature = "inbox")]
+pub use inbox::*;
+#[cfg(feature = "indent-decrease")]
+pub use indent_decrease::*;
+#[cfg(feature = "indent-increase")]
+pub use indent_increase::*;
+#[cfg(feature = "indian-rupee")]
+pub use indian_rupee::*;
+#[cfg(feature = "infinity")]
+pub use infinity::*;
+#[cfg(feature = "info")]
+pub use info::*;
+#[cfg(feature = "inspection-panel")]
+pub use inspection_panel::*;
+#[cfg(feature = "instagram")]
+pub use instagram::*;
+#[cfg(feature = "italic")]
+pub use italic::*;
+#[cfg(feature = "iteration-ccw")]
+pub use iteration_ccw::*;
+#[cfg(feature = "iteration-cw")]
+pub use iteration_cw::*;
+#[cfg(feature = "japanese-yen")]
+pub use japanese_yen::*;
+#[cfg(feature = "joystick")]
+pub use joystick::*;
+#[cfg(feature = "kanban")]
+pub use kanban::*;
+#[cfg(feature = "key")]
+pub use key::*;
+#[cfg(feature = "key-round")]
+pub use key_round::*;
+#[cfg(feature = "key-square")]
+pub use key_square::*;
+#[cfg(feature = "keyboard")]
+pub use keyboard::*;
+#[cfg(feature = "keyboard-music")]
+pub use keyboard_music::*;
+#[cfg(feature = "keyboard-off")]
+pub use keyboard_off::*;
+#[cfg(feature = "lamp")]
+pub use lamp::*;
+#[cfg(feature = "lamp-ceiling")]
+pub use lamp_ceiling::*;
+#[cfg(feature = "lamp-desk")]
+pub use lamp_desk::*;
+#[cfg(feature = "lamp-floor")]
+pub use lamp_floor::*;
+#[cfg(feature = "lamp-wall-down")]
+pub use lamp_wall_down::*;
+#[cfg(feature = "lamp-wall-up")]
+pub use lamp_wall_up::*;
+#[cfg(feature = "land-plot")]
+pub use land_plot::*;
+#[cfg(feature = "landmark")]
+pub use landmark::*;
+#[cfg(feature = "languages")]
+pub use languages::*;
+#[cfg(feature = "laptop")]
+pub use laptop::*;
+#[cfg(feature = "laptop-minimal")]
+pub use laptop_minimal::*;
+#[cfg(feature = "laptop-minimal-check")]
+pub use laptop_minimal_check::*;
+#[cfg(feature = "lasso")]
+pub use lasso::*;
+#[cfg(feature = "lasso-select")]
+pub use lasso_select::*;
+#[cfg(feature = "laugh")]
+pub use laugh::*;
+#[cfg(feature = "layers")]
+pub use layers::*;
+#[cfg(feature = "layers-2")]
+pub use layers_2::*;
+#[cfg(feature = "layers-3")]
+pub use layers_3::*;
+#[cfg(feature = "layout-dashboard")]
+pub use layout_dashboard::*;
+#[cfg(feature = "layout-grid")]
+pub use layout_grid::*;
+#[cfg(feature = "layout-list")]
+pub use layout_list::*;
+#[cfg(feature = "layout-panel-left")]
+pub use layout_panel_left::*;
+#[cfg(feature = "layout-panel-top")]
+pub use layout_panel_top::*;
+#[cfg(feature = "layout-template")]
+pub use layout_template::*;
+#[cfg(feature = "leaf")]
+pub use leaf::*;
+#[cfg(feature = "leafy-green")]
+pub use leafy_green::*;
+#[cfg(feature = "lectern")]
+pub use lectern::*;
+#[cfg(feature = "letter-text")]
+pub use letter_text::*;
+#[cfg(feature = "library")]
+pub use library::*;
+#[cfg(feature = "library-big")]
+pub use library_big::*;
+#[cfg(feature = "life-buoy")]
+pub use life_buoy::*;
+#[cfg(feature = "ligature")]
+pub use ligature::*;
+#[cfg(feature = "lightbulb")]
+pub use lightbulb::*;
+#[cfg(feature = "lightbulb-off")]
+pub use lightbulb_off::*;
+#[cfg(feature = "link")]
+pub use link::*;
+#[cfg(feature = "link-2")]
+pub use link_2::*;
+#[cfg(feature = "link-2-off")]
+pub use link_2_off::*;
+#[cfg(feature = "linkedin")]
+pub use linkedin::*;
+#[cfg(feature = "list")]
+pub use list::*;
+#[cfg(feature = "list-check")]
+pub use list_check::*;
+#[cfg(feature = "list-checks")]
+pub use list_checks::*;
+#[cfg(feature = "list-collapse")]
+pub use list_collapse::*;
+#[cfg(feature = "list-end")]
+pub use list_end::*;
+#[cfg(feature = "list-filter")]
+pub use list_filter::*;
+#[cfg(feature = "list-minus")]
+pub use list_minus::*;
+#[cfg(feature = "list-music")]
+pub use list_music::*;
+#[cfg(feature = "list-ordered")]
+pub use list_ordered::*;
+#[cfg(feature = "list-plus")]
+pub use list_plus::*;
+#[cfg(feature = "list-restart")]
+pub use list_restart::*;
+#[cfg(feature = "list-start")]
+pub use list_start::*;
+#[cfg(feature = "list-todo")]
+pub use list_todo::*;
+#[cfg(feature = "list-tree")]
+pub use list_tree::*;
+#[cfg(feature = "list-video")]
+pub use list_video::*;
+#[cfg(feature = "list-x")]
+pub use list_x::*;
+#[cfg(feature = "loader")]
+pub use loader::*;
+#[cfg(feature = "loader-circle")]
+pub use loader_circle::*;
+#[cfg(feature = "loader-pinwheel")]
+pub use loader_pinwheel::*;
+#[cfg(feature = "locate")]
+pub use locate::*;
+#[cfg(feature = "locate-fixed")]
+pub use locate_fixed::*;
+#[cfg(feature = "locate-off")]
+pub use locate_off::*;
+#[cfg(feature = "lock")]
+pub use lock::*;
+#[cfg(feature = "lock-keyhole")]
+pub use lock_keyhole::*;
+#[cfg(feature = "lock-keyhole-open")]
+pub use lock_keyhole_open::*;
+#[cfg(feature = "lock-open")]
+pub use lock_open::*;
+#[cfg(feature = "log-in")]
+pub use log_in::*;
+#[cfg(feature = "log-out")]
+pub use log_out::*;
+#[cfg(feature = "logs")]
+pub use logs::*;
+#[cfg(feature = "lollipop")]
+pub use lollipop::*;
+#[cfg(feature = "luggage")]
+pub use luggage::*;
+#[cfg(feature = "magnet")]
+pub use magnet::*;
+#[cfg(feature = "mail")]
+pub use mail::*;
+#[cfg(feature = "mail-check")]
+pub use mail_check::*;
+#[cfg(feature = "mail-minus")]
+pub use mail_minus::*;
+#[cfg(feature = "mail-open")]
+pub use mail_open::*;
+#[cfg(feature = "mail-plus")]
+pub use mail_plus::*;
+#[cfg(feature = "mail-question")]
+pub use mail_question::*;
+#[cfg(feature = "mail-search")]
+pub use mail_search::*;
+#[cfg(feature = "mail-warning")]
+pub use mail_warning::*;
+#[cfg(feature = "mail-x")]
+pub use mail_x::*;
+#[cfg(feature = "mailbox")]
+pub use mailbox::*;
+#[cfg(feature = "mails")]
+pub use mails::*;
+#[cfg(feature = "map")]
+pub use map::*;
+#[cfg(feature = "map-pin")]
+pub use map_pin::*;
+#[cfg(feature = "map-pin-check")]
+pub use map_pin_check::*;
+#[cfg(feature = "map-pin-check-inside")]
+pub use map_pin_check_inside::*;
+#[cfg(feature = "map-pin-house")]
+pub use map_pin_house::*;
+#[cfg(feature = "map-pin-minus")]
+pub use map_pin_minus::*;
+#[cfg(feature = "map-pin-minus-inside")]
+pub use map_pin_minus_inside::*;
+#[cfg(feature = "map-pin-off")]
+pub use map_pin_off::*;
+#[cfg(feature = "map-pin-plus")]
+pub use map_pin_plus::*;
+#[cfg(feature = "map-pin-plus-inside")]
+pub use map_pin_plus_inside::*;
+#[cfg(feature = "map-pin-x")]
+pub use map_pin_x::*;
+#[cfg(feature = "map-pin-x-inside")]
+pub use map_pin_x_inside::*;
+#[cfg(feature = "map-pinned")]
+pub use map_pinned::*;
+#[cfg(feature = "martini")]
+pub use martini::*;
+#[cfg(feature = "maximize")]
+pub use maximize::*;
+#[cfg(feature = "maximize-2")]
+pub use maximize_2::*;
+#[cfg(feature = "medal")]
+pub use medal::*;
+#[cfg(feature = "megaphone")]
+pub use megaphone::*;
+#[cfg(feature = "megaphone-off")]
+pub use megaphone_off::*;
+#[cfg(feature = "meh")]
+pub use meh::*;
+#[cfg(feature = "memory-stick")]
+pub use memory_stick::*;
+#[cfg(feature = "menu")]
+pub use menu::*;
+#[cfg(feature = "merge")]
+pub use merge::*;
+#[cfg(feature = "message-circle")]
+pub use message_circle::*;
+#[cfg(feature = "message-circle-code")]
+pub use message_circle_code::*;
+#[cfg(feature = "message-circle-dashed")]
+pub use message_circle_dashed::*;
+#[cfg(feature = "message-circle-heart")]
+pub use message_circle_heart::*;
+#[cfg(feature = "message-circle-more")]
+pub use message_circle_more::*;
+#[cfg(feature = "message-circle-off")]
+pub use message_circle_off::*;
+#[cfg(feature = "message-circle-plus")]
+pub use message_circle_plus::*;
+#[cfg(feature = "message-circle-question")]
+pub use message_circle_question::*;
+#[cfg(feature = "message-circle-reply")]
+pub use message_circle_reply::*;
+#[cfg(feature = "message-circle-warning")]
+pub use message_circle_warning::*;
+#[cfg(feature = "message-circle-x")]
+pub use message_circle_x::*;
+#[cfg(feature = "message-square")]
+pub use message_square::*;
+#[cfg(feature = "message-square-code")]
+pub use message_square_code::*;
+#[cfg(feature = "message-square-dashed")]
+pub use message_square_dashed::*;
+#[cfg(feature = "message-square-diff")]
+pub use message_square_diff::*;
+#[cfg(feature = "message-square-dot")]
+pub use message_square_dot::*;
+#[cfg(feature = "message-square-heart")]
+pub use message_square_heart::*;
+#[cfg(feature = "message-square-lock")]
+pub use message_square_lock::*;
+#[cfg(feature = "message-square-more")]
+pub use message_square_more::*;
+#[cfg(feature = "message-square-off")]
+pub use message_square_off::*;
+#[cfg(feature = "message-square-plus")]
+pub use message_square_plus::*;
+#[cfg(feature = "message-square-quote")]
+pub use message_square_quote::*;
+#[cfg(feature = "message-square-reply")]
+pub use message_square_reply::*;
+#[cfg(feature = "message-square-share")]
+pub use message_square_share::*;
+#[cfg(feature = "message-square-text")]
+pub use message_square_text::*;
+#[cfg(feature = "message-square-warning")]
+pub use message_square_warning::*;
+#[cfg(feature = "message-square-x")]
+pub use message_square_x::*;
+#[cfg(feature = "messages-square")]
+pub use messages_square::*;
+#[cfg(feature = "mic")]
+pub use mic::*;
+#[cfg(feature = "mic-off")]
+pub use mic_off::*;
+#[cfg(feature = "mic-vocal")]
+pub use mic_vocal::*;
+#[cfg(feature = "microchip")]
+pub use microchip::*;
+#[cfg(feature = "microscope")]
+pub use microscope::*;
+#[cfg(feature = "microwave")]
+pub use microwave::*;
+#[cfg(feature = "milestone")]
+pub use milestone::*;
+#[cfg(feature = "milk")]
+pub use milk::*;
+#[cfg(feature = "milk-off")]
+pub use milk_off::*;
+#[cfg(feature = "minimize")]
+pub use minimize::*;
+#[cfg(feature = "minimize-2")]
+pub use minimize_2::*;
+#[cfg(feature = "minus")]
+pub use minus::*;
+#[cfg(feature = "monitor")]
+pub use monitor::*;
+#[cfg(feature = "monitor-check")]
+pub use monitor_check::*;
+#[cfg(feature = "monitor-cog")]
+pub use monitor_cog::*;
+#[cfg(feature = "monitor-dot")]
+pub use monitor_dot::*;
+#[cfg(feature = "monitor-down")]
+pub use monitor_down::*;
+#[cfg(feature = "monitor-off")]
+pub use monitor_off::*;
+#[cfg(feature = "monitor-pause")]
+pub use monitor_pause::*;
+#[cfg(feature = "monitor-play")]
+pub use monitor_play::*;
+#[cfg(feature = "monitor-smartphone")]
+pub use monitor_smartphone::*;
+#[cfg(feature = "monitor-speaker")]
+pub use monitor_speaker::*;
+#[cfg(feature = "monitor-stop")]
+pub use monitor_stop::*;
+#[cfg(feature = "monitor-up")]
+pub use monitor_up::*;
+#[cfg(feature = "monitor-x")]
+pub use monitor_x::*;
+#[cfg(feature = "moon")]
+pub use moon::*;
+#[cfg(feature = "moon-star")]
+pub use moon_star::*;
+#[cfg(feature = "mountain")]
+pub use mountain::*;
+#[cfg(feature = "mountain-snow")]
+pub use mountain_snow::*;
+#[cfg(feature = "mouse")]
+pub use mouse::*;
+#[cfg(feature = "mouse-off")]
+pub use mouse_off::*;
+#[cfg(feature = "mouse-pointer")]
+pub use mouse_pointer::*;
+#[cfg(feature = "mouse-pointer-2")]
+pub use mouse_pointer_2::*;
+#[cfg(feature = "mouse-pointer-ban")]
+pub use mouse_pointer_ban::*;
+#[cfg(feature = "mouse-pointer-click")]
+pub use mouse_pointer_click::*;
+#[cfg(feature = "move-3-d")]
+pub use move_3_d::*;
+#[cfg(feature = "move-diagonal")]
+pub use move_diagonal::*;
+#[cfg(feature = "move-diagonal-2")]
+pub use move_diagonal_2::*;
+#[cfg(feature = "move-down")]
+pub use move_down::*;
+#[cfg(feature = "move-down-left")]
+pub use move_down_left::*;
+#[cfg(feature = "move-down-right")]
+pub use move_down_right::*;
+#[cfg(feature = "move-horizontal")]
+pub use move_horizontal::*;
+#[cfg(feature = "move-left")]
+pub use move_left::*;
+#[cfg(feature = "move-right")]
+pub use move_right::*;
+#[cfg(feature = "move-up")]
+pub use move_up::*;
+#[cfg(feature = "move-up-left")]
+pub use move_up_left::*;
+#[cfg(feature = "move-up-right")]
+pub use move_up_right::*;
+#[cfg(feature = "move-vertical")]
+pub use move_vertical::*;
+#[cfg(feature = "music")]
+pub use music::*;
+#[cfg(feature = "music-2")]
+pub use music_2::*;
+#[cfg(feature = "music-3")]
+pub use music_3::*;
+#[cfg(feature = "music-4")]
+pub use music_4::*;
+#[cfg(feature = "navigation")]
+pub use navigation::*;
+#[cfg(feature = "navigation-2")]
+pub use navigation_2::*;
+#[cfg(feature = "navigation-2-off")]
+pub use navigation_2_off::*;
+#[cfg(feature = "navigation-off")]
+pub use navigation_off::*;
+#[cfg(feature = "network")]
+pub use network::*;
+#[cfg(feature = "newspaper")]
+pub use newspaper::*;
+#[cfg(feature = "nfc")]
+pub use nfc::*;
+#[cfg(feature = "notebook")]
+pub use notebook::*;
+#[cfg(feature = "notebook-pen")]
+pub use notebook_pen::*;
+#[cfg(feature = "notebook-tabs")]
+pub use notebook_tabs::*;
+#[cfg(feature = "notebook-text")]
+pub use notebook_text::*;
+#[cfg(feature = "notepad-text")]
+pub use notepad_text::*;
+#[cfg(feature = "notepad-text-dashed")]
+pub use notepad_text_dashed::*;
+#[cfg(feature = "nut")]
+pub use nut::*;
+#[cfg(feature = "nut-off")]
+pub use nut_off::*;
+#[cfg(feature = "octagon")]
+pub use octagon::*;
+#[cfg(feature = "octagon-alert")]
+pub use octagon_alert::*;
+#[cfg(feature = "octagon-minus")]
+pub use octagon_minus::*;
+#[cfg(feature = "octagon-pause")]
+pub use octagon_pause::*;
+#[cfg(feature = "octagon-x")]
+pub use octagon_x::*;
+#[cfg(feature = "omega")]
+pub use omega::*;
+#[cfg(feature = "option")]
+pub use option::*;
+#[cfg(feature = "orbit")]
+pub use orbit::*;
+#[cfg(feature = "origami")]
+pub use origami::*;
+#[cfg(feature = "package")]
+pub use package::*;
+#[cfg(feature = "package-2")]
+pub use package_2::*;
+#[cfg(feature = "package-check")]
+pub use package_check::*;
+#[cfg(feature = "package-minus")]
+pub use package_minus::*;
+#[cfg(feature = "package-open")]
+pub use package_open::*;
+#[cfg(feature = "package-plus")]
+pub use package_plus::*;
+#[cfg(feature = "package-search")]
+pub use package_search::*;
+#[cfg(feature = "package-x")]
+pub use package_x::*;
+#[cfg(feature = "paint-bucket")]
+pub use paint_bucket::*;
+#[cfg(feature = "paint-roller")]
+pub use paint_roller::*;
+#[cfg(feature = "paintbrush")]
+pub use paintbrush::*;
+#[cfg(feature = "paintbrush-vertical")]
+pub use paintbrush_vertical::*;
+#[cfg(feature = "palette")]
+pub use palette::*;
+#[cfg(feature = "panel-bottom")]
+pub use panel_bottom::*;
+#[cfg(feature = "panel-bottom-close")]
+pub use panel_bottom_close::*;
+#[cfg(feature = "panel-bottom-dashed")]
+pub use panel_bottom_dashed::*;
+#[cfg(feature = "panel-bottom-open")]
+pub use panel_bottom_open::*;
+#[cfg(feature = "panel-left")]
+pub use panel_left::*;
+#[cfg(feature = "panel-left-close")]
+pub use panel_left_close::*;
+#[cfg(feature = "panel-left-dashed")]
+pub use panel_left_dashed::*;
+#[cfg(feature = "panel-left-open")]
+pub use panel_left_open::*;
+#[cfg(feature = "panel-right")]
+pub use panel_right::*;
+#[cfg(feature = "panel-right-close")]
+pub use panel_right_close::*;
+#[cfg(feature = "panel-right-dashed")]
+pub use panel_right_dashed::*;
+#[cfg(feature = "panel-right-open")]
+pub use panel_right_open::*;
+#[cfg(feature = "panel-top")]
+pub use panel_top::*;
+#[cfg(feature = "panel-top-close")]
+pub use panel_top_close::*;
+#[cfg(feature = "panel-top-dashed")]
+pub use panel_top_dashed::*;
+#[cfg(feature = "panel-top-open")]
+pub use panel_top_open::*;
+#[cfg(feature = "panels-left-bottom")]
+pub use panels_left_bottom::*;
+#[cfg(feature = "panels-right-bottom")]
+pub use panels_right_bottom::*;
+#[cfg(feature = "panels-top-left")]
+pub use panels_top_left::*;
+#[cfg(feature = "paperclip")]
+pub use paperclip::*;
+#[cfg(feature = "parentheses")]
+pub use parentheses::*;
+#[cfg(feature = "parking-meter")]
+pub use parking_meter::*;
+#[cfg(feature = "party-popper")]
+pub use party_popper::*;
+#[cfg(feature = "pause")]
+pub use pause::*;
+#[cfg(feature = "paw-print")]
+pub use paw_print::*;
+#[cfg(feature = "pc-case")]
+pub use pc_case::*;
+#[cfg(feature = "pen")]
+pub use pen::*;
+#[cfg(feature = "pen-line")]
+pub use pen_line::*;
+#[cfg(feature = "pen-off")]
+pub use pen_off::*;
+#[cfg(feature = "pen-tool")]
+pub use pen_tool::*;
+#[cfg(feature = "pencil")]
+pub use pencil::*;
+#[cfg(feature = "pencil-line")]
+pub use pencil_line::*;
+#[cfg(feature = "pencil-off")]
+pub use pencil_off::*;
+#[cfg(feature = "pencil-ruler")]
+pub use pencil_ruler::*;
+#[cfg(feature = "pentagon")]
+pub use pentagon::*;
+#[cfg(feature = "percent")]
+pub use percent::*;
+#[cfg(feature = "person-standing")]
+pub use person_standing::*;
+#[cfg(feature = "philippine-peso")]
+pub use philippine_peso::*;
+#[cfg(feature = "phone")]
+pub use phone::*;
+#[cfg(feature = "phone-call")]
+pub use phone_call::*;
+#[cfg(feature = "phone-forwarded")]
+pub use phone_forwarded::*;
+#[cfg(feature = "phone-incoming")]
+pub use phone_incoming::*;
+#[cfg(feature = "phone-missed")]
+pub use phone_missed::*;
+#[cfg(feature = "phone-off")]
+pub use phone_off::*;
+#[cfg(feature = "phone-outgoing")]
+pub use phone_outgoing::*;
+#[cfg(feature = "pi")]
+pub use pi::*;
+#[cfg(feature = "piano")]
+pub use piano::*;
+#[cfg(feature = "pickaxe")]
+pub use pickaxe::*;
+#[cfg(feature = "picture-in-picture")]
+pub use picture_in_picture::*;
+#[cfg(feature = "picture-in-picture-2")]
+pub use picture_in_picture_2::*;
+#[cfg(feature = "piggy-bank")]
+pub use piggy_bank::*;
+#[cfg(feature = "pilcrow")]
+pub use pilcrow::*;
+#[cfg(feature = "pilcrow-left")]
+pub use pilcrow_left::*;
+#[cfg(feature = "pilcrow-right")]
+pub use pilcrow_right::*;
+#[cfg(feature = "pill")]
+pub use pill::*;
+#[cfg(feature = "pill-bottle")]
+pub use pill_bottle::*;
+#[cfg(feature = "pin")]
+pub use pin::*;
+#[cfg(feature = "pin-off")]
+pub use pin_off::*;
+#[cfg(feature = "pipette")]
+pub use pipette::*;
+#[cfg(feature = "pizza")]
+pub use pizza::*;
+#[cfg(feature = "plane")]
+pub use plane::*;
+#[cfg(feature = "plane-landing")]
+pub use plane_landing::*;
+#[cfg(feature = "plane-takeoff")]
+pub use plane_takeoff::*;
+#[cfg(feature = "play")]
+pub use play::*;
+#[cfg(feature = "plug")]
+pub use plug::*;
+#[cfg(feature = "plug-2")]
+pub use plug_2::*;
+#[cfg(feature = "plug-zap")]
+pub use plug_zap::*;
+#[cfg(feature = "plus")]
+pub use plus::*;
+#[cfg(feature = "pocket")]
+pub use pocket::*;
+#[cfg(feature = "pocket-knife")]
+pub use pocket_knife::*;
+#[cfg(feature = "podcast")]
+pub use podcast::*;
+#[cfg(feature = "pointer")]
+pub use pointer::*;
+#[cfg(feature = "pointer-off")]
+pub use pointer_off::*;
+#[cfg(feature = "popcorn")]
+pub use popcorn::*;
+#[cfg(feature = "popsicle")]
+pub use popsicle::*;
+#[cfg(feature = "pound-sterling")]
+pub use pound_sterling::*;
+#[cfg(feature = "power")]
+pub use power::*;
+#[cfg(feature = "power-off")]
+pub use power_off::*;
+#[cfg(feature = "presentation")]
+pub use presentation::*;
+#[cfg(feature = "printer")]
+pub use printer::*;
+#[cfg(feature = "printer-check")]
+pub use printer_check::*;
+#[cfg(feature = "projector")]
+pub use projector::*;
+#[cfg(feature = "proportions")]
+pub use proportions::*;
+#[cfg(feature = "puzzle")]
+pub use puzzle::*;
+#[cfg(feature = "pyramid")]
+pub use pyramid::*;
+#[cfg(feature = "qr-code")]
+pub use qr_code::*;
+#[cfg(feature = "quote")]
+pub use quote::*;
+#[cfg(feature = "box")]
+pub use r#box::*;
+#[cfg(feature = "move")]
+pub use r#move::*;
+#[cfg(feature = "type")]
+pub use r#type::*;
+#[cfg(feature = "rabbit")]
+pub use rabbit::*;
+#[cfg(feature = "radar")]
+pub use radar::*;
+#[cfg(feature = "radiation")]
+pub use radiation::*;
+#[cfg(feature = "radical")]
+pub use radical::*;
+#[cfg(feature = "radio")]
+pub use radio::*;
+#[cfg(feature = "radio-receiver")]
+pub use radio_receiver::*;
+#[cfg(feature = "radio-tower")]
+pub use radio_tower::*;
+#[cfg(feature = "radius")]
+pub use radius::*;
+#[cfg(feature = "rail-symbol")]
+pub use rail_symbol::*;
+#[cfg(feature = "rainbow")]
+pub use rainbow::*;
+#[cfg(feature = "rat")]
+pub use rat::*;
+#[cfg(feature = "ratio")]
+pub use ratio::*;
+#[cfg(feature = "receipt")]
+pub use receipt::*;
+#[cfg(feature = "receipt-cent")]
+pub use receipt_cent::*;
+#[cfg(feature = "receipt-euro")]
+pub use receipt_euro::*;
+#[cfg(feature = "receipt-indian-rupee")]
+pub use receipt_indian_rupee::*;
+#[cfg(feature = "receipt-japanese-yen")]
+pub use receipt_japanese_yen::*;
+#[cfg(feature = "receipt-pound-sterling")]
+pub use receipt_pound_sterling::*;
+#[cfg(feature = "receipt-russian-ruble")]
+pub use receipt_russian_ruble::*;
+#[cfg(feature = "receipt-swiss-franc")]
+pub use receipt_swiss_franc::*;
+#[cfg(feature = "receipt-text")]
+pub use receipt_text::*;
+#[cfg(feature = "rectangle-ellipsis")]
+pub use rectangle_ellipsis::*;
+#[cfg(feature = "rectangle-horizontal")]
+pub use rectangle_horizontal::*;
+#[cfg(feature = "rectangle-vertical")]
+pub use rectangle_vertical::*;
+#[cfg(feature = "recycle")]
+pub use recycle::*;
+#[cfg(feature = "redo")]
+pub use redo::*;
+#[cfg(feature = "redo-2")]
+pub use redo_2::*;
+#[cfg(feature = "redo-dot")]
+pub use redo_dot::*;
+#[cfg(feature = "refresh-ccw")]
+pub use refresh_ccw::*;
+#[cfg(feature = "refresh-ccw-dot")]
+pub use refresh_ccw_dot::*;
+#[cfg(feature = "refresh-cw")]
+pub use refresh_cw::*;
+#[cfg(feature = "refresh-cw-off")]
+pub use refresh_cw_off::*;
+#[cfg(feature = "refrigerator")]
+pub use refrigerator::*;
+#[cfg(feature = "regex")]
+pub use regex::*;
+#[cfg(feature = "remove-formatting")]
+pub use remove_formatting::*;
+#[cfg(feature = "repeat")]
+pub use repeat::*;
+#[cfg(feature = "repeat-1")]
+pub use repeat_1::*;
+#[cfg(feature = "repeat-2")]
+pub use repeat_2::*;
+#[cfg(feature = "replace")]
+pub use replace::*;
+#[cfg(feature = "replace-all")]
+pub use replace_all::*;
+#[cfg(feature = "reply")]
+pub use reply::*;
+#[cfg(feature = "reply-all")]
+pub use reply_all::*;
+#[cfg(feature = "rewind")]
+pub use rewind::*;
+#[cfg(feature = "ribbon")]
+pub use ribbon::*;
+#[cfg(feature = "rocket")]
+pub use rocket::*;
+#[cfg(feature = "rocking-chair")]
+pub use rocking_chair::*;
+#[cfg(feature = "roller-coaster")]
+pub use roller_coaster::*;
+#[cfg(feature = "rotate-3-d")]
+pub use rotate_3_d::*;
+#[cfg(feature = "rotate-ccw")]
+pub use rotate_ccw::*;
+#[cfg(feature = "rotate-ccw-square")]
+pub use rotate_ccw_square::*;
+#[cfg(feature = "rotate-cw")]
+pub use rotate_cw::*;
+#[cfg(feature = "rotate-cw-square")]
+pub use rotate_cw_square::*;
+#[cfg(feature = "route")]
+pub use route::*;
+#[cfg(feature = "route-off")]
+pub use route_off::*;
+#[cfg(feature = "router")]
+pub use router::*;
+#[cfg(feature = "rows-2")]
+pub use rows_2::*;
+#[cfg(feature = "rows-3")]
+pub use rows_3::*;
+#[cfg(feature = "rows-4")]
+pub use rows_4::*;
+#[cfg(feature = "rss")]
+pub use rss::*;
+#[cfg(feature = "ruler")]
+pub use ruler::*;
+#[cfg(feature = "russian-ruble")]
+pub use russian_ruble::*;
+#[cfg(feature = "sailboat")]
+pub use sailboat::*;
+#[cfg(feature = "salad")]
+pub use salad::*;
+#[cfg(feature = "sandwich")]
+pub use sandwich::*;
+#[cfg(feature = "satellite")]
+pub use satellite::*;
+#[cfg(feature = "satellite-dish")]
+pub use satellite_dish::*;
+#[cfg(feature = "save")]
+pub use save::*;
+#[cfg(feature = "save-all")]
+pub use save_all::*;
+#[cfg(feature = "save-off")]
+pub use save_off::*;
+#[cfg(feature = "scale")]
+pub use scale::*;
+#[cfg(feature = "scale-3-d")]
+pub use scale_3_d::*;
+#[cfg(feature = "scaling")]
+pub use scaling::*;
+#[cfg(feature = "scan")]
+pub use scan::*;
+#[cfg(feature = "scan-barcode")]
+pub use scan_barcode::*;
+#[cfg(feature = "scan-eye")]
+pub use scan_eye::*;
+#[cfg(feature = "scan-face")]
+pub use scan_face::*;
+#[cfg(feature = "scan-line")]
+pub use scan_line::*;
+#[cfg(feature = "scan-qr-code")]
+pub use scan_qr_code::*;
+#[cfg(feature = "scan-search")]
+pub use scan_search::*;
+#[cfg(feature = "scan-text")]
+pub use scan_text::*;
+#[cfg(feature = "school")]
+pub use school::*;
+#[cfg(feature = "scissors")]
+pub use scissors::*;
+#[cfg(feature = "scissors-line-dashed")]
+pub use scissors_line_dashed::*;
+#[cfg(feature = "screen-share")]
+pub use screen_share::*;
+#[cfg(feature = "screen-share-off")]
+pub use screen_share_off::*;
+#[cfg(feature = "scroll")]
+pub use scroll::*;
+#[cfg(feature = "scroll-text")]
+pub use scroll_text::*;
+#[cfg(feature = "search")]
+pub use search::*;
+#[cfg(feature = "search-check")]
+pub use search_check::*;
+#[cfg(feature = "search-code")]
+pub use search_code::*;
+#[cfg(feature = "search-slash")]
+pub use search_slash::*;
+#[cfg(feature = "search-x")]
+pub use search_x::*;
+#[cfg(feature = "section")]
+pub use section::*;
+#[cfg(feature = "send")]
+pub use send::*;
+#[cfg(feature = "send-horizontal")]
+pub use send_horizontal::*;
+#[cfg(feature = "send-to-back")]
+pub use send_to_back::*;
+#[cfg(feature = "separator-horizontal")]
+pub use separator_horizontal::*;
+#[cfg(feature = "separator-vertical")]
+pub use separator_vertical::*;
+#[cfg(feature = "server")]
+pub use server::*;
+#[cfg(feature = "server-cog")]
+pub use server_cog::*;
+#[cfg(feature = "server-crash")]
+pub use server_crash::*;
+#[cfg(feature = "server-off")]
+pub use server_off::*;
+#[cfg(feature = "settings")]
+pub use settings::*;
+#[cfg(feature = "settings-2")]
+pub use settings_2::*;
+#[cfg(feature = "shapes")]
+pub use shapes::*;
+#[cfg(feature = "share")]
+pub use share::*;
+#[cfg(feature = "share-2")]
+pub use share_2::*;
+#[cfg(feature = "sheet")]
+pub use sheet::*;
+#[cfg(feature = "shell")]
+pub use shell::*;
+#[cfg(feature = "shield")]
+pub use shield::*;
+#[cfg(feature = "shield-alert")]
+pub use shield_alert::*;
+#[cfg(feature = "shield-ban")]
+pub use shield_ban::*;
+#[cfg(feature = "shield-check")]
+pub use shield_check::*;
+#[cfg(feature = "shield-ellipsis")]
+pub use shield_ellipsis::*;
+#[cfg(feature = "shield-half")]
+pub use shield_half::*;
+#[cfg(feature = "shield-minus")]
+pub use shield_minus::*;
+#[cfg(feature = "shield-off")]
+pub use shield_off::*;
+#[cfg(feature = "shield-plus")]
+pub use shield_plus::*;
+#[cfg(feature = "shield-question")]
+pub use shield_question::*;
+#[cfg(feature = "shield-x")]
+pub use shield_x::*;
+#[cfg(feature = "ship")]
+pub use ship::*;
+#[cfg(feature = "ship-wheel")]
+pub use ship_wheel::*;
+#[cfg(feature = "shirt")]
+pub use shirt::*;
+#[cfg(feature = "shopping-bag")]
+pub use shopping_bag::*;
+#[cfg(feature = "shopping-basket")]
+pub use shopping_basket::*;
+#[cfg(feature = "shopping-cart")]
+pub use shopping_cart::*;
+#[cfg(feature = "shovel")]
+pub use shovel::*;
+#[cfg(feature = "shower-head")]
+pub use shower_head::*;
+#[cfg(feature = "shrink")]
+pub use shrink::*;
+#[cfg(feature = "shrub")]
+pub use shrub::*;
+#[cfg(feature = "shuffle")]
+pub use shuffle::*;
+#[cfg(feature = "sigma")]
+pub use sigma::*;
+#[cfg(feature = "signal")]
+pub use signal::*;
+#[cfg(feature = "signal-high")]
+pub use signal_high::*;
+#[cfg(feature = "signal-low")]
+pub use signal_low::*;
+#[cfg(feature = "signal-medium")]
+pub use signal_medium::*;
+#[cfg(feature = "signal-zero")]
+pub use signal_zero::*;
+#[cfg(feature = "signature")]
+pub use signature::*;
+#[cfg(feature = "signpost")]
+pub use signpost::*;
+#[cfg(feature = "signpost-big")]
+pub use signpost_big::*;
+#[cfg(feature = "siren")]
+pub use siren::*;
+#[cfg(feature = "skip-back")]
+pub use skip_back::*;
+#[cfg(feature = "skip-forward")]
+pub use skip_forward::*;
+#[cfg(feature = "skull")]
+pub use skull::*;
+#[cfg(feature = "slack")]
+pub use slack::*;
+#[cfg(feature = "slash")]
+pub use slash::*;
+#[cfg(feature = "slice")]
+pub use slice::*;
+#[cfg(feature = "sliders-horizontal")]
+pub use sliders_horizontal::*;
+#[cfg(feature = "sliders-vertical")]
+pub use sliders_vertical::*;
+#[cfg(feature = "smartphone")]
+pub use smartphone::*;
+#[cfg(feature = "smartphone-charging")]
+pub use smartphone_charging::*;
+#[cfg(feature = "smartphone-nfc")]
+pub use smartphone_nfc::*;
+#[cfg(feature = "smile")]
+pub use smile::*;
+#[cfg(feature = "smile-plus")]
+pub use smile_plus::*;
+#[cfg(feature = "snail")]
+pub use snail::*;
+#[cfg(feature = "snowflake")]
+pub use snowflake::*;
+#[cfg(feature = "sofa")]
+pub use sofa::*;
+#[cfg(feature = "soup")]
+pub use soup::*;
+#[cfg(feature = "space")]
+pub use space::*;
+#[cfg(feature = "spade")]
+pub use spade::*;
+#[cfg(feature = "sparkle")]
+pub use sparkle::*;
+#[cfg(feature = "sparkles")]
+pub use sparkles::*;
+#[cfg(feature = "speaker")]
+pub use speaker::*;
+#[cfg(feature = "speech")]
+pub use speech::*;
+#[cfg(feature = "spell-check")]
+pub use spell_check::*;
+#[cfg(feature = "spell-check-2")]
+pub use spell_check_2::*;
+#[cfg(feature = "spline")]
+pub use spline::*;
+#[cfg(feature = "split")]
+pub use split::*;
+#[cfg(feature = "spray-can")]
+pub use spray_can::*;
+#[cfg(feature = "sprout")]
+pub use sprout::*;
+#[cfg(feature = "square")]
+pub use square::*;
+#[cfg(feature = "square-activity")]
+pub use square_activity::*;
+#[cfg(feature = "square-arrow-down")]
+pub use square_arrow_down::*;
+#[cfg(feature = "square-arrow-down-left")]
+pub use square_arrow_down_left::*;
+#[cfg(feature = "square-arrow-down-right")]
+pub use square_arrow_down_right::*;
+#[cfg(feature = "square-arrow-left")]
+pub use square_arrow_left::*;
+#[cfg(feature = "square-arrow-out-down-left")]
+pub use square_arrow_out_down_left::*;
+#[cfg(feature = "square-arrow-out-down-right")]
+pub use square_arrow_out_down_right::*;
+#[cfg(feature = "square-arrow-out-up-left")]
+pub use square_arrow_out_up_left::*;
+#[cfg(feature = "square-arrow-out-up-right")]
+pub use square_arrow_out_up_right::*;
+#[cfg(feature = "square-arrow-right")]
+pub use square_arrow_right::*;
+#[cfg(feature = "square-arrow-up")]
+pub use square_arrow_up::*;
+#[cfg(feature = "square-arrow-up-left")]
+pub use square_arrow_up_left::*;
+#[cfg(feature = "square-arrow-up-right")]
+pub use square_arrow_up_right::*;
+#[cfg(feature = "square-asterisk")]
+pub use square_asterisk::*;
+#[cfg(feature = "square-bottom-dashed-scissors")]
+pub use square_bottom_dashed_scissors::*;
+#[cfg(feature = "square-chart-gantt")]
+pub use square_chart_gantt::*;
+#[cfg(feature = "square-check")]
+pub use square_check::*;
+#[cfg(feature = "square-check-big")]
+pub use square_check_big::*;
+#[cfg(feature = "square-chevron-down")]
+pub use square_chevron_down::*;
+#[cfg(feature = "square-chevron-left")]
+pub use square_chevron_left::*;
+#[cfg(feature = "square-chevron-right")]
+pub use square_chevron_right::*;
+#[cfg(feature = "square-chevron-up")]
+pub use square_chevron_up::*;
+#[cfg(feature = "square-code")]
+pub use square_code::*;
+#[cfg(feature = "square-dashed")]
+pub use square_dashed::*;
+#[cfg(feature = "square-dashed-bottom")]
+pub use square_dashed_bottom::*;
+#[cfg(feature = "square-dashed-bottom-code")]
+pub use square_dashed_bottom_code::*;
+#[cfg(feature = "square-dashed-kanban")]
+pub use square_dashed_kanban::*;
+#[cfg(feature = "square-dashed-mouse-pointer")]
+pub use square_dashed_mouse_pointer::*;
+#[cfg(feature = "square-divide")]
+pub use square_divide::*;
+#[cfg(feature = "square-dot")]
+pub use square_dot::*;
+#[cfg(feature = "square-equal")]
+pub use square_equal::*;
+#[cfg(feature = "square-function")]
+pub use square_function::*;
+#[cfg(feature = "square-kanban")]
+pub use square_kanban::*;
+#[cfg(feature = "square-library")]
+pub use square_library::*;
+#[cfg(feature = "square-m")]
+pub use square_m::*;
+#[cfg(feature = "square-menu")]
+pub use square_menu::*;
+#[cfg(feature = "square-minus")]
+pub use square_minus::*;
+#[cfg(feature = "square-mouse-pointer")]
+pub use square_mouse_pointer::*;
+#[cfg(feature = "square-parking")]
+pub use square_parking::*;
+#[cfg(feature = "square-parking-off")]
+pub use square_parking_off::*;
+#[cfg(feature = "square-pen")]
+pub use square_pen::*;
+#[cfg(feature = "square-percent")]
+pub use square_percent::*;
+#[cfg(feature = "square-pi")]
+pub use square_pi::*;
+#[cfg(feature = "square-pilcrow")]
+pub use square_pilcrow::*;
+#[cfg(feature = "square-play")]
+pub use square_play::*;
+#[cfg(feature = "square-plus")]
+pub use square_plus::*;
+#[cfg(feature = "square-power")]
+pub use square_power::*;
+#[cfg(feature = "square-radical")]
+pub use square_radical::*;
+#[cfg(feature = "square-scissors")]
+pub use square_scissors::*;
+#[cfg(feature = "square-sigma")]
+pub use square_sigma::*;
+#[cfg(feature = "square-slash")]
+pub use square_slash::*;
+#[cfg(feature = "square-split-horizontal")]
+pub use square_split_horizontal::*;
+#[cfg(feature = "square-split-vertical")]
+pub use square_split_vertical::*;
+#[cfg(feature = "square-square")]
+pub use square_square::*;
+#[cfg(feature = "square-stack")]
+pub use square_stack::*;
+#[cfg(feature = "square-terminal")]
+pub use square_terminal::*;
+#[cfg(feature = "square-user")]
+pub use square_user::*;
+#[cfg(feature = "square-user-round")]
+pub use square_user_round::*;
+#[cfg(feature = "square-x")]
+pub use square_x::*;
+#[cfg(feature = "squircle")]
+pub use squircle::*;
+#[cfg(feature = "squirrel")]
+pub use squirrel::*;
+#[cfg(feature = "stamp")]
+pub use stamp::*;
+#[cfg(feature = "star")]
+pub use star::*;
+#[cfg(feature = "star-half")]
+pub use star_half::*;
+#[cfg(feature = "star-off")]
+pub use star_off::*;
+#[cfg(feature = "step-back")]
+pub use step_back::*;
+#[cfg(feature = "step-forward")]
+pub use step_forward::*;
+#[cfg(feature = "stethoscope")]
+pub use stethoscope::*;
+#[cfg(feature = "sticker")]
+pub use sticker::*;
+#[cfg(feature = "sticky-note")]
+pub use sticky_note::*;
+#[cfg(feature = "store")]
+pub use store::*;
+#[cfg(feature = "stretch-horizontal")]
+pub use stretch_horizontal::*;
+#[cfg(feature = "stretch-vertical")]
+pub use stretch_vertical::*;
+#[cfg(feature = "strikethrough")]
+pub use strikethrough::*;
+#[cfg(feature = "subscript")]
+pub use subscript::*;
+#[cfg(feature = "sun")]
+pub use sun::*;
+#[cfg(feature = "sun-dim")]
+pub use sun_dim::*;
+#[cfg(feature = "sun-medium")]
+pub use sun_medium::*;
+#[cfg(feature = "sun-moon")]
+pub use sun_moon::*;
+#[cfg(feature = "sun-snow")]
+pub use sun_snow::*;
+#[cfg(feature = "sunrise")]
+pub use sunrise::*;
+#[cfg(feature = "sunset")]
+pub use sunset::*;
+#[cfg(feature = "superscript")]
+pub use superscript::*;
+#[cfg(feature = "swatch-book")]
+pub use swatch_book::*;
+#[cfg(feature = "swiss-franc")]
+pub use swiss_franc::*;
+#[cfg(feature = "switch-camera")]
+pub use switch_camera::*;
+#[cfg(feature = "sword")]
+pub use sword::*;
+#[cfg(feature = "swords")]
+pub use swords::*;
+#[cfg(feature = "syringe")]
+pub use syringe::*;
+#[cfg(feature = "table")]
+pub use table::*;
+#[cfg(feature = "table-2")]
+pub use table_2::*;
+#[cfg(feature = "table-cells-merge")]
+pub use table_cells_merge::*;
+#[cfg(feature = "table-cells-split")]
+pub use table_cells_split::*;
+#[cfg(feature = "table-columns-split")]
+pub use table_columns_split::*;
+#[cfg(feature = "table-of-contents")]
+pub use table_of_contents::*;
+#[cfg(feature = "table-properties")]
+pub use table_properties::*;
+#[cfg(feature = "table-rows-split")]
+pub use table_rows_split::*;
+#[cfg(feature = "tablet")]
+pub use tablet::*;
+#[cfg(feature = "tablet-smartphone")]
+pub use tablet_smartphone::*;
+#[cfg(feature = "tablets")]
+pub use tablets::*;
+#[cfg(feature = "tag")]
+pub use tag::*;
+#[cfg(feature = "tags")]
+pub use tags::*;
+#[cfg(feature = "tally-1")]
+pub use tally_1::*;
+#[cfg(feature = "tally-2")]
+pub use tally_2::*;
+#[cfg(feature = "tally-3")]
+pub use tally_3::*;
+#[cfg(feature = "tally-4")]
+pub use tally_4::*;
+#[cfg(feature = "tally-5")]
+pub use tally_5::*;
+#[cfg(feature = "tangent")]
+pub use tangent::*;
+#[cfg(feature = "target")]
+pub use target::*;
+#[cfg(feature = "telescope")]
+pub use telescope::*;
+#[cfg(feature = "tent")]
+pub use tent::*;
+#[cfg(feature = "tent-tree")]
+pub use tent_tree::*;
+#[cfg(feature = "terminal")]
+pub use terminal::*;
+#[cfg(feature = "test-tube")]
+pub use test_tube::*;
+#[cfg(feature = "test-tube-diagonal")]
+pub use test_tube_diagonal::*;
+#[cfg(feature = "test-tubes")]
+pub use test_tubes::*;
+#[cfg(feature = "text")]
+pub use text::*;
+#[cfg(feature = "text-cursor")]
+pub use text_cursor::*;
+#[cfg(feature = "text-cursor-input")]
+pub use text_cursor_input::*;
+#[cfg(feature = "text-quote")]
+pub use text_quote::*;
+#[cfg(feature = "text-search")]
+pub use text_search::*;
+#[cfg(feature = "text-select")]
+pub use text_select::*;
+#[cfg(feature = "theater")]
+pub use theater::*;
+#[cfg(feature = "thermometer")]
+pub use thermometer::*;
+#[cfg(feature = "thermometer-snowflake")]
+pub use thermometer_snowflake::*;
+#[cfg(feature = "thermometer-sun")]
+pub use thermometer_sun::*;
+#[cfg(feature = "thumbs-down")]
+pub use thumbs_down::*;
+#[cfg(feature = "thumbs-up")]
+pub use thumbs_up::*;
+#[cfg(feature = "ticket")]
+pub use ticket::*;
+#[cfg(feature = "ticket-check")]
+pub use ticket_check::*;
+#[cfg(feature = "ticket-minus")]
+pub use ticket_minus::*;
+#[cfg(feature = "ticket-percent")]
+pub use ticket_percent::*;
+#[cfg(feature = "ticket-plus")]
+pub use ticket_plus::*;
+#[cfg(feature = "ticket-slash")]
+pub use ticket_slash::*;
+#[cfg(feature = "ticket-x")]
+pub use ticket_x::*;
+#[cfg(feature = "tickets")]
+pub use tickets::*;
+#[cfg(feature = "tickets-plane")]
+pub use tickets_plane::*;
+#[cfg(feature = "timer")]
+pub use timer::*;
+#[cfg(feature = "timer-off")]
+pub use timer_off::*;
+#[cfg(feature = "timer-reset")]
+pub use timer_reset::*;
+#[cfg(feature = "toggle-left")]
+pub use toggle_left::*;
+#[cfg(feature = "toggle-right")]
+pub use toggle_right::*;
+#[cfg(feature = "toilet")]
+pub use toilet::*;
+#[cfg(feature = "tornado")]
+pub use tornado::*;
+#[cfg(feature = "torus")]
+pub use torus::*;
+#[cfg(feature = "touchpad")]
+pub use touchpad::*;
+#[cfg(feature = "touchpad-off")]
+pub use touchpad_off::*;
+#[cfg(feature = "tower-control")]
+pub use tower_control::*;
+#[cfg(feature = "toy-brick")]
+pub use toy_brick::*;
+#[cfg(feature = "tractor")]
+pub use tractor::*;
+#[cfg(feature = "traffic-cone")]
+pub use traffic_cone::*;
+#[cfg(feature = "train-front")]
+pub use train_front::*;
+#[cfg(feature = "train-front-tunnel")]
+pub use train_front_tunnel::*;
+#[cfg(feature = "train-track")]
+pub use train_track::*;
+#[cfg(feature = "tram-front")]
+pub use tram_front::*;
+#[cfg(feature = "trash")]
+pub use trash::*;
+#[cfg(feature = "trash-2")]
+pub use trash_2::*;
+#[cfg(feature = "tree-deciduous")]
+pub use tree_deciduous::*;
+#[cfg(feature = "tree-palm")]
+pub use tree_palm::*;
+#[cfg(feature = "tree-pine")]
+pub use tree_pine::*;
+#[cfg(feature = "trees")]
+pub use trees::*;
+#[cfg(feature = "trello")]
+pub use trello::*;
+#[cfg(feature = "trending-down")]
+pub use trending_down::*;
+#[cfg(feature = "trending-up")]
+pub use trending_up::*;
+#[cfg(feature = "trending-up-down")]
+pub use trending_up_down::*;
+#[cfg(feature = "triangle")]
+pub use triangle::*;
+#[cfg(feature = "triangle-alert")]
+pub use triangle_alert::*;
+#[cfg(feature = "triangle-right")]
+pub use triangle_right::*;
+#[cfg(feature = "trophy")]
+pub use trophy::*;
+#[cfg(feature = "truck")]
+pub use truck::*;
+#[cfg(feature = "turtle")]
+pub use turtle::*;
+#[cfg(feature = "tv")]
+pub use tv::*;
+#[cfg(feature = "tv-minimal")]
+pub use tv_minimal::*;
+#[cfg(feature = "tv-minimal-play")]
+pub use tv_minimal_play::*;
+#[cfg(feature = "twitch")]
+pub use twitch::*;
+#[cfg(feature = "twitter")]
+pub use twitter::*;
+#[cfg(feature = "type-outline")]
+pub use type_outline::*;
+#[cfg(feature = "umbrella")]
+pub use umbrella::*;
+#[cfg(feature = "umbrella-off")]
+pub use umbrella_off::*;
+#[cfg(feature = "underline")]
+pub use underline::*;
+#[cfg(feature = "undo")]
+pub use undo::*;
+#[cfg(feature = "undo-2")]
+pub use undo_2::*;
+#[cfg(feature = "undo-dot")]
+pub use undo_dot::*;
+#[cfg(feature = "unfold-horizontal")]
+pub use unfold_horizontal::*;
+#[cfg(feature = "unfold-vertical")]
+pub use unfold_vertical::*;
+#[cfg(feature = "ungroup")]
+pub use ungroup::*;
+#[cfg(feature = "university")]
+pub use university::*;
+#[cfg(feature = "unlink")]
+pub use unlink::*;
+#[cfg(feature = "unlink-2")]
+pub use unlink_2::*;
+#[cfg(feature = "unplug")]
+pub use unplug::*;
+#[cfg(feature = "upload")]
+pub use upload::*;
+#[cfg(feature = "usb")]
+pub use usb::*;
+#[cfg(feature = "user")]
+pub use user::*;
+#[cfg(feature = "user-check")]
+pub use user_check::*;
+#[cfg(feature = "user-cog")]
+pub use user_cog::*;
+#[cfg(feature = "user-minus")]
+pub use user_minus::*;
+#[cfg(feature = "user-pen")]
+pub use user_pen::*;
+#[cfg(feature = "user-plus")]
+pub use user_plus::*;
+#[cfg(feature = "user-round")]
+pub use user_round::*;
+#[cfg(feature = "user-round-check")]
+pub use user_round_check::*;
+#[cfg(feature = "user-round-cog")]
+pub use user_round_cog::*;
+#[cfg(feature = "user-round-minus")]
+pub use user_round_minus::*;
+#[cfg(feature = "user-round-pen")]
+pub use user_round_pen::*;
+#[cfg(feature = "user-round-plus")]
+pub use user_round_plus::*;
+#[cfg(feature = "user-round-search")]
+pub use user_round_search::*;
+#[cfg(feature = "user-round-x")]
+pub use user_round_x::*;
+#[cfg(feature = "user-search")]
+pub use user_search::*;
+#[cfg(feature = "user-x")]
+pub use user_x::*;
+#[cfg(feature = "users")]
+pub use users::*;
+#[cfg(feature = "users-round")]
+pub use users_round::*;
+#[cfg(feature = "utensils")]
+pub use utensils::*;
+#[cfg(feature = "utensils-crossed")]
+pub use utensils_crossed::*;
+#[cfg(feature = "utility-pole")]
+pub use utility_pole::*;
+#[cfg(feature = "variable")]
+pub use variable::*;
+#[cfg(feature = "vault")]
+pub use vault::*;
+#[cfg(feature = "vegan")]
+pub use vegan::*;
+#[cfg(feature = "venetian-mask")]
+pub use venetian_mask::*;
+#[cfg(feature = "vibrate")]
+pub use vibrate::*;
+#[cfg(feature = "vibrate-off")]
+pub use vibrate_off::*;
+#[cfg(feature = "video")]
+pub use video::*;
+#[cfg(feature = "video-off")]
+pub use video_off::*;
+#[cfg(feature = "videotape")]
+pub use videotape::*;
+#[cfg(feature = "view")]
+pub use view::*;
+#[cfg(feature = "voicemail")]
+pub use voicemail::*;
+#[cfg(feature = "volleyball")]
+pub use volleyball::*;
+#[cfg(feature = "volume")]
+pub use volume::*;
+#[cfg(feature = "volume-1")]
+pub use volume_1::*;
+#[cfg(feature = "volume-2")]
+pub use volume_2::*;
+#[cfg(feature = "volume-off")]
+pub use volume_off::*;
+#[cfg(feature = "volume-x")]
+pub use volume_x::*;
+#[cfg(feature = "vote")]
+pub use vote::*;
+#[cfg(feature = "wallet")]
+pub use wallet::*;
+#[cfg(feature = "wallet-cards")]
+pub use wallet_cards::*;
+#[cfg(feature = "wallet-minimal")]
+pub use wallet_minimal::*;
+#[cfg(feature = "wallpaper")]
+pub use wallpaper::*;
+#[cfg(feature = "wand")]
+pub use wand::*;
+#[cfg(feature = "wand-sparkles")]
+pub use wand_sparkles::*;
+#[cfg(feature = "warehouse")]
+pub use warehouse::*;
+#[cfg(feature = "washing-machine")]
+pub use washing_machine::*;
+#[cfg(feature = "watch")]
+pub use watch::*;
+#[cfg(feature = "waves")]
+pub use waves::*;
+#[cfg(feature = "waypoints")]
+pub use waypoints::*;
+#[cfg(feature = "webcam")]
+pub use webcam::*;
+#[cfg(feature = "webhook")]
+pub use webhook::*;
+#[cfg(feature = "webhook-off")]
+pub use webhook_off::*;
+#[cfg(feature = "weight")]
+pub use weight::*;
+#[cfg(feature = "wheat")]
+pub use wheat::*;
+#[cfg(feature = "wheat-off")]
+pub use wheat_off::*;
+#[cfg(feature = "whole-word")]
+pub use whole_word::*;
+#[cfg(feature = "wifi")]
+pub use wifi::*;
+#[cfg(feature = "wifi-high")]
+pub use wifi_high::*;
+#[cfg(feature = "wifi-low")]
+pub use wifi_low::*;
+#[cfg(feature = "wifi-off")]
+pub use wifi_off::*;
+#[cfg(feature = "wifi-zero")]
+pub use wifi_zero::*;
+#[cfg(feature = "wind")]
+pub use wind::*;
+#[cfg(feature = "wind-arrow-down")]
+pub use wind_arrow_down::*;
+#[cfg(feature = "wine")]
+pub use wine::*;
+#[cfg(feature = "wine-off")]
+pub use wine_off::*;
+#[cfg(feature = "workflow")]
+pub use workflow::*;
+#[cfg(feature = "worm")]
+pub use worm::*;
+#[cfg(feature = "wrap-text")]
+pub use wrap_text::*;
+#[cfg(feature = "wrench")]
+pub use wrench::*;
+#[cfg(feature = "x")]
+pub use x::*;
+#[cfg(feature = "youtube")]
+pub use youtube::*;
+#[cfg(feature = "zap")]
+pub use zap::*;
+#[cfg(feature = "zap-off")]
+pub use zap_off::*;
+#[cfg(feature = "zoom-in")]
+pub use zoom_in::*;
+#[cfg(feature = "zoom-out")]
+pub use zoom_out::*;
diff --git a/packages/yew/src/library.rs b/packages/yew/src/library.rs
new file mode 100644
index 0000000..57d05f8
--- /dev/null
+++ b/packages/yew/src/library.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LibraryProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Library(props: &LibraryProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 6 4 14" />
+            <path d="M12 6v14" />
+            <path d="M8 8v12" />
+            <path d="M4 4v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/library_big.rs b/packages/yew/src/library_big.rs
new file mode 100644
index 0000000..ba26913
--- /dev/null
+++ b/packages/yew/src/library_big.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LibraryBigProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LibraryBig(props: &LibraryBigProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="18" x="3" y="3" rx="1" />
+            <path d="M7 3v18" />
+            <path
+                d="M20.4 18.9c.2.5-.1 1.1-.6 1.3l-1.9.7c-.5.2-1.1-.1-1.3-.6L11.1 5.1c-.2-.5.1-1.1.6-1.3l1.9-.7c.5-.2 1.1.1 1.3.6Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/life_buoy.rs b/packages/yew/src/life_buoy.rs
new file mode 100644
index 0000000..27f6b7d
--- /dev/null
+++ b/packages/yew/src/life_buoy.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LifeBuoyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LifeBuoy(props: &LifeBuoyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="m4.93 4.93 4.24 4.24" />
+            <path d="m14.83 9.17 4.24-4.24" />
+            <path d="m14.83 14.83 4.24 4.24" />
+            <path d="m9.17 14.83-4.24 4.24" />
+            <circle cx="12" cy="12" r="4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ligature.rs b/packages/yew/src/ligature.rs
new file mode 100644
index 0000000..d96c520
--- /dev/null
+++ b/packages/yew/src/ligature.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LigatureProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ligature(props: &LigatureProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 20V8c0-2.2 1.8-4 4-4 1.5 0 2.8.8 3.5 2" />
+            <path d="M6 12h4" />
+            <path d="M14 12h2v8" />
+            <path d="M6 20h4" />
+            <path d="M14 20h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lightbulb.rs b/packages/yew/src/lightbulb.rs
new file mode 100644
index 0000000..de40c05
--- /dev/null
+++ b/packages/yew/src/lightbulb.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LightbulbProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Lightbulb(props: &LightbulbProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5.7.7 1.3 1.5 1.5 2.5"
+            />
+            <path d="M9 18h6" />
+            <path d="M10 22h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lightbulb_off.rs b/packages/yew/src/lightbulb_off.rs
new file mode 100644
index 0000000..310ab84
--- /dev/null
+++ b/packages/yew/src/lightbulb_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LightbulbOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LightbulbOff(props: &LightbulbOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16.8 11.2c.8-.9 1.2-2 1.2-3.2a6 6 0 0 0-9.3-5" />
+            <path d="m2 2 20 20" />
+            <path d="M6.3 6.3a4.67 4.67 0 0 0 1.2 5.2c.7.7 1.3 1.5 1.5 2.5" />
+            <path d="M9 18h6" />
+            <path d="M10 22h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/link.rs b/packages/yew/src/link.rs
new file mode 100644
index 0000000..4b040e1
--- /dev/null
+++ b/packages/yew/src/link.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LinkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Link(props: &LinkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71" />
+            <path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/link_2.rs b/packages/yew/src/link_2.rs
new file mode 100644
index 0000000..3866613
--- /dev/null
+++ b/packages/yew/src/link_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Link2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Link2(props: &Link2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 17H7A5 5 0 0 1 7 7h2" />
+            <path d="M15 7h2a5 5 0 1 1 0 10h-2" />
+            <line x1="8" x2="16" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/link_2_off.rs b/packages/yew/src/link_2_off.rs
new file mode 100644
index 0000000..fb00345
--- /dev/null
+++ b/packages/yew/src/link_2_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Link2OffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Link2Off(props: &Link2OffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 17H7A5 5 0 0 1 7 7" />
+            <path d="M15 7h2a5 5 0 0 1 4 8" />
+            <line x1="8" x2="12" y1="12" y2="12" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/linkedin.rs b/packages/yew/src/linkedin.rs
new file mode 100644
index 0000000..c975b5e
--- /dev/null
+++ b/packages/yew/src/linkedin.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LinkedinProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Linkedin(props: &LinkedinProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z"
+            />
+            <rect width="4" height="12" x="2" y="9" />
+            <circle cx="4" cy="4" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list.rs b/packages/yew/src/list.rs
new file mode 100644
index 0000000..6c3fb76
--- /dev/null
+++ b/packages/yew/src/list.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn List(props: &ListProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12h.01" />
+            <path d="M3 18h.01" />
+            <path d="M3 6h.01" />
+            <path d="M8 12h13" />
+            <path d="M8 18h13" />
+            <path d="M8 6h13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_check.rs b/packages/yew/src/list_check.rs
new file mode 100644
index 0000000..cb6d028
--- /dev/null
+++ b/packages/yew/src/list_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListCheck(props: &ListCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 18H3" />
+            <path d="m15 18 2 2 4-4" />
+            <path d="M16 12H3" />
+            <path d="M16 6H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_checks.rs b/packages/yew/src/list_checks.rs
new file mode 100644
index 0000000..493602d
--- /dev/null
+++ b/packages/yew/src/list_checks.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListChecksProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListChecks(props: &ListChecksProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 17 2 2 4-4" />
+            <path d="m3 7 2 2 4-4" />
+            <path d="M13 6h8" />
+            <path d="M13 12h8" />
+            <path d="M13 18h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_collapse.rs b/packages/yew/src/list_collapse.rs
new file mode 100644
index 0000000..ecd87f5
--- /dev/null
+++ b/packages/yew/src/list_collapse.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListCollapseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListCollapse(props: &ListCollapseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 10 2.5-2.5L3 5" />
+            <path d="m3 19 2.5-2.5L3 14" />
+            <path d="M10 6h11" />
+            <path d="M10 12h11" />
+            <path d="M10 18h11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_end.rs b/packages/yew/src/list_end.rs
new file mode 100644
index 0000000..6a30cef
--- /dev/null
+++ b/packages/yew/src/list_end.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListEndProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListEnd(props: &ListEndProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12H3" />
+            <path d="M16 6H3" />
+            <path d="M10 18H3" />
+            <path d="M21 6v10a2 2 0 0 1-2 2h-5" />
+            <path d="m16 16-2 2 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_filter.rs b/packages/yew/src/list_filter.rs
new file mode 100644
index 0000000..fad804c
--- /dev/null
+++ b/packages/yew/src/list_filter.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListFilterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListFilter(props: &ListFilterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 6h18" />
+            <path d="M7 12h10" />
+            <path d="M10 18h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_minus.rs b/packages/yew/src/list_minus.rs
new file mode 100644
index 0000000..aea289a
--- /dev/null
+++ b/packages/yew/src/list_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListMinus(props: &ListMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 12H3" />
+            <path d="M16 6H3" />
+            <path d="M16 18H3" />
+            <path d="M21 12h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_music.rs b/packages/yew/src/list_music.rs
new file mode 100644
index 0000000..c93fbd9
--- /dev/null
+++ b/packages/yew/src/list_music.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListMusicProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListMusic(props: &ListMusicProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15V6" />
+            <path d="M18.5 18a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5Z" />
+            <path d="M12 12H3" />
+            <path d="M16 6H3" />
+            <path d="M12 18H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_ordered.rs b/packages/yew/src/list_ordered.rs
new file mode 100644
index 0000000..0891c8e
--- /dev/null
+++ b/packages/yew/src/list_ordered.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListOrderedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListOrdered(props: &ListOrderedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 12h11" />
+            <path d="M10 18h11" />
+            <path d="M10 6h11" />
+            <path d="M4 10h2" />
+            <path d="M4 6h1v4" />
+            <path d="M6 18H4c0-1 2-2 2-3s-1-1.5-2-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_plus.rs b/packages/yew/src/list_plus.rs
new file mode 100644
index 0000000..a958cda
--- /dev/null
+++ b/packages/yew/src/list_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListPlus(props: &ListPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 12H3" />
+            <path d="M16 6H3" />
+            <path d="M16 18H3" />
+            <path d="M18 9v6" />
+            <path d="M21 12h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_restart.rs b/packages/yew/src/list_restart.rs
new file mode 100644
index 0000000..700dc3f
--- /dev/null
+++ b/packages/yew/src/list_restart.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListRestartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListRestart(props: &ListRestartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 6H3" />
+            <path d="M7 12H3" />
+            <path d="M7 18H3" />
+            <path d="M12 18a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L11 14" />
+            <path d="M11 10v4h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_start.rs b/packages/yew/src/list_start.rs
new file mode 100644
index 0000000..65cd5dc
--- /dev/null
+++ b/packages/yew/src/list_start.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListStartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListStart(props: &ListStartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12H3" />
+            <path d="M16 18H3" />
+            <path d="M10 6H3" />
+            <path d="M21 18V8a2 2 0 0 0-2-2h-5" />
+            <path d="m16 8-2-2 2-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_todo.rs b/packages/yew/src/list_todo.rs
new file mode 100644
index 0000000..4f2e7f3
--- /dev/null
+++ b/packages/yew/src/list_todo.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListTodoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListTodo(props: &ListTodoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="3" y="5" width="6" height="6" rx="1" />
+            <path d="m3 17 2 2 4-4" />
+            <path d="M13 6h8" />
+            <path d="M13 12h8" />
+            <path d="M13 18h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_tree.rs b/packages/yew/src/list_tree.rs
new file mode 100644
index 0000000..4d2a918
--- /dev/null
+++ b/packages/yew/src/list_tree.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListTreeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListTree(props: &ListTreeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12h-8" />
+            <path d="M21 6H8" />
+            <path d="M21 18h-8" />
+            <path d="M3 6v4c0 1.1.9 2 2 2h3" />
+            <path d="M3 10v6c0 1.1.9 2 2 2h3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_video.rs b/packages/yew/src/list_video.rs
new file mode 100644
index 0000000..6c6ca88
--- /dev/null
+++ b/packages/yew/src/list_video.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListVideoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListVideo(props: &ListVideoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12H3" />
+            <path d="M16 6H3" />
+            <path d="M12 18H3" />
+            <path d="m16 12 5 3-5 3v-6Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/list_x.rs b/packages/yew/src/list_x.rs
new file mode 100644
index 0000000..d5cd817
--- /dev/null
+++ b/packages/yew/src/list_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ListXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ListX(props: &ListXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 12H3" />
+            <path d="M16 6H3" />
+            <path d="M16 18H3" />
+            <path d="m19 10-4 4" />
+            <path d="m15 10 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/loader.rs b/packages/yew/src/loader.rs
new file mode 100644
index 0000000..8a543dd
--- /dev/null
+++ b/packages/yew/src/loader.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LoaderProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Loader(props: &LoaderProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v4" />
+            <path d="m16.2 7.8 2.9-2.9" />
+            <path d="M18 12h4" />
+            <path d="m16.2 16.2 2.9 2.9" />
+            <path d="M12 18v4" />
+            <path d="m4.9 19.1 2.9-2.9" />
+            <path d="M2 12h4" />
+            <path d="m4.9 4.9 2.9 2.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/loader_circle.rs b/packages/yew/src/loader_circle.rs
new file mode 100644
index 0000000..e4bfffa
--- /dev/null
+++ b/packages/yew/src/loader_circle.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LoaderCircleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LoaderCircle(props: &LoaderCircleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12a9 9 0 1 1-6.219-8.56" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/loader_pinwheel.rs b/packages/yew/src/loader_pinwheel.rs
new file mode 100644
index 0000000..3dcb1c5
--- /dev/null
+++ b/packages/yew/src/loader_pinwheel.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LoaderPinwheelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LoaderPinwheel(props: &LoaderPinwheelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12a1 1 0 0 1-10 0 1 1 0 0 0-10 0" />
+            <path d="M7 20.7a1 1 0 1 1 5-8.7 1 1 0 1 0 5-8.6" />
+            <path d="M7 3.3a1 1 0 1 1 5 8.6 1 1 0 1 0 5 8.6" />
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/locate.rs b/packages/yew/src/locate.rs
new file mode 100644
index 0000000..031bb65
--- /dev/null
+++ b/packages/yew/src/locate.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LocateProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Locate(props: &LocateProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="5" y1="12" y2="12" />
+            <line x1="19" x2="22" y1="12" y2="12" />
+            <line x1="12" x2="12" y1="2" y2="5" />
+            <line x1="12" x2="12" y1="19" y2="22" />
+            <circle cx="12" cy="12" r="7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/locate_fixed.rs b/packages/yew/src/locate_fixed.rs
new file mode 100644
index 0000000..9bfd312
--- /dev/null
+++ b/packages/yew/src/locate_fixed.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LocateFixedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LocateFixed(props: &LocateFixedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="5" y1="12" y2="12" />
+            <line x1="19" x2="22" y1="12" y2="12" />
+            <line x1="12" x2="12" y1="2" y2="5" />
+            <line x1="12" x2="12" y1="19" y2="22" />
+            <circle cx="12" cy="12" r="7" />
+            <circle cx="12" cy="12" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/locate_off.rs b/packages/yew/src/locate_off.rs
new file mode 100644
index 0000000..fa143ea
--- /dev/null
+++ b/packages/yew/src/locate_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LocateOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LocateOff(props: &LocateOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="5" y1="12" y2="12" />
+            <line x1="19" x2="22" y1="12" y2="12" />
+            <line x1="12" x2="12" y1="2" y2="5" />
+            <line x1="12" x2="12" y1="19" y2="22" />
+            <path d="M7.11 7.11C5.83 8.39 5 10.1 5 12c0 3.87 3.13 7 7 7 1.9 0 3.61-.83 4.89-2.11" />
+            <path d="M18.71 13.96c.19-.63.29-1.29.29-1.96 0-3.87-3.13-7-7-7-.67 0-1.33.1-1.96.29" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lock.rs b/packages/yew/src/lock.rs
new file mode 100644
index 0000000..52c2dd8
--- /dev/null
+++ b/packages/yew/src/lock.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Lock(props: &LockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="11" x="3" y="11" rx="2" ry="2" />
+            <path d="M7 11V7a5 5 0 0 1 10 0v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lock_keyhole.rs b/packages/yew/src/lock_keyhole.rs
new file mode 100644
index 0000000..71d19a2
--- /dev/null
+++ b/packages/yew/src/lock_keyhole.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LockKeyholeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LockKeyhole(props: &LockKeyholeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="16" r="1" />
+            <rect x="3" y="10" width="18" height="12" rx="2" />
+            <path d="M7 10V7a5 5 0 0 1 10 0v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lock_keyhole_open.rs b/packages/yew/src/lock_keyhole_open.rs
new file mode 100644
index 0000000..39726ff
--- /dev/null
+++ b/packages/yew/src/lock_keyhole_open.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LockKeyholeOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LockKeyholeOpen(props: &LockKeyholeOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="16" r="1" />
+            <rect width="18" height="12" x="3" y="10" rx="2" />
+            <path d="M7 10V7a5 5 0 0 1 9.33-2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lock_open.rs b/packages/yew/src/lock_open.rs
new file mode 100644
index 0000000..7f0c38e
--- /dev/null
+++ b/packages/yew/src/lock_open.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LockOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LockOpen(props: &LockOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="11" x="3" y="11" rx="2" ry="2" />
+            <path d="M7 11V7a5 5 0 0 1 9.9-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/log_in.rs b/packages/yew/src/log_in.rs
new file mode 100644
index 0000000..89dfe36
--- /dev/null
+++ b/packages/yew/src/log_in.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LogInProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LogIn(props: &LogInProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4" />
+            <polyline points="10 17 15 12 10 7" />
+            <line x1="15" x2="3" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/log_out.rs b/packages/yew/src/log_out.rs
new file mode 100644
index 0000000..a49d745
--- /dev/null
+++ b/packages/yew/src/log_out.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LogOutProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn LogOut(props: &LogOutProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4" />
+            <polyline points="16 17 21 12 16 7" />
+            <line x1="21" x2="9" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/logs.rs b/packages/yew/src/logs.rs
new file mode 100644
index 0000000..39b3e36
--- /dev/null
+++ b/packages/yew/src/logs.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LogsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Logs(props: &LogsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 12h8" />
+            <path d="M13 18h8" />
+            <path d="M13 6h8" />
+            <path d="M3 12h1" />
+            <path d="M3 18h1" />
+            <path d="M3 6h1" />
+            <path d="M8 12h1" />
+            <path d="M8 18h1" />
+            <path d="M8 6h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/lollipop.rs b/packages/yew/src/lollipop.rs
new file mode 100644
index 0000000..1f8b3c5
--- /dev/null
+++ b/packages/yew/src/lollipop.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LollipopProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Lollipop(props: &LollipopProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="11" r="8" />
+            <path d="m21 21-4.3-4.3" />
+            <path d="M11 11a2 2 0 0 0 4 0 4 4 0 0 0-8 0 6 6 0 0 0 12 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/luggage.rs b/packages/yew/src/luggage.rs
new file mode 100644
index 0000000..4767bc4
--- /dev/null
+++ b/packages/yew/src/luggage.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct LuggageProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Luggage(props: &LuggageProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 20a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2" />
+            <path d="M8 18V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v14" />
+            <path d="M10 20h4" />
+            <circle cx="16" cy="20" r="2" />
+            <circle cx="8" cy="20" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/magnet.rs b/packages/yew/src/magnet.rs
new file mode 100644
index 0000000..9eacb8a
--- /dev/null
+++ b/packages/yew/src/magnet.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MagnetProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Magnet(props: &MagnetProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m6 15-4-4 6.75-6.77a7.79 7.79 0 0 1 11 11L13 22l-4-4 6.39-6.36a2.14 2.14 0 0 0-3-3L6 15"
+            />
+            <path d="m5 8 4 4" />
+            <path d="m12 15 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail.rs b/packages/yew/src/mail.rs
new file mode 100644
index 0000000..8944f69
--- /dev/null
+++ b/packages/yew/src/mail.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Mail(props: &MailProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail_check.rs b/packages/yew/src/mail_check.rs
new file mode 100644
index 0000000..49ab8ef
--- /dev/null
+++ b/packages/yew/src/mail_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MailCheck(props: &MailCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8" />
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" />
+            <path d="m16 19 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail_minus.rs b/packages/yew/src/mail_minus.rs
new file mode 100644
index 0000000..ea498a8
--- /dev/null
+++ b/packages/yew/src/mail_minus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MailMinus(props: &MailMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 15V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8" />
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" />
+            <path d="M16 19h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail_open.rs b/packages/yew/src/mail_open.rs
new file mode 100644
index 0000000..cd3bf1c
--- /dev/null
+++ b/packages/yew/src/mail_open.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MailOpen(props: &MailOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21.2 8.4c.5.38.8.97.8 1.6v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V10a2 2 0 0 1 .8-1.6l8-6a2 2 0 0 1 2.4 0l8 6Z"
+            />
+            <path d="m22 10-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail_plus.rs b/packages/yew/src/mail_plus.rs
new file mode 100644
index 0000000..e14ddc5
--- /dev/null
+++ b/packages/yew/src/mail_plus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MailPlus(props: &MailPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8" />
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" />
+            <path d="M19 16v6" />
+            <path d="M16 19h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail_question.rs b/packages/yew/src/mail_question.rs
new file mode 100644
index 0000000..b94d5d6
--- /dev/null
+++ b/packages/yew/src/mail_question.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailQuestionProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MailQuestion(props: &MailQuestionProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 10.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h12.5" />
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" />
+            <path d="M18 15.28c.2-.4.5-.8.9-1a2.1 2.1 0 0 1 2.6.4c.3.4.5.8.5 1.3 0 1.3-2 2-2 2" />
+            <path d="M20 22v.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail_search.rs b/packages/yew/src/mail_search.rs
new file mode 100644
index 0000000..aeb68b4
--- /dev/null
+++ b/packages/yew/src/mail_search.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MailSearch(props: &MailSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h7.5" />
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" />
+            <path d="M18 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z" />
+            <circle cx="18" cy="18" r="3" />
+            <path d="m22 22-1.5-1.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail_warning.rs b/packages/yew/src/mail_warning.rs
new file mode 100644
index 0000000..4d25478
--- /dev/null
+++ b/packages/yew/src/mail_warning.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailWarningProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MailWarning(props: &MailWarningProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 10.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h12.5" />
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" />
+            <path d="M20 14v4" />
+            <path d="M20 22v.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mail_x.rs b/packages/yew/src/mail_x.rs
new file mode 100644
index 0000000..c0c199c
--- /dev/null
+++ b/packages/yew/src/mail_x.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MailX(props: &MailXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h9" />
+            <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" />
+            <path d="m17 17 4 4" />
+            <path d="m21 17-4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mailbox.rs b/packages/yew/src/mailbox.rs
new file mode 100644
index 0000000..a5908c5
--- /dev/null
+++ b/packages/yew/src/mailbox.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailboxProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Mailbox(props: &MailboxProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9.5C2 7 4 5 6.5 5H18c2.2 0 4 1.8 4 4v8Z" />
+            <polyline points="15,9 18,9 18,11" />
+            <path d="M6.5 5C9 5 11 7 11 9.5V17a2 2 0 0 1-2 2" />
+            <line x1="6" x2="7" y1="10" y2="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mails.rs b/packages/yew/src/mails.rs
new file mode 100644
index 0000000..b3d3a48
--- /dev/null
+++ b/packages/yew/src/mails.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MailsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Mails(props: &MailsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="13" x="6" y="4" rx="2" />
+            <path d="m22 7-7.1 3.78c-.57.3-1.23.3-1.8 0L6 7" />
+            <path d="M2 8v11c0 1.1.9 2 2 2h14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map.rs b/packages/yew/src/map.rs
new file mode 100644
index 0000000..3af2d9d
--- /dev/null
+++ b/packages/yew/src/map.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Map(props: &MapProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M14.106 5.553a2 2 0 0 0 1.788 0l3.659-1.83A1 1 0 0 1 21 4.619v12.764a1 1 0 0 1-.553.894l-4.553 2.277a2 2 0 0 1-1.788 0l-4.212-2.106a2 2 0 0 0-1.788 0l-3.659 1.83A1 1 0 0 1 3 19.381V6.618a1 1 0 0 1 .553-.894l4.553-2.277a2 2 0 0 1 1.788 0z"
+            />
+            <path d="M15 5.764v15" />
+            <path d="M9 3.236v15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin.rs b/packages/yew/src/map_pin.rs
new file mode 100644
index 0000000..f6a79e2
--- /dev/null
+++ b/packages/yew/src/map_pin.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPin(props: &MapPinProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"
+            />
+            <circle cx="12" cy="10" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_check.rs b/packages/yew/src/map_pin_check.rs
new file mode 100644
index 0000000..3e82e0c
--- /dev/null
+++ b/packages/yew/src/map_pin_check.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinCheck(props: &MapPinCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19.43 12.935c.357-.967.57-1.955.57-2.935a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32.197 32.197 0 0 0 .813-.728"
+            />
+            <circle cx="12" cy="10" r="3" />
+            <path d="m16 18 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_check_inside.rs b/packages/yew/src/map_pin_check_inside.rs
new file mode 100644
index 0000000..5538704
--- /dev/null
+++ b/packages/yew/src/map_pin_check_inside.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinCheckInsideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinCheckInside(props: &MapPinCheckInsideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"
+            />
+            <path d="m9 10 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_house.rs b/packages/yew/src/map_pin_house.rs
new file mode 100644
index 0000000..d3aeb4a
--- /dev/null
+++ b/packages/yew/src/map_pin_house.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinHouseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinHouse(props: &MapPinHouseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M15 22a1 1 0 0 1-1-1v-4a1 1 0 0 1 .445-.832l3-2a1 1 0 0 1 1.11 0l3 2A1 1 0 0 1 22 17v4a1 1 0 0 1-1 1z"
+            />
+            <path d="M18 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 .601.2" />
+            <path d="M18 22v-3" />
+            <circle cx="10" cy="10" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_minus.rs b/packages/yew/src/map_pin_minus.rs
new file mode 100644
index 0000000..0f49966
--- /dev/null
+++ b/packages/yew/src/map_pin_minus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinMinus(props: &MapPinMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M18.977 14C19.6 12.701 20 11.343 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32 32 0 0 0 .824-.738"
+            />
+            <circle cx="12" cy="10" r="3" />
+            <path d="M16 18h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_minus_inside.rs b/packages/yew/src/map_pin_minus_inside.rs
new file mode 100644
index 0000000..717fa82
--- /dev/null
+++ b/packages/yew/src/map_pin_minus_inside.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinMinusInsideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinMinusInside(props: &MapPinMinusInsideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"
+            />
+            <path d="M9 10h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_off.rs b/packages/yew/src/map_pin_off.rs
new file mode 100644
index 0000000..8b41ded
--- /dev/null
+++ b/packages/yew/src/map_pin_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinOff(props: &MapPinOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.75 7.09a3 3 0 0 1 2.16 2.16" />
+            <path
+                d="M17.072 17.072c-1.634 2.17-3.527 3.912-4.471 4.727a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 1.432-4.568"
+            />
+            <path d="m2 2 20 20" />
+            <path d="M8.475 2.818A8 8 0 0 1 20 10c0 1.183-.31 2.377-.81 3.533" />
+            <path d="M9.13 9.13a3 3 0 0 0 3.74 3.74" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_plus.rs b/packages/yew/src/map_pin_plus.rs
new file mode 100644
index 0000000..f6b8607
--- /dev/null
+++ b/packages/yew/src/map_pin_plus.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinPlus(props: &MapPinPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19.914 11.105A7.298 7.298 0 0 0 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32 32 0 0 0 .824-.738"
+            />
+            <circle cx="12" cy="10" r="3" />
+            <path d="M16 18h6" />
+            <path d="M19 15v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_plus_inside.rs b/packages/yew/src/map_pin_plus_inside.rs
new file mode 100644
index 0000000..3ad2d7f
--- /dev/null
+++ b/packages/yew/src/map_pin_plus_inside.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinPlusInsideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinPlusInside(props: &MapPinPlusInsideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"
+            />
+            <path d="M12 7v6" />
+            <path d="M9 10h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_x.rs b/packages/yew/src/map_pin_x.rs
new file mode 100644
index 0000000..c7b6d0b
--- /dev/null
+++ b/packages/yew/src/map_pin_x.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinX(props: &MapPinXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19.752 11.901A7.78 7.78 0 0 0 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 19 19 0 0 0 .09-.077"
+            />
+            <circle cx="12" cy="10" r="3" />
+            <path d="m21.5 15.5-5 5" />
+            <path d="m21.5 20.5-5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pin_x_inside.rs b/packages/yew/src/map_pin_x_inside.rs
new file mode 100644
index 0000000..9b35540
--- /dev/null
+++ b/packages/yew/src/map_pin_x_inside.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinXInsideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinXInside(props: &MapPinXInsideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"
+            />
+            <path d="m14.5 7.5-5 5" />
+            <path d="m9.5 7.5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/map_pinned.rs b/packages/yew/src/map_pinned.rs
new file mode 100644
index 0000000..a97c430
--- /dev/null
+++ b/packages/yew/src/map_pinned.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MapPinnedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MapPinned(props: &MapPinnedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M18 8c0 3.613-3.869 7.429-5.393 8.795a1 1 0 0 1-1.214 0C9.87 15.429 6 11.613 6 8a6 6 0 0 1 12 0"
+            />
+            <circle cx="12" cy="8" r="2" />
+            <path
+                d="M8.714 14h-3.71a1 1 0 0 0-.948.683l-2.004 6A1 1 0 0 0 3 22h18a1 1 0 0 0 .948-1.316l-2-6a1 1 0 0 0-.949-.684h-3.712"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/martini.rs b/packages/yew/src/martini.rs
new file mode 100644
index 0000000..eeebf5c
--- /dev/null
+++ b/packages/yew/src/martini.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MartiniProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Martini(props: &MartiniProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 22h8" />
+            <path d="M12 11v11" />
+            <path d="m19 3-7 8-7-8Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/maximize.rs b/packages/yew/src/maximize.rs
new file mode 100644
index 0000000..605c77f
--- /dev/null
+++ b/packages/yew/src/maximize.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MaximizeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Maximize(props: &MaximizeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3H5a2 2 0 0 0-2 2v3" />
+            <path d="M21 8V5a2 2 0 0 0-2-2h-3" />
+            <path d="M3 16v3a2 2 0 0 0 2 2h3" />
+            <path d="M16 21h3a2 2 0 0 0 2-2v-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/maximize_2.rs b/packages/yew/src/maximize_2.rs
new file mode 100644
index 0000000..826d02c
--- /dev/null
+++ b/packages/yew/src/maximize_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Maximize2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Maximize2(props: &Maximize2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="15 3 21 3 21 9" />
+            <polyline points="9 21 3 21 3 15" />
+            <line x1="21" x2="14" y1="3" y2="10" />
+            <line x1="3" x2="10" y1="21" y2="14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/medal.rs b/packages/yew/src/medal.rs
new file mode 100644
index 0000000..91e3846
--- /dev/null
+++ b/packages/yew/src/medal.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MedalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Medal(props: &MedalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M7.21 15 2.66 7.14a2 2 0 0 1 .13-2.2L4.4 2.8A2 2 0 0 1 6 2h12a2 2 0 0 1 1.6.8l1.6 2.14a2 2 0 0 1 .14 2.2L16.79 15"
+            />
+            <path d="M11 12 5.12 2.2" />
+            <path d="m13 12 5.88-9.8" />
+            <path d="M8 7h8" />
+            <circle cx="12" cy="17" r="5" />
+            <path d="M12 18v-2h-.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/megaphone.rs b/packages/yew/src/megaphone.rs
new file mode 100644
index 0000000..51dce7b
--- /dev/null
+++ b/packages/yew/src/megaphone.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MegaphoneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Megaphone(props: &MegaphoneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m3 11 18-5v12L3 14v-3z" />
+            <path d="M11.6 16.8a3 3 0 1 1-5.8-1.6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/megaphone_off.rs b/packages/yew/src/megaphone_off.rs
new file mode 100644
index 0000000..44e1a23
--- /dev/null
+++ b/packages/yew/src/megaphone_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MegaphoneOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MegaphoneOff(props: &MegaphoneOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9.26 9.26 3 11v3l14.14 3.14" />
+            <path d="M21 15.34V6l-7.31 2.03" />
+            <path d="M11.6 16.8a3 3 0 1 1-5.8-1.6" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/meh.rs b/packages/yew/src/meh.rs
new file mode 100644
index 0000000..965ffeb
--- /dev/null
+++ b/packages/yew/src/meh.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MehProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Meh(props: &MehProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <line x1="8" x2="16" y1="15" y2="15" />
+            <line x1="9" x2="9.01" y1="9" y2="9" />
+            <line x1="15" x2="15.01" y1="9" y2="9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/memory_stick.rs b/packages/yew/src/memory_stick.rs
new file mode 100644
index 0000000..dc72a93
--- /dev/null
+++ b/packages/yew/src/memory_stick.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MemoryStickProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MemoryStick(props: &MemoryStickProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 19v-3" />
+            <path d="M10 19v-3" />
+            <path d="M14 19v-3" />
+            <path d="M18 19v-3" />
+            <path d="M8 11V9" />
+            <path d="M16 11V9" />
+            <path d="M12 11V9" />
+            <path d="M2 15h20" />
+            <path
+                d="M2 7a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1.1a2 2 0 0 0 0 3.837V17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-5.1a2 2 0 0 0 0-3.837Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/menu.rs b/packages/yew/src/menu.rs
new file mode 100644
index 0000000..798b504
--- /dev/null
+++ b/packages/yew/src/menu.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MenuProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Menu(props: &MenuProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="4" x2="20" y1="12" y2="12" />
+            <line x1="4" x2="20" y1="6" y2="6" />
+            <line x1="4" x2="20" y1="18" y2="18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/merge.rs b/packages/yew/src/merge.rs
new file mode 100644
index 0000000..e712cd3
--- /dev/null
+++ b/packages/yew/src/merge.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MergeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Merge(props: &MergeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 6 4-4 4 4" />
+            <path d="M12 2v10.3a4 4 0 0 1-1.172 2.872L4 22" />
+            <path d="m20 22-5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle.rs b/packages/yew/src/message_circle.rs
new file mode 100644
index 0000000..eae10b5
--- /dev/null
+++ b/packages/yew/src/message_circle.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircle(props: &MessageCircleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_code.rs b/packages/yew/src/message_circle_code.rs
new file mode 100644
index 0000000..76a2e59
--- /dev/null
+++ b/packages/yew/src/message_circle_code.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleCode(props: &MessageCircleCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9.5 8 12l2 2.5" />
+            <path d="m14 9.5 2 2.5-2 2.5" />
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_dashed.rs b/packages/yew/src/message_circle_dashed.rs
new file mode 100644
index 0000000..d5fa38d
--- /dev/null
+++ b/packages/yew/src/message_circle_dashed.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleDashed(props: &MessageCircleDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.5 3.1c-.5 0-1-.1-1.5-.1s-1 .1-1.5.1" />
+            <path d="M19.3 6.8a10.45 10.45 0 0 0-2.1-2.1" />
+            <path d="M20.9 13.5c.1-.5.1-1 .1-1.5s-.1-1-.1-1.5" />
+            <path d="M17.2 19.3a10.45 10.45 0 0 0 2.1-2.1" />
+            <path d="M10.5 20.9c.5.1 1 .1 1.5.1s1-.1 1.5-.1" />
+            <path d="M3.5 17.5 2 22l4.5-1.5" />
+            <path d="M3.1 10.5c0 .5-.1 1-.1 1.5s.1 1 .1 1.5" />
+            <path d="M6.8 4.7a10.45 10.45 0 0 0-2.1 2.1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_heart.rs b/packages/yew/src/message_circle_heart.rs
new file mode 100644
index 0000000..8b20889
--- /dev/null
+++ b/packages/yew/src/message_circle_heart.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleHeartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleHeart(props: &MessageCircleHeartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" />
+            <path
+                d="M15.8 9.2a2.5 2.5 0 0 0-3.5 0l-.3.4-.35-.3a2.42 2.42 0 1 0-3.2 3.6l3.6 3.5 3.6-3.5c1.2-1.2 1.1-2.7.2-3.7"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_more.rs b/packages/yew/src/message_circle_more.rs
new file mode 100644
index 0000000..5e96b93
--- /dev/null
+++ b/packages/yew/src/message_circle_more.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleMoreProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleMore(props: &MessageCircleMoreProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" />
+            <path d="M8 12h.01" />
+            <path d="M12 12h.01" />
+            <path d="M16 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_off.rs b/packages/yew/src/message_circle_off.rs
new file mode 100644
index 0000000..abc6124
--- /dev/null
+++ b/packages/yew/src/message_circle_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleOff(props: &MessageCircleOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20.5 14.9A9 9 0 0 0 9.1 3.5" />
+            <path d="m2 2 20 20" />
+            <path d="M5.6 5.6C3 8.3 2.2 12.5 4 16l-2 6 6-2c3.4 1.8 7.6 1.1 10.3-1.7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_plus.rs b/packages/yew/src/message_circle_plus.rs
new file mode 100644
index 0000000..3c2bbac
--- /dev/null
+++ b/packages/yew/src/message_circle_plus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCirclePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCirclePlus(props: &MessageCirclePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" />
+            <path d="M8 12h8" />
+            <path d="M12 8v8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_question.rs b/packages/yew/src/message_circle_question.rs
new file mode 100644
index 0000000..0491aee
--- /dev/null
+++ b/packages/yew/src/message_circle_question.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleQuestionProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleQuestion(props: &MessageCircleQuestionProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" />
+            <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" />
+            <path d="M12 17h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_reply.rs b/packages/yew/src/message_circle_reply.rs
new file mode 100644
index 0000000..0d10b27
--- /dev/null
+++ b/packages/yew/src/message_circle_reply.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleReplyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleReply(props: &MessageCircleReplyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" />
+            <path d="m10 15-3-3 3-3" />
+            <path d="M7 12h7a2 2 0 0 1 2 2v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_warning.rs b/packages/yew/src/message_circle_warning.rs
new file mode 100644
index 0000000..91074e3
--- /dev/null
+++ b/packages/yew/src/message_circle_warning.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleWarningProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleWarning(props: &MessageCircleWarningProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" />
+            <path d="M12 8v4" />
+            <path d="M12 16h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_circle_x.rs b/packages/yew/src/message_circle_x.rs
new file mode 100644
index 0000000..982d417
--- /dev/null
+++ b/packages/yew/src/message_circle_x.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageCircleXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageCircleX(props: &MessageCircleXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z" />
+            <path d="m15 9-6 6" />
+            <path d="m9 9 6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square.rs b/packages/yew/src/message_square.rs
new file mode 100644
index 0000000..ce28909
--- /dev/null
+++ b/packages/yew/src/message_square.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquare(props: &MessageSquareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_code.rs b/packages/yew/src/message_square_code.rs
new file mode 100644
index 0000000..69d249f
--- /dev/null
+++ b/packages/yew/src/message_square_code.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareCode(props: &MessageSquareCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 7.5 8 10l2 2.5" />
+            <path d="m14 7.5 2 2.5-2 2.5" />
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_dashed.rs b/packages/yew/src/message_square_dashed.rs
new file mode 100644
index 0000000..06bfdca
--- /dev/null
+++ b/packages/yew/src/message_square_dashed.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareDashed(props: &MessageSquareDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 17H7l-4 4v-7" />
+            <path d="M14 17h1" />
+            <path d="M14 3h1" />
+            <path d="M19 3a2 2 0 0 1 2 2" />
+            <path d="M21 14v1a2 2 0 0 1-2 2" />
+            <path d="M21 9v1" />
+            <path d="M3 9v1" />
+            <path d="M5 3a2 2 0 0 0-2 2" />
+            <path d="M9 3h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_diff.rs b/packages/yew/src/message_square_diff.rs
new file mode 100644
index 0000000..24c8cff
--- /dev/null
+++ b/packages/yew/src/message_square_diff.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareDiffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareDiff(props: &MessageSquareDiffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m5 19-2 2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2" />
+            <path d="M9 10h6" />
+            <path d="M12 7v6" />
+            <path d="M9 17h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_dot.rs b/packages/yew/src/message_square_dot.rs
new file mode 100644
index 0000000..bd8e557
--- /dev/null
+++ b/packages/yew/src/message_square_dot.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareDot(props: &MessageSquareDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.7 3H5a2 2 0 0 0-2 2v16l4-4h12a2 2 0 0 0 2-2v-2.7" />
+            <circle cx="18" cy="6" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_heart.rs b/packages/yew/src/message_square_heart.rs
new file mode 100644
index 0000000..b5702ac
--- /dev/null
+++ b/packages/yew/src/message_square_heart.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareHeartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareHeart(props: &MessageSquareHeartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+            <path
+                d="M14.8 7.5a1.84 1.84 0 0 0-2.6 0l-.2.3-.3-.3a1.84 1.84 0 1 0-2.4 2.8L12 13l2.7-2.7c.9-.9.8-2.1.1-2.8"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_lock.rs b/packages/yew/src/message_square_lock.rs
new file mode 100644
index 0000000..222df1e
--- /dev/null
+++ b/packages/yew/src/message_square_lock.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareLockProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareLock(props: &MessageSquareLockProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 15v-2a2 2 0 1 0-4 0v2" />
+            <path d="M9 17H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v3.5" />
+            <rect x="13" y="15" width="8" height="5" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_more.rs b/packages/yew/src/message_square_more.rs
new file mode 100644
index 0000000..61fed52
--- /dev/null
+++ b/packages/yew/src/message_square_more.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareMoreProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareMore(props: &MessageSquareMoreProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+            <path d="M8 10h.01" />
+            <path d="M12 10h.01" />
+            <path d="M16 10h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_off.rs b/packages/yew/src/message_square_off.rs
new file mode 100644
index 0000000..fb54d78
--- /dev/null
+++ b/packages/yew/src/message_square_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareOff(props: &MessageSquareOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15V5a2 2 0 0 0-2-2H9" />
+            <path d="m2 2 20 20" />
+            <path d="M3.6 3.6c-.4.3-.6.8-.6 1.4v16l4-4h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_plus.rs b/packages/yew/src/message_square_plus.rs
new file mode 100644
index 0000000..f0769f6
--- /dev/null
+++ b/packages/yew/src/message_square_plus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquarePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquarePlus(props: &MessageSquarePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+            <path d="M12 7v6" />
+            <path d="M9 10h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_quote.rs b/packages/yew/src/message_square_quote.rs
new file mode 100644
index 0000000..2cfccf6
--- /dev/null
+++ b/packages/yew/src/message_square_quote.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareQuoteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareQuote(props: &MessageSquareQuoteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+            <path d="M8 12a2 2 0 0 0 2-2V8H8" />
+            <path d="M14 12a2 2 0 0 0 2-2V8h-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_reply.rs b/packages/yew/src/message_square_reply.rs
new file mode 100644
index 0000000..cffe3fa
--- /dev/null
+++ b/packages/yew/src/message_square_reply.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareReplyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareReply(props: &MessageSquareReplyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+            <path d="m10 7-3 3 3 3" />
+            <path d="M17 13v-1a2 2 0 0 0-2-2H7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_share.rs b/packages/yew/src/message_square_share.rs
new file mode 100644
index 0000000..5d1b8af
--- /dev/null
+++ b/packages/yew/src/message_square_share.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareShareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareShare(props: &MessageSquareShareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12v3a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h7" />
+            <path d="M16 3h5v5" />
+            <path d="m16 8 5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_text.rs b/packages/yew/src/message_square_text.rs
new file mode 100644
index 0000000..cd40297
--- /dev/null
+++ b/packages/yew/src/message_square_text.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareText(props: &MessageSquareTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+            <path d="M13 8H7" />
+            <path d="M17 12H7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_warning.rs b/packages/yew/src/message_square_warning.rs
new file mode 100644
index 0000000..c3a46c1
--- /dev/null
+++ b/packages/yew/src/message_square_warning.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareWarningProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareWarning(props: &MessageSquareWarningProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+            <path d="M12 7v2" />
+            <path d="M12 13h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/message_square_x.rs b/packages/yew/src/message_square_x.rs
new file mode 100644
index 0000000..0432cec
--- /dev/null
+++ b/packages/yew/src/message_square_x.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessageSquareXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessageSquareX(props: &MessageSquareXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+            <path d="m14.5 7.5-5 5" />
+            <path d="m9.5 7.5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/messages_square.rs b/packages/yew/src/messages_square.rs
new file mode 100644
index 0000000..e980c5c
--- /dev/null
+++ b/packages/yew/src/messages_square.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MessagesSquareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MessagesSquare(props: &MessagesSquareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 9a2 2 0 0 1-2 2H6l-4 4V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2z" />
+            <path d="M18 9h2a2 2 0 0 1 2 2v11l-4-4h-6a2 2 0 0 1-2-2v-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mic.rs b/packages/yew/src/mic.rs
new file mode 100644
index 0000000..4ab589a
--- /dev/null
+++ b/packages/yew/src/mic.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MicProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Mic(props: &MicProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2a3 3 0 0 0-3 3v7a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3Z" />
+            <path d="M19 10v2a7 7 0 0 1-14 0v-2" />
+            <line x1="12" x2="12" y1="19" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mic_off.rs b/packages/yew/src/mic_off.rs
new file mode 100644
index 0000000..1d32c2e
--- /dev/null
+++ b/packages/yew/src/mic_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MicOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MicOff(props: &MicOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="22" y1="2" y2="22" />
+            <path d="M18.89 13.23A7.12 7.12 0 0 0 19 12v-2" />
+            <path d="M5 10v2a7 7 0 0 0 12 5" />
+            <path d="M15 9.34V5a3 3 0 0 0-5.68-1.33" />
+            <path d="M9 9v3a3 3 0 0 0 5.12 2.12" />
+            <line x1="12" x2="12" y1="19" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mic_vocal.rs b/packages/yew/src/mic_vocal.rs
new file mode 100644
index 0000000..e816206
--- /dev/null
+++ b/packages/yew/src/mic_vocal.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MicVocalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MicVocal(props: &MicVocalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m11 7.601-5.994 8.19a1 1 0 0 0 .1 1.298l.817.818a1 1 0 0 0 1.314.087L15.09 12"
+            />
+            <path
+                d="M16.5 21.174C15.5 20.5 14.372 20 13 20c-2.058 0-3.928 2.356-6 2-2.072-.356-2.775-3.369-1.5-4.5"
+            />
+            <circle cx="16" cy="7" r="5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/microchip.rs b/packages/yew/src/microchip.rs
new file mode 100644
index 0000000..58bb02a
--- /dev/null
+++ b/packages/yew/src/microchip.rs
@@ -0,0 +1,56 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MicrochipProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Microchip(props: &MicrochipProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 12h2" />
+            <path d="M18 16h2" />
+            <path d="M18 20h2" />
+            <path d="M18 4h2" />
+            <path d="M18 8h2" />
+            <path d="M4 12h2" />
+            <path d="M4 16h2" />
+            <path d="M4 20h2" />
+            <path d="M4 4h2" />
+            <path d="M4 8h2" />
+            <path
+                d="M8 2a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2h-1.5c-.276 0-.494.227-.562.495a2 2 0 0 1-3.876 0C9.994 2.227 9.776 2 9.5 2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/microscope.rs b/packages/yew/src/microscope.rs
new file mode 100644
index 0000000..aafe0e4
--- /dev/null
+++ b/packages/yew/src/microscope.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MicroscopeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Microscope(props: &MicroscopeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 18h8" />
+            <path d="M3 22h18" />
+            <path d="M14 22a7 7 0 1 0 0-14h-1" />
+            <path d="M9 14h2" />
+            <path d="M9 12a2 2 0 0 1-2-2V6h6v4a2 2 0 0 1-2 2Z" />
+            <path d="M12 6V3a1 1 0 0 0-1-1H9a1 1 0 0 0-1 1v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/microwave.rs b/packages/yew/src/microwave.rs
new file mode 100644
index 0000000..8e4ed85
--- /dev/null
+++ b/packages/yew/src/microwave.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MicrowaveProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Microwave(props: &MicrowaveProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="15" x="2" y="4" rx="2" />
+            <rect width="8" height="7" x="6" y="8" rx="1" />
+            <path d="M18 8v7" />
+            <path d="M6 19v2" />
+            <path d="M18 19v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/milestone.rs b/packages/yew/src/milestone.rs
new file mode 100644
index 0000000..3c3a952
--- /dev/null
+++ b/packages/yew/src/milestone.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MilestoneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Milestone(props: &MilestoneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13v8" />
+            <path d="M12 3v3" />
+            <path
+                d="M4 6a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1h13a2 2 0 0 0 1.152-.365l3.424-2.317a1 1 0 0 0 0-1.635l-3.424-2.318A2 2 0 0 0 17 6z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/milk.rs b/packages/yew/src/milk.rs
new file mode 100644
index 0000000..3de22cd
--- /dev/null
+++ b/packages/yew/src/milk.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MilkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Milk(props: &MilkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2h8" />
+            <path
+                d="M9 2v2.789a4 4 0 0 1-.672 2.219l-.656.984A4 4 0 0 0 7 10.212V20a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-9.789a4 4 0 0 0-.672-2.219l-.656-.984A4 4 0 0 1 15 4.788V2"
+            />
+            <path d="M7 15a6.472 6.472 0 0 1 5 0 6.47 6.47 0 0 0 5 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/milk_off.rs b/packages/yew/src/milk_off.rs
new file mode 100644
index 0000000..054a1b3
--- /dev/null
+++ b/packages/yew/src/milk_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MilkOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MilkOff(props: &MilkOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2h8" />
+            <path
+                d="M9 2v1.343M15 2v2.789a4 4 0 0 0 .672 2.219l.656.984a4 4 0 0 1 .672 2.22v1.131M7.8 7.8l-.128.192A4 4 0 0 0 7 10.212V20a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-3"
+            />
+            <path d="M7 15a6.47 6.47 0 0 1 5 0 6.472 6.472 0 0 0 3.435.435" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/minimize.rs b/packages/yew/src/minimize.rs
new file mode 100644
index 0000000..658140e
--- /dev/null
+++ b/packages/yew/src/minimize.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MinimizeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Minimize(props: &MinimizeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3v3a2 2 0 0 1-2 2H3" />
+            <path d="M21 8h-3a2 2 0 0 1-2-2V3" />
+            <path d="M3 16h3a2 2 0 0 1 2 2v3" />
+            <path d="M16 21v-3a2 2 0 0 1 2-2h3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/minimize_2.rs b/packages/yew/src/minimize_2.rs
new file mode 100644
index 0000000..81d46f2
--- /dev/null
+++ b/packages/yew/src/minimize_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Minimize2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Minimize2(props: &Minimize2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="4 14 10 14 10 20" />
+            <polyline points="20 10 14 10 14 4" />
+            <line x1="14" x2="21" y1="10" y2="3" />
+            <line x1="3" x2="10" y1="21" y2="14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/minus.rs b/packages/yew/src/minus.rs
new file mode 100644
index 0000000..d62939f
--- /dev/null
+++ b/packages/yew/src/minus.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Minus(props: &MinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 12h14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor.rs b/packages/yew/src/monitor.rs
new file mode 100644
index 0000000..d388d12
--- /dev/null
+++ b/packages/yew/src/monitor.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Monitor(props: &MonitorProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="14" x="2" y="3" rx="2" />
+            <line x1="8" x2="16" y1="21" y2="21" />
+            <line x1="12" x2="12" y1="17" y2="21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_check.rs b/packages/yew/src/monitor_check.rs
new file mode 100644
index 0000000..e993ce1
--- /dev/null
+++ b/packages/yew/src/monitor_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorCheck(props: &MonitorCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 10 2 2 4-4" />
+            <rect width="20" height="14" x="2" y="3" rx="2" />
+            <path d="M12 17v4" />
+            <path d="M8 21h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_cog.rs b/packages/yew/src/monitor_cog.rs
new file mode 100644
index 0000000..3afd678
--- /dev/null
+++ b/packages/yew/src/monitor_cog.rs
@@ -0,0 +1,55 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorCog(props: &MonitorCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17v4" />
+            <path d="m15.2 4.9-.9-.4" />
+            <path d="m15.2 7.1-.9.4" />
+            <path d="m16.9 3.2-.4-.9" />
+            <path d="m16.9 8.8-.4.9" />
+            <path d="m19.5 2.3-.4.9" />
+            <path d="m19.5 9.7-.4-.9" />
+            <path d="m21.7 4.5-.9.4" />
+            <path d="m21.7 7.5-.9-.4" />
+            <path d="M22 13v2a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7" />
+            <path d="M8 21h8" />
+            <circle cx="18" cy="6" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_dot.rs b/packages/yew/src/monitor_dot.rs
new file mode 100644
index 0000000..bf12624
--- /dev/null
+++ b/packages/yew/src/monitor_dot.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorDot(props: &MonitorDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="19" cy="6" r="3" />
+            <path d="M22 12v3a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h9" />
+            <path d="M12 17v4" />
+            <path d="M8 21h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_down.rs b/packages/yew/src/monitor_down.rs
new file mode 100644
index 0000000..3a47a43
--- /dev/null
+++ b/packages/yew/src/monitor_down.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorDown(props: &MonitorDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13V7" />
+            <path d="m15 10-3 3-3-3" />
+            <rect width="20" height="14" x="2" y="3" rx="2" />
+            <path d="M12 17v4" />
+            <path d="M8 21h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_off.rs b/packages/yew/src/monitor_off.rs
new file mode 100644
index 0000000..de6fd37
--- /dev/null
+++ b/packages/yew/src/monitor_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorOff(props: &MonitorOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 17H4a2 2 0 0 1-2-2V5c0-1.5 1-2 1-2" />
+            <path d="M22 15V5a2 2 0 0 0-2-2H9" />
+            <path d="M8 21h8" />
+            <path d="M12 17v4" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_pause.rs b/packages/yew/src/monitor_pause.rs
new file mode 100644
index 0000000..59b533f
--- /dev/null
+++ b/packages/yew/src/monitor_pause.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorPauseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorPause(props: &MonitorPauseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 13V7" />
+            <path d="M14 13V7" />
+            <rect width="20" height="14" x="2" y="3" rx="2" />
+            <path d="M12 17v4" />
+            <path d="M8 21h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_play.rs b/packages/yew/src/monitor_play.rs
new file mode 100644
index 0000000..2aa3aab
--- /dev/null
+++ b/packages/yew/src/monitor_play.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorPlayProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorPlay(props: &MonitorPlayProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10 7.75a.75.75 0 0 1 1.142-.638l3.664 2.249a.75.75 0 0 1 0 1.278l-3.664 2.25a.75.75 0 0 1-1.142-.64z"
+            />
+            <path d="M12 17v4" />
+            <path d="M8 21h8" />
+            <rect x="2" y="3" width="20" height="14" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_smartphone.rs b/packages/yew/src/monitor_smartphone.rs
new file mode 100644
index 0000000..0ac15ed
--- /dev/null
+++ b/packages/yew/src/monitor_smartphone.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorSmartphoneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorSmartphone(props: &MonitorSmartphoneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 8V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v7a2 2 0 0 0 2 2h8" />
+            <path d="M10 19v-3.96 3.15" />
+            <path d="M7 19h5" />
+            <rect width="6" height="10" x="16" y="12" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_speaker.rs b/packages/yew/src/monitor_speaker.rs
new file mode 100644
index 0000000..22b0386
--- /dev/null
+++ b/packages/yew/src/monitor_speaker.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorSpeakerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorSpeaker(props: &MonitorSpeakerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5.5 20H8" />
+            <path d="M17 9h.01" />
+            <rect width="10" height="16" x="12" y="4" rx="2" />
+            <path d="M8 6H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h4" />
+            <circle cx="17" cy="15" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_stop.rs b/packages/yew/src/monitor_stop.rs
new file mode 100644
index 0000000..1b80036
--- /dev/null
+++ b/packages/yew/src/monitor_stop.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorStopProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorStop(props: &MonitorStopProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17v4" />
+            <path d="M8 21h8" />
+            <rect x="2" y="3" width="20" height="14" rx="2" />
+            <rect x="9" y="7" width="6" height="6" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_up.rs b/packages/yew/src/monitor_up.rs
new file mode 100644
index 0000000..38b61af
--- /dev/null
+++ b/packages/yew/src/monitor_up.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorUp(props: &MonitorUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 10 3-3 3 3" />
+            <path d="M12 13V7" />
+            <rect width="20" height="14" x="2" y="3" rx="2" />
+            <path d="M12 17v4" />
+            <path d="M8 21h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/monitor_x.rs b/packages/yew/src/monitor_x.rs
new file mode 100644
index 0000000..800f7af
--- /dev/null
+++ b/packages/yew/src/monitor_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MonitorXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MonitorX(props: &MonitorXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14.5 12.5-5-5" />
+            <path d="m9.5 12.5 5-5" />
+            <rect width="20" height="14" x="2" y="3" rx="2" />
+            <path d="M12 17v4" />
+            <path d="M8 21h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/moon.rs b/packages/yew/src/moon.rs
new file mode 100644
index 0000000..b648d6b
--- /dev/null
+++ b/packages/yew/src/moon.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoonProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Moon(props: &MoonProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/moon_star.rs b/packages/yew/src/moon_star.rs
new file mode 100644
index 0000000..14e826c
--- /dev/null
+++ b/packages/yew/src/moon_star.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoonStarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoonStar(props: &MoonStarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9" />
+            <path d="M20 3v4" />
+            <path d="M22 5h-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mountain.rs b/packages/yew/src/mountain.rs
new file mode 100644
index 0000000..149c118
--- /dev/null
+++ b/packages/yew/src/mountain.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MountainProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Mountain(props: &MountainProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 3 4 8 5-5 5 15H2L8 3z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mountain_snow.rs b/packages/yew/src/mountain_snow.rs
new file mode 100644
index 0000000..8b08e41
--- /dev/null
+++ b/packages/yew/src/mountain_snow.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MountainSnowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MountainSnow(props: &MountainSnowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 3 4 8 5-5 5 15H2L8 3z" />
+            <path d="M4.14 15.08c2.62-1.57 5.24-1.43 7.86.42 2.74 1.94 5.49 2 8.23.19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mouse.rs b/packages/yew/src/mouse.rs
new file mode 100644
index 0000000..1e2b34b
--- /dev/null
+++ b/packages/yew/src/mouse.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MouseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Mouse(props: &MouseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="5" y="2" width="14" height="20" rx="7" />
+            <path d="M12 6v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mouse_off.rs b/packages/yew/src/mouse_off.rs
new file mode 100644
index 0000000..d2d56a7
--- /dev/null
+++ b/packages/yew/src/mouse_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MouseOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MouseOff(props: &MouseOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 6v.343" />
+            <path d="M18.218 18.218A7 7 0 0 1 5 15V9a7 7 0 0 1 .782-3.218" />
+            <path d="M19 13.343V9A7 7 0 0 0 8.56 2.902" />
+            <path d="M22 22 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mouse_pointer.rs b/packages/yew/src/mouse_pointer.rs
new file mode 100644
index 0000000..e1ce3ce
--- /dev/null
+++ b/packages/yew/src/mouse_pointer.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MousePointerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MousePointer(props: &MousePointerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.586 12.586 19 19" />
+            <path
+                d="M3.688 3.037a.497.497 0 0 0-.651.651l6.5 15.999a.501.501 0 0 0 .947-.062l1.569-6.083a2 2 0 0 1 1.448-1.479l6.124-1.579a.5.5 0 0 0 .063-.947z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mouse_pointer_2.rs b/packages/yew/src/mouse_pointer_2.rs
new file mode 100644
index 0000000..a03d44a
--- /dev/null
+++ b/packages/yew/src/mouse_pointer_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MousePointer2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MousePointer2(props: &MousePointer2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4.037 4.688a.495.495 0 0 1 .651-.651l16 6.5a.5.5 0 0 1-.063.947l-6.124 1.58a2 2 0 0 0-1.438 1.435l-1.579 6.126a.5.5 0 0 1-.947.063z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mouse_pointer_ban.rs b/packages/yew/src/mouse_pointer_ban.rs
new file mode 100644
index 0000000..8c75174
--- /dev/null
+++ b/packages/yew/src/mouse_pointer_ban.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MousePointerBanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MousePointerBan(props: &MousePointerBanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.034 2.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.944L8.204 7.545a1 1 0 0 0-.66.66l-1.066 3.443a.5.5 0 0 1-.944.033z"
+            />
+            <circle cx="16" cy="16" r="6" />
+            <path d="m11.8 11.8 8.4 8.4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/mouse_pointer_click.rs b/packages/yew/src/mouse_pointer_click.rs
new file mode 100644
index 0000000..45e6776
--- /dev/null
+++ b/packages/yew/src/mouse_pointer_click.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MousePointerClickProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MousePointerClick(props: &MousePointerClickProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 4.1 12 6" />
+            <path d="m5.1 8-2.9-.8" />
+            <path d="m6 12-1.9 2" />
+            <path d="M7.2 2.2 8 5.1" />
+            <path
+                d="M9.037 9.69a.498.498 0 0 1 .653-.653l11 4.5a.5.5 0 0 1-.074.949l-4.349 1.041a1 1 0 0 0-.74.739l-1.04 4.35a.5.5 0 0 1-.95.074z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move.rs b/packages/yew/src/move.rs
new file mode 100644
index 0000000..efc445b
--- /dev/null
+++ b/packages/yew/src/move.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Move(props: &MoveProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v20" />
+            <path d="m15 19-3 3-3-3" />
+            <path d="m19 9 3 3-3 3" />
+            <path d="M2 12h20" />
+            <path d="m5 9-3 3 3 3" />
+            <path d="m9 5 3-3 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_3_d.rs b/packages/yew/src/move_3_d.rs
new file mode 100644
index 0000000..fa30020
--- /dev/null
+++ b/packages/yew/src/move_3_d.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Move3DProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Move3D(props: &Move3DProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 3v16h16" />
+            <path d="m5 19 6-6" />
+            <path d="m2 6 3-3 3 3" />
+            <path d="m18 16 3 3-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_diagonal.rs b/packages/yew/src/move_diagonal.rs
new file mode 100644
index 0000000..24efae9
--- /dev/null
+++ b/packages/yew/src/move_diagonal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveDiagonalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveDiagonal(props: &MoveDiagonalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 19H5v-6" />
+            <path d="M13 5h6v6" />
+            <path d="M19 5 5 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_diagonal_2.rs b/packages/yew/src/move_diagonal_2.rs
new file mode 100644
index 0000000..980d55c
--- /dev/null
+++ b/packages/yew/src/move_diagonal_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveDiagonal2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveDiagonal2(props: &MoveDiagonal2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 13v6h-6" />
+            <path d="M5 11V5h6" />
+            <path d="m5 5 14 14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_down.rs b/packages/yew/src/move_down.rs
new file mode 100644
index 0000000..1e0aa0a
--- /dev/null
+++ b/packages/yew/src/move_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveDown(props: &MoveDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 18L12 22L16 18" />
+            <path d="M12 2V22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_down_left.rs b/packages/yew/src/move_down_left.rs
new file mode 100644
index 0000000..968d171
--- /dev/null
+++ b/packages/yew/src/move_down_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveDownLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveDownLeft(props: &MoveDownLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 19H5V13" />
+            <path d="M19 5L5 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_down_right.rs b/packages/yew/src/move_down_right.rs
new file mode 100644
index 0000000..574ecb7
--- /dev/null
+++ b/packages/yew/src/move_down_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveDownRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveDownRight(props: &MoveDownRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 13V19H13" />
+            <path d="M5 5L19 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_horizontal.rs b/packages/yew/src/move_horizontal.rs
new file mode 100644
index 0000000..e553bfd
--- /dev/null
+++ b/packages/yew/src/move_horizontal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveHorizontal(props: &MoveHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 8 4 4-4 4" />
+            <path d="M2 12h20" />
+            <path d="m6 8-4 4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_left.rs b/packages/yew/src/move_left.rs
new file mode 100644
index 0000000..71cf792
--- /dev/null
+++ b/packages/yew/src/move_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveLeft(props: &MoveLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8L2 12L6 16" />
+            <path d="M2 12H22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_right.rs b/packages/yew/src/move_right.rs
new file mode 100644
index 0000000..7aaa57e
--- /dev/null
+++ b/packages/yew/src/move_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveRight(props: &MoveRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 8L22 12L18 16" />
+            <path d="M2 12H22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_up.rs b/packages/yew/src/move_up.rs
new file mode 100644
index 0000000..56fa721
--- /dev/null
+++ b/packages/yew/src/move_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveUp(props: &MoveUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 6L12 2L16 6" />
+            <path d="M12 2V22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_up_left.rs b/packages/yew/src/move_up_left.rs
new file mode 100644
index 0000000..33a20df
--- /dev/null
+++ b/packages/yew/src/move_up_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveUpLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveUpLeft(props: &MoveUpLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 11V5H11" />
+            <path d="M5 5L19 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_up_right.rs b/packages/yew/src/move_up_right.rs
new file mode 100644
index 0000000..b655fa0
--- /dev/null
+++ b/packages/yew/src/move_up_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveUpRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveUpRight(props: &MoveUpRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 5H19V11" />
+            <path d="M19 5L5 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/move_vertical.rs b/packages/yew/src/move_vertical.rs
new file mode 100644
index 0000000..bbc721d
--- /dev/null
+++ b/packages/yew/src/move_vertical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MoveVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn MoveVertical(props: &MoveVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v20" />
+            <path d="m8 18 4 4 4-4" />
+            <path d="m8 6 4-4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/music.rs b/packages/yew/src/music.rs
new file mode 100644
index 0000000..1ee548c
--- /dev/null
+++ b/packages/yew/src/music.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct MusicProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Music(props: &MusicProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 18V5l12-2v13" />
+            <circle cx="6" cy="18" r="3" />
+            <circle cx="18" cy="16" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/music_2.rs b/packages/yew/src/music_2.rs
new file mode 100644
index 0000000..4ee9a34
--- /dev/null
+++ b/packages/yew/src/music_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Music2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Music2(props: &Music2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="8" cy="18" r="4" />
+            <path d="M12 18V2l7 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/music_3.rs b/packages/yew/src/music_3.rs
new file mode 100644
index 0000000..b59f3f7
--- /dev/null
+++ b/packages/yew/src/music_3.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Music3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Music3(props: &Music3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="18" r="4" />
+            <path d="M16 18V2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/music_4.rs b/packages/yew/src/music_4.rs
new file mode 100644
index 0000000..fb4d380
--- /dev/null
+++ b/packages/yew/src/music_4.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Music4Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Music4(props: &Music4Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 18V5l12-2v13" />
+            <path d="m9 9 12-2" />
+            <circle cx="6" cy="18" r="3" />
+            <circle cx="18" cy="16" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/navigation.rs b/packages/yew/src/navigation.rs
new file mode 100644
index 0000000..1d4b76e
--- /dev/null
+++ b/packages/yew/src/navigation.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NavigationProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Navigation(props: &NavigationProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="3 11 22 2 13 21 11 13 3 11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/navigation_2.rs b/packages/yew/src/navigation_2.rs
new file mode 100644
index 0000000..63600ce
--- /dev/null
+++ b/packages/yew/src/navigation_2.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Navigation2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Navigation2(props: &Navigation2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="12 2 19 21 12 17 5 21 12 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/navigation_2_off.rs b/packages/yew/src/navigation_2_off.rs
new file mode 100644
index 0000000..e495557
--- /dev/null
+++ b/packages/yew/src/navigation_2_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Navigation2OffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Navigation2Off(props: &Navigation2OffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9.31 9.31 5 21l7-4 7 4-1.17-3.17" />
+            <path d="M14.53 8.88 12 2l-1.17 3.17" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/navigation_off.rs b/packages/yew/src/navigation_off.rs
new file mode 100644
index 0000000..cbecde5
--- /dev/null
+++ b/packages/yew/src/navigation_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NavigationOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn NavigationOff(props: &NavigationOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.43 8.43 3 11l8 2 2 8 2.57-5.43" />
+            <path d="M17.39 11.73 22 2l-9.73 4.61" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/network.rs b/packages/yew/src/network.rs
new file mode 100644
index 0000000..8ba4126
--- /dev/null
+++ b/packages/yew/src/network.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NetworkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Network(props: &NetworkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="16" y="16" width="6" height="6" rx="1" />
+            <rect x="2" y="16" width="6" height="6" rx="1" />
+            <rect x="9" y="2" width="6" height="6" rx="1" />
+            <path d="M5 16v-3a1 1 0 0 1 1-1h12a1 1 0 0 1 1 1v3" />
+            <path d="M12 12V8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/newspaper.rs b/packages/yew/src/newspaper.rs
new file mode 100644
index 0000000..ca5c390
--- /dev/null
+++ b/packages/yew/src/newspaper.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NewspaperProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Newspaper(props: &NewspaperProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 22h16a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v16a2 2 0 0 1-2 2Zm0 0a2 2 0 0 1-2-2v-9c0-1.1.9-2 2-2h2"
+            />
+            <path d="M18 14h-8" />
+            <path d="M15 18h-5" />
+            <path d="M10 6h8v4h-8V6Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/nfc.rs b/packages/yew/src/nfc.rs
new file mode 100644
index 0000000..945f843
--- /dev/null
+++ b/packages/yew/src/nfc.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NfcProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Nfc(props: &NfcProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 8.32a7.43 7.43 0 0 1 0 7.36" />
+            <path d="M9.46 6.21a11.76 11.76 0 0 1 0 11.58" />
+            <path d="M12.91 4.1a15.91 15.91 0 0 1 .01 15.8" />
+            <path d="M16.37 2a20.16 20.16 0 0 1 0 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/notebook.rs b/packages/yew/src/notebook.rs
new file mode 100644
index 0000000..e1ff36a
--- /dev/null
+++ b/packages/yew/src/notebook.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NotebookProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Notebook(props: &NotebookProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 6h4" />
+            <path d="M2 10h4" />
+            <path d="M2 14h4" />
+            <path d="M2 18h4" />
+            <rect width="16" height="20" x="4" y="2" rx="2" />
+            <path d="M16 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/notebook_pen.rs b/packages/yew/src/notebook_pen.rs
new file mode 100644
index 0000000..b87d3b4
--- /dev/null
+++ b/packages/yew/src/notebook_pen.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NotebookPenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn NotebookPen(props: &NotebookPenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.4 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-7.4" />
+            <path d="M2 6h4" />
+            <path d="M2 10h4" />
+            <path d="M2 14h4" />
+            <path d="M2 18h4" />
+            <path
+                d="M21.378 5.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/notebook_tabs.rs b/packages/yew/src/notebook_tabs.rs
new file mode 100644
index 0000000..166b55a
--- /dev/null
+++ b/packages/yew/src/notebook_tabs.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NotebookTabsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn NotebookTabs(props: &NotebookTabsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 6h4" />
+            <path d="M2 10h4" />
+            <path d="M2 14h4" />
+            <path d="M2 18h4" />
+            <rect width="16" height="20" x="4" y="2" rx="2" />
+            <path d="M15 2v20" />
+            <path d="M15 7h5" />
+            <path d="M15 12h5" />
+            <path d="M15 17h5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/notebook_text.rs b/packages/yew/src/notebook_text.rs
new file mode 100644
index 0000000..9e6f630
--- /dev/null
+++ b/packages/yew/src/notebook_text.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NotebookTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn NotebookText(props: &NotebookTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 6h4" />
+            <path d="M2 10h4" />
+            <path d="M2 14h4" />
+            <path d="M2 18h4" />
+            <rect width="16" height="20" x="4" y="2" rx="2" />
+            <path d="M9.5 8h5" />
+            <path d="M9.5 12H16" />
+            <path d="M9.5 16H14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/notepad_text.rs b/packages/yew/src/notepad_text.rs
new file mode 100644
index 0000000..7ca4de5
--- /dev/null
+++ b/packages/yew/src/notepad_text.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NotepadTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn NotepadText(props: &NotepadTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M12 2v4" />
+            <path d="M16 2v4" />
+            <rect width="16" height="18" x="4" y="4" rx="2" />
+            <path d="M8 10h6" />
+            <path d="M8 14h8" />
+            <path d="M8 18h5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/notepad_text_dashed.rs b/packages/yew/src/notepad_text_dashed.rs
new file mode 100644
index 0000000..f68e4fe
--- /dev/null
+++ b/packages/yew/src/notepad_text_dashed.rs
@@ -0,0 +1,56 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NotepadTextDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn NotepadTextDashed(props: &NotepadTextDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 2v4" />
+            <path d="M12 2v4" />
+            <path d="M16 2v4" />
+            <path d="M16 4h2a2 2 0 0 1 2 2v2" />
+            <path d="M20 12v2" />
+            <path d="M20 18v2a2 2 0 0 1-2 2h-1" />
+            <path d="M13 22h-2" />
+            <path d="M7 22H6a2 2 0 0 1-2-2v-2" />
+            <path d="M4 14v-2" />
+            <path d="M4 8V6a2 2 0 0 1 2-2h2" />
+            <path d="M8 10h6" />
+            <path d="M8 14h8" />
+            <path d="M8 18h5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/nut.rs b/packages/yew/src/nut.rs
new file mode 100644
index 0000000..3571ce0
--- /dev/null
+++ b/packages/yew/src/nut.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NutProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Nut(props: &NutProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 4V2" />
+            <path
+                d="M5 10v4a7.004 7.004 0 0 0 5.277 6.787c.412.104.802.292 1.102.592L12 22l.621-.621c.3-.3.69-.488 1.102-.592A7.003 7.003 0 0 0 19 14v-4"
+            />
+            <path
+                d="M12 4C8 4 4.5 6 4 8c-.243.97-.919 1.952-2 3 1.31-.082 1.972-.29 3-1 .54.92.982 1.356 2 2 1.452-.647 1.954-1.098 2.5-2 .595.995 1.151 1.427 2.5 2 1.31-.621 1.862-1.058 2.5-2 .629.977 1.162 1.423 2.5 2 1.209-.548 1.68-.967 2-2 1.032.916 1.683 1.157 3 1-1.297-1.036-1.758-2.03-2-3-.5-2-4-4-8-4Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/nut_off.rs b/packages/yew/src/nut_off.rs
new file mode 100644
index 0000000..10840c8
--- /dev/null
+++ b/packages/yew/src/nut_off.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct NutOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn NutOff(props: &NutOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 4V2" />
+            <path
+                d="M5 10v4a7.004 7.004 0 0 0 5.277 6.787c.412.104.802.292 1.102.592L12 22l.621-.621c.3-.3.69-.488 1.102-.592a7.01 7.01 0 0 0 4.125-2.939"
+            />
+            <path d="M19 10v3.343" />
+            <path
+                d="M12 12c-1.349-.573-1.905-1.005-2.5-2-.546.902-1.048 1.353-2.5 2-1.018-.644-1.46-1.08-2-2-1.028.71-1.69.918-3 1 1.081-1.048 1.757-2.03 2-3 .194-.776.84-1.551 1.79-2.21m11.654 5.997c.887-.457 1.28-.891 1.556-1.787 1.032.916 1.683 1.157 3 1-1.297-1.036-1.758-2.03-2-3-.5-2-4-4-8-4-.74 0-1.461.068-2.15.192"
+            />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/octagon.rs b/packages/yew/src/octagon.rs
new file mode 100644
index 0000000..d852b5f
--- /dev/null
+++ b/packages/yew/src/octagon.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OctagonProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Octagon(props: &OctagonProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/octagon_alert.rs b/packages/yew/src/octagon_alert.rs
new file mode 100644
index 0000000..559e43a
--- /dev/null
+++ b/packages/yew/src/octagon_alert.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OctagonAlertProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn OctagonAlert(props: &OctagonAlertProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 16h.01" />
+            <path d="M12 8v4" />
+            <path
+                d="M15.312 2a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586l-4.688-4.688A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/octagon_minus.rs b/packages/yew/src/octagon_minus.rs
new file mode 100644
index 0000000..28d8ebb
--- /dev/null
+++ b/packages/yew/src/octagon_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OctagonMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn OctagonMinus(props: &OctagonMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"
+            />
+            <path d="M8 12h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/octagon_pause.rs b/packages/yew/src/octagon_pause.rs
new file mode 100644
index 0000000..957c531
--- /dev/null
+++ b/packages/yew/src/octagon_pause.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OctagonPauseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn OctagonPause(props: &OctagonPauseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 15V9" />
+            <path d="M14 15V9" />
+            <path
+                d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/octagon_x.rs b/packages/yew/src/octagon_x.rs
new file mode 100644
index 0000000..757d33d
--- /dev/null
+++ b/packages/yew/src/octagon_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OctagonXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn OctagonX(props: &OctagonXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 9-6 6" />
+            <path
+                d="M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"
+            />
+            <path d="m9 9 6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/omega.rs b/packages/yew/src/omega.rs
new file mode 100644
index 0000000..165a559
--- /dev/null
+++ b/packages/yew/src/omega.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OmegaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Omega(props: &OmegaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3 20h4.5a.5.5 0 0 0 .5-.5v-.282a.52.52 0 0 0-.247-.437 8 8 0 1 1 8.494-.001.52.52 0 0 0-.247.438v.282a.5.5 0 0 0 .5.5H21"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/option.rs b/packages/yew/src/option.rs
new file mode 100644
index 0000000..80c52d4
--- /dev/null
+++ b/packages/yew/src/option.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OptionProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Option(props: &OptionProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3h6l6 18h6" />
+            <path d="M14 3h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/orbit.rs b/packages/yew/src/orbit.rs
new file mode 100644
index 0000000..11f27a9
--- /dev/null
+++ b/packages/yew/src/orbit.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OrbitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Orbit(props: &OrbitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3" />
+            <circle cx="19" cy="5" r="2" />
+            <circle cx="5" cy="19" r="2" />
+            <path d="M10.4 21.9a10 10 0 0 0 9.941-15.416" />
+            <path d="M13.5 2.1a10 10 0 0 0-9.841 15.416" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/origami.rs b/packages/yew/src/origami.rs
new file mode 100644
index 0000000..657903e
--- /dev/null
+++ b/packages/yew/src/origami.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct OrigamiProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Origami(props: &OrigamiProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12V4a1 1 0 0 1 1-1h6.297a1 1 0 0 1 .651 1.759l-4.696 4.025" />
+            <path
+                d="m12 21-7.414-7.414A2 2 0 0 1 4 12.172V6.415a1.002 1.002 0 0 1 1.707-.707L20 20.009"
+            />
+            <path
+                d="m12.214 3.381 8.414 14.966a1 1 0 0 1-.167 1.199l-1.168 1.163a1 1 0 0 1-.706.291H6.351a1 1 0 0 1-.625-.219L3.25 18.8a1 1 0 0 1 .631-1.781l4.165.027"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/package.rs b/packages/yew/src/package.rs
new file mode 100644
index 0000000..e067c07
--- /dev/null
+++ b/packages/yew/src/package.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PackageProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Package(props: &PackageProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11 21.73a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73z"
+            />
+            <path d="M12 22V12" />
+            <path d="m3.3 7 7.703 4.734a2 2 0 0 0 1.994 0L20.7 7" />
+            <path d="m7.5 4.27 9 5.15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/package_2.rs b/packages/yew/src/package_2.rs
new file mode 100644
index 0000000..cf01da0
--- /dev/null
+++ b/packages/yew/src/package_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Package2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Package2(props: &Package2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 9h18v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V9Z" />
+            <path d="m3 9 2.45-4.9A2 2 0 0 1 7.24 3h9.52a2 2 0 0 1 1.8 1.1L21 9" />
+            <path d="M12 3v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/package_check.rs b/packages/yew/src/package_check.rs
new file mode 100644
index 0000000..c4a3a69
--- /dev/null
+++ b/packages/yew/src/package_check.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PackageCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PackageCheck(props: &PackageCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 16 2 2 4-4" />
+            <path
+                d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"
+            />
+            <path d="m7.5 4.27 9 5.15" />
+            <polyline points="3.29 7 12 12 20.71 7" />
+            <line x1="12" x2="12" y1="22" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/package_minus.rs b/packages/yew/src/package_minus.rs
new file mode 100644
index 0000000..8c981ea
--- /dev/null
+++ b/packages/yew/src/package_minus.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PackageMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PackageMinus(props: &PackageMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 16h6" />
+            <path
+                d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"
+            />
+            <path d="m7.5 4.27 9 5.15" />
+            <polyline points="3.29 7 12 12 20.71 7" />
+            <line x1="12" x2="12" y1="22" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/package_open.rs b/packages/yew/src/package_open.rs
new file mode 100644
index 0000000..5bab45c
--- /dev/null
+++ b/packages/yew/src/package_open.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PackageOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PackageOpen(props: &PackageOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-9" />
+            <path
+                d="M15.17 2.21a1.67 1.67 0 0 1 1.63 0L21 4.57a1.93 1.93 0 0 1 0 3.36L8.82 14.79a1.655 1.655 0 0 1-1.64 0L3 12.43a1.93 1.93 0 0 1 0-3.36z"
+            />
+            <path
+                d="M20 13v3.87a2.06 2.06 0 0 1-1.11 1.83l-6 3.08a1.93 1.93 0 0 1-1.78 0l-6-3.08A2.06 2.06 0 0 1 4 16.87V13"
+            />
+            <path
+                d="M21 12.43a1.93 1.93 0 0 0 0-3.36L8.83 2.2a1.64 1.64 0 0 0-1.63 0L3 4.57a1.93 1.93 0 0 0 0 3.36l12.18 6.86a1.636 1.636 0 0 0 1.63 0z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/package_plus.rs b/packages/yew/src/package_plus.rs
new file mode 100644
index 0000000..76585ec
--- /dev/null
+++ b/packages/yew/src/package_plus.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PackagePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PackagePlus(props: &PackagePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 16h6" />
+            <path d="M19 13v6" />
+            <path
+                d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"
+            />
+            <path d="m7.5 4.27 9 5.15" />
+            <polyline points="3.29 7 12 12 20.71 7" />
+            <line x1="12" x2="12" y1="22" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/package_search.rs b/packages/yew/src/package_search.rs
new file mode 100644
index 0000000..6e26097
--- /dev/null
+++ b/packages/yew/src/package_search.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PackageSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PackageSearch(props: &PackageSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"
+            />
+            <path d="m7.5 4.27 9 5.15" />
+            <polyline points="3.29 7 12 12 20.71 7" />
+            <line x1="12" x2="12" y1="22" y2="12" />
+            <circle cx="18.5" cy="15.5" r="2.5" />
+            <path d="M20.27 17.27 22 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/package_x.rs b/packages/yew/src/package_x.rs
new file mode 100644
index 0000000..010e0f8
--- /dev/null
+++ b/packages/yew/src/package_x.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PackageXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PackageX(props: &PackageXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"
+            />
+            <path d="m7.5 4.27 9 5.15" />
+            <polyline points="3.29 7 12 12 20.71 7" />
+            <line x1="12" x2="12" y1="22" y2="12" />
+            <path d="m17 13 5 5m-5 0 5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/paint_bucket.rs b/packages/yew/src/paint_bucket.rs
new file mode 100644
index 0000000..5184e5d
--- /dev/null
+++ b/packages/yew/src/paint_bucket.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PaintBucketProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PaintBucket(props: &PaintBucketProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 11-8-8-8.6 8.6a2 2 0 0 0 0 2.8l5.2 5.2c.8.8 2 .8 2.8 0L19 11Z" />
+            <path d="m5 2 5 5" />
+            <path d="M2 13h15" />
+            <path d="M22 20a2 2 0 1 1-4 0c0-1.6 1.7-2.4 2-4 .3 1.6 2 2.4 2 4Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/paint_roller.rs b/packages/yew/src/paint_roller.rs
new file mode 100644
index 0000000..419cf8c
--- /dev/null
+++ b/packages/yew/src/paint_roller.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PaintRollerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PaintRoller(props: &PaintRollerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="6" x="2" y="2" rx="2" />
+            <path d="M10 16v-2a2 2 0 0 1 2-2h8a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2" />
+            <rect width="4" height="6" x="8" y="16" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/paintbrush.rs b/packages/yew/src/paintbrush.rs
new file mode 100644
index 0000000..211dd13
--- /dev/null
+++ b/packages/yew/src/paintbrush.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PaintbrushProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Paintbrush(props: &PaintbrushProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m14.622 17.897-10.68-2.913" />
+            <path
+                d="M18.376 2.622a1 1 0 1 1 3.002 3.002L17.36 9.643a.5.5 0 0 0 0 .707l.944.944a2.41 2.41 0 0 1 0 3.408l-.944.944a.5.5 0 0 1-.707 0L8.354 7.348a.5.5 0 0 1 0-.707l.944-.944a2.41 2.41 0 0 1 3.408 0l.944.944a.5.5 0 0 0 .707 0z"
+            />
+            <path
+                d="M9 8c-1.804 2.71-3.97 3.46-6.583 3.948a.507.507 0 0 0-.302.819l7.32 8.883a1 1 0 0 0 1.185.204C12.735 20.405 16 16.792 16 15"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/paintbrush_vertical.rs b/packages/yew/src/paintbrush_vertical.rs
new file mode 100644
index 0000000..f0bb9db
--- /dev/null
+++ b/packages/yew/src/paintbrush_vertical.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PaintbrushVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PaintbrushVertical(props: &PaintbrushVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v2" />
+            <path d="M14 2v4" />
+            <path d="M17 2a1 1 0 0 1 1 1v9H6V3a1 1 0 0 1 1-1z" />
+            <path
+                d="M6 12a1 1 0 0 0-1 1v1a2 2 0 0 0 2 2h2a1 1 0 0 1 1 1v2.9a2 2 0 1 0 4 0V17a1 1 0 0 1 1-1h2a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/palette.rs b/packages/yew/src/palette.rs
new file mode 100644
index 0000000..979e134
--- /dev/null
+++ b/packages/yew/src/palette.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PaletteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Palette(props: &PaletteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="13.5" cy="6.5" r=".5" fill="currentColor" />
+            <circle cx="17.5" cy="10.5" r=".5" fill="currentColor" />
+            <circle cx="8.5" cy="7.5" r=".5" fill="currentColor" />
+            <circle cx="6.5" cy="12.5" r=".5" fill="currentColor" />
+            <path
+                d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10c.926 0 1.648-.746 1.648-1.688 0-.437-.18-.835-.437-1.125-.29-.289-.438-.652-.438-1.125a1.64 1.64 0 0 1 1.668-1.668h1.996c3.051 0 5.555-2.503 5.555-5.554C21.965 6.012 17.461 2 12 2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_bottom.rs b/packages/yew/src/panel_bottom.rs
new file mode 100644
index 0000000..ee807ac
--- /dev/null
+++ b/packages/yew/src/panel_bottom.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelBottomProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelBottom(props: &PanelBottomProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 15h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_bottom_close.rs b/packages/yew/src/panel_bottom_close.rs
new file mode 100644
index 0000000..4004503
--- /dev/null
+++ b/packages/yew/src/panel_bottom_close.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelBottomCloseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelBottomClose(props: &PanelBottomCloseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 15h18" />
+            <path d="m15 8-3 3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_bottom_dashed.rs b/packages/yew/src/panel_bottom_dashed.rs
new file mode 100644
index 0000000..96bbe19
--- /dev/null
+++ b/packages/yew/src/panel_bottom_dashed.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelBottomDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelBottomDashed(props: &PanelBottomDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M14 15h1" />
+            <path d="M19 15h2" />
+            <path d="M3 15h2" />
+            <path d="M9 15h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_bottom_open.rs b/packages/yew/src/panel_bottom_open.rs
new file mode 100644
index 0000000..2767968
--- /dev/null
+++ b/packages/yew/src/panel_bottom_open.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelBottomOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelBottomOpen(props: &PanelBottomOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 15h18" />
+            <path d="m9 10 3-3 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_left.rs b/packages/yew/src/panel_left.rs
new file mode 100644
index 0000000..745f366
--- /dev/null
+++ b/packages/yew/src/panel_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelLeft(props: &PanelLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M9 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_left_close.rs b/packages/yew/src/panel_left_close.rs
new file mode 100644
index 0000000..e806ada
--- /dev/null
+++ b/packages/yew/src/panel_left_close.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelLeftCloseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelLeftClose(props: &PanelLeftCloseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M9 3v18" />
+            <path d="m16 15-3-3 3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_left_dashed.rs b/packages/yew/src/panel_left_dashed.rs
new file mode 100644
index 0000000..54fcaa2
--- /dev/null
+++ b/packages/yew/src/panel_left_dashed.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelLeftDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelLeftDashed(props: &PanelLeftDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M9 14v1" />
+            <path d="M9 19v2" />
+            <path d="M9 3v2" />
+            <path d="M9 9v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_left_open.rs b/packages/yew/src/panel_left_open.rs
new file mode 100644
index 0000000..9a74b95
--- /dev/null
+++ b/packages/yew/src/panel_left_open.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelLeftOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelLeftOpen(props: &PanelLeftOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M9 3v18" />
+            <path d="m14 9 3 3-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_right.rs b/packages/yew/src/panel_right.rs
new file mode 100644
index 0000000..d6df8fb
--- /dev/null
+++ b/packages/yew/src/panel_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelRight(props: &PanelRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M15 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_right_close.rs b/packages/yew/src/panel_right_close.rs
new file mode 100644
index 0000000..4bda0b3
--- /dev/null
+++ b/packages/yew/src/panel_right_close.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelRightCloseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelRightClose(props: &PanelRightCloseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M15 3v18" />
+            <path d="m8 9 3 3-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_right_dashed.rs b/packages/yew/src/panel_right_dashed.rs
new file mode 100644
index 0000000..762fe6f
--- /dev/null
+++ b/packages/yew/src/panel_right_dashed.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelRightDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelRightDashed(props: &PanelRightDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M15 14v1" />
+            <path d="M15 19v2" />
+            <path d="M15 3v2" />
+            <path d="M15 9v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_right_open.rs b/packages/yew/src/panel_right_open.rs
new file mode 100644
index 0000000..7c8879e
--- /dev/null
+++ b/packages/yew/src/panel_right_open.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelRightOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelRightOpen(props: &PanelRightOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M15 3v18" />
+            <path d="m10 15-3-3 3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_top.rs b/packages/yew/src/panel_top.rs
new file mode 100644
index 0000000..56b73f2
--- /dev/null
+++ b/packages/yew/src/panel_top.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelTopProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelTop(props: &PanelTopProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 9h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_top_close.rs b/packages/yew/src/panel_top_close.rs
new file mode 100644
index 0000000..ba628b4
--- /dev/null
+++ b/packages/yew/src/panel_top_close.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelTopCloseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelTopClose(props: &PanelTopCloseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 9h18" />
+            <path d="m9 16 3-3 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_top_dashed.rs b/packages/yew/src/panel_top_dashed.rs
new file mode 100644
index 0000000..b21c42b
--- /dev/null
+++ b/packages/yew/src/panel_top_dashed.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelTopDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelTopDashed(props: &PanelTopDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M14 9h1" />
+            <path d="M19 9h2" />
+            <path d="M3 9h2" />
+            <path d="M9 9h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panel_top_open.rs b/packages/yew/src/panel_top_open.rs
new file mode 100644
index 0000000..0958d0e
--- /dev/null
+++ b/packages/yew/src/panel_top_open.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelTopOpenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelTopOpen(props: &PanelTopOpenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 9h18" />
+            <path d="m15 14-3 3-3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panels_left_bottom.rs b/packages/yew/src/panels_left_bottom.rs
new file mode 100644
index 0000000..47ffb58
--- /dev/null
+++ b/packages/yew/src/panels_left_bottom.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelsLeftBottomProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelsLeftBottom(props: &PanelsLeftBottomProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M9 3v18" />
+            <path d="M9 15h12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panels_right_bottom.rs b/packages/yew/src/panels_right_bottom.rs
new file mode 100644
index 0000000..036d509
--- /dev/null
+++ b/packages/yew/src/panels_right_bottom.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelsRightBottomProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelsRightBottom(props: &PanelsRightBottomProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 15h12" />
+            <path d="M15 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/panels_top_left.rs b/packages/yew/src/panels_top_left.rs
new file mode 100644
index 0000000..885a442
--- /dev/null
+++ b/packages/yew/src/panels_top_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PanelsTopLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PanelsTopLeft(props: &PanelsTopLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 9h18" />
+            <path d="M9 21V9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/paperclip.rs b/packages/yew/src/paperclip.rs
new file mode 100644
index 0000000..424adc0
--- /dev/null
+++ b/packages/yew/src/paperclip.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PaperclipProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Paperclip(props: &PaperclipProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m21.44 11.05-9.19 9.19a6 6 0 0 1-8.49-8.49l8.57-8.57A4 4 0 1 1 18 8.84l-8.59 8.57a2 2 0 0 1-2.83-2.83l8.49-8.48"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/parentheses.rs b/packages/yew/src/parentheses.rs
new file mode 100644
index 0000000..d782c1d
--- /dev/null
+++ b/packages/yew/src/parentheses.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ParenthesesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Parentheses(props: &ParenthesesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 21s-4-3-4-9 4-9 4-9" />
+            <path d="M16 3s4 3 4 9-4 9-4 9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/parking_meter.rs b/packages/yew/src/parking_meter.rs
new file mode 100644
index 0000000..6cc3864
--- /dev/null
+++ b/packages/yew/src/parking_meter.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ParkingMeterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ParkingMeter(props: &ParkingMeterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 15h2" />
+            <path d="M12 12v3" />
+            <path d="M12 19v3" />
+            <path
+                d="M15.282 19a1 1 0 0 0 .948-.68l2.37-6.988a7 7 0 1 0-13.2 0l2.37 6.988a1 1 0 0 0 .948.68z"
+            />
+            <path d="M9 9a3 3 0 1 1 6 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/party_popper.rs b/packages/yew/src/party_popper.rs
new file mode 100644
index 0000000..346fe18
--- /dev/null
+++ b/packages/yew/src/party_popper.rs
@@ -0,0 +1,56 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PartyPopperProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PartyPopper(props: &PartyPopperProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5.8 11.3 2 22l10.7-3.79" />
+            <path d="M4 3h.01" />
+            <path d="M22 8h.01" />
+            <path d="M15 2h.01" />
+            <path d="M22 20h.01" />
+            <path
+                d="m22 2-2.24.75a2.9 2.9 0 0 0-1.96 3.12c.1.86-.57 1.63-1.45 1.63h-.38c-.86 0-1.6.6-1.76 1.44L14 10"
+            />
+            <path d="m22 13-.82-.33c-.86-.34-1.82.2-1.98 1.11c-.11.7-.72 1.22-1.43 1.22H17" />
+            <path d="m11 2 .33.82c.34.86-.2 1.82-1.11 1.98C9.52 4.9 9 5.52 9 6.23V7" />
+            <path
+                d="M11 13c1.93 1.93 2.83 4.17 2 5-.83.83-3.07-.07-5-2-1.93-1.93-2.83-4.17-2-5 .83-.83 3.07.07 5 2Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pause.rs b/packages/yew/src/pause.rs
new file mode 100644
index 0000000..fa23041
--- /dev/null
+++ b/packages/yew/src/pause.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PauseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pause(props: &PauseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="14" y="4" width="4" height="16" rx="1" />
+            <rect x="6" y="4" width="4" height="16" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/paw_print.rs b/packages/yew/src/paw_print.rs
new file mode 100644
index 0000000..4786a3e
--- /dev/null
+++ b/packages/yew/src/paw_print.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PawPrintProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PawPrint(props: &PawPrintProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="4" r="2" />
+            <circle cx="18" cy="8" r="2" />
+            <circle cx="20" cy="16" r="2" />
+            <path
+                d="M9 10a5 5 0 0 1 5 5v3.5a3.5 3.5 0 0 1-6.84 1.045Q6.52 17.48 4.46 16.84A3.5 3.5 0 0 1 5.5 10Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pc_case.rs b/packages/yew/src/pc_case.rs
new file mode 100644
index 0000000..588295e
--- /dev/null
+++ b/packages/yew/src/pc_case.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PcCaseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PcCase(props: &PcCaseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="20" x="5" y="2" rx="2" />
+            <path d="M15 14h.01" />
+            <path d="M9 6h6" />
+            <path d="M9 10h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pen.rs b/packages/yew/src/pen.rs
new file mode 100644
index 0000000..95c0ab7
--- /dev/null
+++ b/packages/yew/src/pen.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pen(props: &PenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pen_line.rs b/packages/yew/src/pen_line.rs
new file mode 100644
index 0000000..37f73f3
--- /dev/null
+++ b/packages/yew/src/pen_line.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PenLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PenLine(props: &PenLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h9" />
+            <path
+                d="M16.376 3.622a1 1 0 0 1 3.002 3.002L7.368 18.635a2 2 0 0 1-.855.506l-2.872.838a.5.5 0 0 1-.62-.62l.838-2.872a2 2 0 0 1 .506-.854z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pen_off.rs b/packages/yew/src/pen_off.rs
new file mode 100644
index 0000000..68ee315
--- /dev/null
+++ b/packages/yew/src/pen_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PenOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PenOff(props: &PenOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m10 10-6.157 6.162a2 2 0 0 0-.5.833l-1.322 4.36a.5.5 0 0 0 .622.624l4.358-1.323a2 2 0 0 0 .83-.5L14 13.982"
+            />
+            <path d="m12.829 7.172 4.359-4.346a1 1 0 1 1 3.986 3.986l-4.353 4.353" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pen_tool.rs b/packages/yew/src/pen_tool.rs
new file mode 100644
index 0000000..8792131
--- /dev/null
+++ b/packages/yew/src/pen_tool.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PenToolProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PenTool(props: &PenToolProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M15.707 21.293a1 1 0 0 1-1.414 0l-1.586-1.586a1 1 0 0 1 0-1.414l5.586-5.586a1 1 0 0 1 1.414 0l1.586 1.586a1 1 0 0 1 0 1.414z"
+            />
+            <path
+                d="m18 13-1.375-6.874a1 1 0 0 0-.746-.776L3.235 2.028a1 1 0 0 0-1.207 1.207L5.35 15.879a1 1 0 0 0 .776.746L13 18"
+            />
+            <path d="m2.3 2.3 7.286 7.286" />
+            <circle cx="11" cy="11" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pencil.rs b/packages/yew/src/pencil.rs
new file mode 100644
index 0000000..0b8627f
--- /dev/null
+++ b/packages/yew/src/pencil.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PencilProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pencil(props: &PencilProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"
+            />
+            <path d="m15 5 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pencil_line.rs b/packages/yew/src/pencil_line.rs
new file mode 100644
index 0000000..8ff318d
--- /dev/null
+++ b/packages/yew/src/pencil_line.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PencilLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PencilLine(props: &PencilLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h9" />
+            <path
+                d="M16.376 3.622a1 1 0 0 1 3.002 3.002L7.368 18.635a2 2 0 0 1-.855.506l-2.872.838a.5.5 0 0 1-.62-.62l.838-2.872a2 2 0 0 1 .506-.854z"
+            />
+            <path d="m15 5 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pencil_off.rs b/packages/yew/src/pencil_off.rs
new file mode 100644
index 0000000..725d729
--- /dev/null
+++ b/packages/yew/src/pencil_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PencilOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PencilOff(props: &PencilOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m10 10-6.157 6.162a2 2 0 0 0-.5.833l-1.322 4.36a.5.5 0 0 0 .622.624l4.358-1.323a2 2 0 0 0 .83-.5L14 13.982"
+            />
+            <path d="m12.829 7.172 4.359-4.346a1 1 0 1 1 3.986 3.986l-4.353 4.353" />
+            <path d="m15 5 4 4" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pencil_ruler.rs b/packages/yew/src/pencil_ruler.rs
new file mode 100644
index 0000000..9a7c69e
--- /dev/null
+++ b/packages/yew/src/pencil_ruler.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PencilRulerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PencilRuler(props: &PencilRulerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 7 8.7 2.7a2.41 2.41 0 0 0-3.4 0L2.7 5.3a2.41 2.41 0 0 0 0 3.4L7 13" />
+            <path d="m8 6 2-2" />
+            <path d="m18 16 2-2" />
+            <path d="m17 11 4.3 4.3c.94.94.94 2.46 0 3.4l-2.6 2.6c-.94.94-2.46.94-3.4 0L11 17" />
+            <path
+                d="M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"
+            />
+            <path d="m15 5 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pentagon.rs b/packages/yew/src/pentagon.rs
new file mode 100644
index 0000000..f8bad67
--- /dev/null
+++ b/packages/yew/src/pentagon.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PentagonProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pentagon(props: &PentagonProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.83 2.38a2 2 0 0 1 2.34 0l8 5.74a2 2 0 0 1 .73 2.25l-3.04 9.26a2 2 0 0 1-1.9 1.37H7.04a2 2 0 0 1-1.9-1.37L2.1 10.37a2 2 0 0 1 .73-2.25z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/percent.rs b/packages/yew/src/percent.rs
new file mode 100644
index 0000000..5a0ff5f
--- /dev/null
+++ b/packages/yew/src/percent.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PercentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Percent(props: &PercentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="19" x2="5" y1="5" y2="19" />
+            <circle cx="6.5" cy="6.5" r="2.5" />
+            <circle cx="17.5" cy="17.5" r="2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/person_standing.rs b/packages/yew/src/person_standing.rs
new file mode 100644
index 0000000..e0f14a7
--- /dev/null
+++ b/packages/yew/src/person_standing.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PersonStandingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PersonStanding(props: &PersonStandingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="5" r="1" />
+            <path d="m9 20 3-6 3 6" />
+            <path d="m6 8 6 2 6-2" />
+            <path d="M12 10v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/philippine_peso.rs b/packages/yew/src/philippine_peso.rs
new file mode 100644
index 0000000..3bc063f
--- /dev/null
+++ b/packages/yew/src/philippine_peso.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PhilippinePesoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PhilippinePeso(props: &PhilippinePesoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 11H4" />
+            <path d="M20 7H4" />
+            <path d="M7 21V4a1 1 0 0 1 1-1h4a1 1 0 0 1 0 12H7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/phone.rs b/packages/yew/src/phone.rs
new file mode 100644
index 0000000..c5b5010
--- /dev/null
+++ b/packages/yew/src/phone.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PhoneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Phone(props: &PhoneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/phone_call.rs b/packages/yew/src/phone_call.rs
new file mode 100644
index 0000000..1c2079d
--- /dev/null
+++ b/packages/yew/src/phone_call.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PhoneCallProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PhoneCall(props: &PhoneCallProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"
+            />
+            <path d="M14.05 2a9 9 0 0 1 8 7.94" />
+            <path d="M14.05 6A5 5 0 0 1 18 10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/phone_forwarded.rs b/packages/yew/src/phone_forwarded.rs
new file mode 100644
index 0000000..9d4ee85
--- /dev/null
+++ b/packages/yew/src/phone_forwarded.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PhoneForwardedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PhoneForwarded(props: &PhoneForwardedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="18 2 22 6 18 10" />
+            <line x1="14" x2="22" y1="6" y2="6" />
+            <path
+                d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/phone_incoming.rs b/packages/yew/src/phone_incoming.rs
new file mode 100644
index 0000000..c6b6cdb
--- /dev/null
+++ b/packages/yew/src/phone_incoming.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PhoneIncomingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PhoneIncoming(props: &PhoneIncomingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="16 2 16 8 22 8" />
+            <line x1="22" x2="16" y1="2" y2="8" />
+            <path
+                d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/phone_missed.rs b/packages/yew/src/phone_missed.rs
new file mode 100644
index 0000000..a1c0ad0
--- /dev/null
+++ b/packages/yew/src/phone_missed.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PhoneMissedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PhoneMissed(props: &PhoneMissedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="22" x2="16" y1="2" y2="8" />
+            <line x1="16" x2="22" y1="2" y2="8" />
+            <path
+                d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/phone_off.rs b/packages/yew/src/phone_off.rs
new file mode 100644
index 0000000..6911222
--- /dev/null
+++ b/packages/yew/src/phone_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PhoneOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PhoneOff(props: &PhoneOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10.68 13.31a16 16 0 0 0 3.41 2.6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7 2 2 0 0 1 1.72 2v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.42 19.42 0 0 1-3.33-2.67m-2.67-3.34a19.79 19.79 0 0 1-3.07-8.63A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91"
+            />
+            <line x1="22" x2="2" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/phone_outgoing.rs b/packages/yew/src/phone_outgoing.rs
new file mode 100644
index 0000000..f873d6d
--- /dev/null
+++ b/packages/yew/src/phone_outgoing.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PhoneOutgoingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PhoneOutgoing(props: &PhoneOutgoingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="22 8 22 2 16 2" />
+            <line x1="16" x2="22" y1="8" y2="2" />
+            <path
+                d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pi.rs b/packages/yew/src/pi.rs
new file mode 100644
index 0000000..c097405
--- /dev/null
+++ b/packages/yew/src/pi.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PiProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pi(props: &PiProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="9" x2="9" y1="4" y2="20" />
+            <path d="M4 7c0-1.7 1.3-3 3-3h13" />
+            <path d="M18 20c-1.7 0-3-1.3-3-3V4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/piano.rs b/packages/yew/src/piano.rs
new file mode 100644
index 0000000..e914c71
--- /dev/null
+++ b/packages/yew/src/piano.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PianoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Piano(props: &PianoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M18.5 8c-1.4 0-2.6-.8-3.2-2A6.87 6.87 0 0 0 2 9v11a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-8.5C22 9.6 20.4 8 18.5 8"
+            />
+            <path d="M2 14h20" />
+            <path d="M6 14v4" />
+            <path d="M10 14v4" />
+            <path d="M14 14v4" />
+            <path d="M18 14v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pickaxe.rs b/packages/yew/src/pickaxe.rs
new file mode 100644
index 0000000..58df213
--- /dev/null
+++ b/packages/yew/src/pickaxe.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PickaxeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pickaxe(props: &PickaxeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.531 12.469 6.619 20.38a1 1 0 1 1-3-3l7.912-7.912" />
+            <path
+                d="M15.686 4.314A12.5 12.5 0 0 0 5.461 2.958 1 1 0 0 0 5.58 4.71a22 22 0 0 1 6.318 3.393"
+            />
+            <path
+                d="M17.7 3.7a1 1 0 0 0-1.4 0l-4.6 4.6a1 1 0 0 0 0 1.4l2.6 2.6a1 1 0 0 0 1.4 0l4.6-4.6a1 1 0 0 0 0-1.4z"
+            />
+            <path
+                d="M19.686 8.314a12.501 12.501 0 0 1 1.356 10.225 1 1 0 0 1-1.751-.119 22 22 0 0 0-3.393-6.319"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/picture_in_picture.rs b/packages/yew/src/picture_in_picture.rs
new file mode 100644
index 0000000..80bf13b
--- /dev/null
+++ b/packages/yew/src/picture_in_picture.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PictureInPictureProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PictureInPicture(props: &PictureInPictureProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 4.5v5H3m-1-6 6 6m13 0v-3c0-1.16-.84-2-2-2h-7m-9 9v2c0 1.05.95 2 2 2h3" />
+            <rect width="10" height="7" x="12" y="13.5" ry="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/picture_in_picture_2.rs b/packages/yew/src/picture_in_picture_2.rs
new file mode 100644
index 0000000..dafbfb3
--- /dev/null
+++ b/packages/yew/src/picture_in_picture_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PictureInPicture2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PictureInPicture2(props: &PictureInPicture2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 9V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10c0 1.1.9 2 2 2h4" />
+            <rect width="10" height="7" x="12" y="13" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/piggy_bank.rs b/packages/yew/src/piggy_bank.rs
new file mode 100644
index 0000000..eb13ca2
--- /dev/null
+++ b/packages/yew/src/piggy_bank.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PiggyBankProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PiggyBank(props: &PiggyBankProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19 5c-1.5 0-2.8 1.4-3 2-3.5-1.5-11-.3-11 5 0 1.8 0 3 2 4.5V20h4v-2h3v2h4v-4c1-.5 1.7-1 2-2h2v-4h-2c0-1-.5-1.5-1-2V5z"
+            />
+            <path d="M2 9v1c0 1.1.9 2 2 2h1" />
+            <path d="M16 11h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pilcrow.rs b/packages/yew/src/pilcrow.rs
new file mode 100644
index 0000000..86a49b1
--- /dev/null
+++ b/packages/yew/src/pilcrow.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PilcrowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pilcrow(props: &PilcrowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 4v16" />
+            <path d="M17 4v16" />
+            <path d="M19 4H9.5a4.5 4.5 0 0 0 0 9H13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pilcrow_left.rs b/packages/yew/src/pilcrow_left.rs
new file mode 100644
index 0000000..47d9c58
--- /dev/null
+++ b/packages/yew/src/pilcrow_left.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PilcrowLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PilcrowLeft(props: &PilcrowLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 3v11" />
+            <path d="M14 9h-3a3 3 0 0 1 0-6h9" />
+            <path d="M18 3v11" />
+            <path d="M22 18H2l4-4" />
+            <path d="m6 22-4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pilcrow_right.rs b/packages/yew/src/pilcrow_right.rs
new file mode 100644
index 0000000..0e00008
--- /dev/null
+++ b/packages/yew/src/pilcrow_right.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PilcrowRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PilcrowRight(props: &PilcrowRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 3v11" />
+            <path d="M10 9H7a1 1 0 0 1 0-6h8" />
+            <path d="M14 3v11" />
+            <path d="m18 14 4 4H2" />
+            <path d="m22 18-4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pill.rs b/packages/yew/src/pill.rs
new file mode 100644
index 0000000..f6603b0
--- /dev/null
+++ b/packages/yew/src/pill.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PillProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pill(props: &PillProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10.5 20.5 10-10a4.95 4.95 0 1 0-7-7l-10 10a4.95 4.95 0 1 0 7 7Z" />
+            <path d="m8.5 8.5 7 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pill_bottle.rs b/packages/yew/src/pill_bottle.rs
new file mode 100644
index 0000000..e03d548
--- /dev/null
+++ b/packages/yew/src/pill_bottle.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PillBottleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PillBottle(props: &PillBottleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 11h-4a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1h4" />
+            <path d="M6 7v13a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V7" />
+            <rect width="16" height="5" x="4" y="2" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pin.rs b/packages/yew/src/pin.rs
new file mode 100644
index 0000000..ee1e08b
--- /dev/null
+++ b/packages/yew/src/pin.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PinProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pin(props: &PinProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17v5" />
+            <path
+                d="M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H8a2 2 0 0 0 0 4 1 1 0 0 1 1 1z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pin_off.rs b/packages/yew/src/pin_off.rs
new file mode 100644
index 0000000..1ea39bb
--- /dev/null
+++ b/packages/yew/src/pin_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PinOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PinOff(props: &PinOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 17v5" />
+            <path d="M15 9.34V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H7.89" />
+            <path d="m2 2 20 20" />
+            <path d="M9 9v1.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pipette.rs b/packages/yew/src/pipette.rs
new file mode 100644
index 0000000..64ba4d7
--- /dev/null
+++ b/packages/yew/src/pipette.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PipetteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pipette(props: &PipetteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 22 1-1h3l9-9" />
+            <path d="M3 21v-3l9-9" />
+            <path
+                d="m15 6 3.4-3.4a2.1 2.1 0 1 1 3 3L18 9l.4.4a2.1 2.1 0 1 1-3 3l-3.8-3.8a2.1 2.1 0 1 1 3-3l.4.4Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pizza.rs b/packages/yew/src/pizza.rs
new file mode 100644
index 0000000..5ea7b76
--- /dev/null
+++ b/packages/yew/src/pizza.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PizzaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pizza(props: &PizzaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12 14-1 1" />
+            <path d="m13.75 18.25-1.25 1.42" />
+            <path d="M17.775 5.654a15.68 15.68 0 0 0-12.121 12.12" />
+            <path d="M18.8 9.3a1 1 0 0 0 2.1 7.7" />
+            <path
+                d="M21.964 20.732a1 1 0 0 1-1.232 1.232l-18-5a1 1 0 0 1-.695-1.232A19.68 19.68 0 0 1 15.732 2.037a1 1 0 0 1 1.232.695z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/plane.rs b/packages/yew/src/plane.rs
new file mode 100644
index 0000000..3eccf95
--- /dev/null
+++ b/packages/yew/src/plane.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PlaneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Plane(props: &PlaneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/plane_landing.rs b/packages/yew/src/plane_landing.rs
new file mode 100644
index 0000000..7bde7cf
--- /dev/null
+++ b/packages/yew/src/plane_landing.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PlaneLandingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PlaneLanding(props: &PlaneLandingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22h20" />
+            <path
+                d="M3.77 10.77 2 9l2-4.5 1.1.55c.55.28.9.84.9 1.45s.35 1.17.9 1.45L8 8.5l3-6 1.05.53a2 2 0 0 1 1.09 1.52l.72 5.4a2 2 0 0 0 1.09 1.52l4.4 2.2c.42.22.78.55 1.01.96l.6 1.03c.49.88-.06 1.98-1.06 2.1l-1.18.15c-.47.06-.95-.02-1.37-.24L4.29 11.15a2 2 0 0 1-.52-.38Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/plane_takeoff.rs b/packages/yew/src/plane_takeoff.rs
new file mode 100644
index 0000000..06dabbe
--- /dev/null
+++ b/packages/yew/src/plane_takeoff.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PlaneTakeoffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PlaneTakeoff(props: &PlaneTakeoffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22h20" />
+            <path
+                d="M6.36 17.4 4 17l-2-4 1.1-.55a2 2 0 0 1 1.8 0l.17.1a2 2 0 0 0 1.8 0L8 12 5 6l.9-.45a2 2 0 0 1 2.09.2l4.02 3a2 2 0 0 0 2.1.2l4.19-2.06a2.41 2.41 0 0 1 1.73-.17L21 7a1.4 1.4 0 0 1 .87 1.99l-.38.76c-.23.46-.6.84-1.07 1.08L7.58 17.2a2 2 0 0 1-1.22.18Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/play.rs b/packages/yew/src/play.rs
new file mode 100644
index 0000000..efa4682
--- /dev/null
+++ b/packages/yew/src/play.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PlayProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Play(props: &PlayProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="6 3 20 12 6 21 6 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/plug.rs b/packages/yew/src/plug.rs
new file mode 100644
index 0000000..1c26124
--- /dev/null
+++ b/packages/yew/src/plug.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PlugProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Plug(props: &PlugProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-5" />
+            <path d="M9 8V2" />
+            <path d="M15 8V2" />
+            <path d="M18 8v5a4 4 0 0 1-4 4h-4a4 4 0 0 1-4-4V8Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/plug_2.rs b/packages/yew/src/plug_2.rs
new file mode 100644
index 0000000..133ea20
--- /dev/null
+++ b/packages/yew/src/plug_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Plug2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Plug2(props: &Plug2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 2v6" />
+            <path d="M15 2v6" />
+            <path d="M12 17v5" />
+            <path d="M5 8h14" />
+            <path d="M6 11V8h12v3a6 6 0 1 1-12 0Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/plug_zap.rs b/packages/yew/src/plug_zap.rs
new file mode 100644
index 0000000..eba8db3
--- /dev/null
+++ b/packages/yew/src/plug_zap.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PlugZapProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PlugZap(props: &PlugZapProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z" />
+            <path d="m2 22 3-3" />
+            <path d="M7.5 13.5 10 11" />
+            <path d="M10.5 16.5 13 14" />
+            <path d="m18 3-4 4h6l-4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/plus.rs b/packages/yew/src/plus.rs
new file mode 100644
index 0000000..5905acc
--- /dev/null
+++ b/packages/yew/src/plus.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Plus(props: &PlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 12h14" />
+            <path d="M12 5v14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pocket.rs b/packages/yew/src/pocket.rs
new file mode 100644
index 0000000..ca9b381
--- /dev/null
+++ b/packages/yew/src/pocket.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PocketProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pocket(props: &PocketProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 3h16a2 2 0 0 1 2 2v6a10 10 0 0 1-10 10A10 10 0 0 1 2 11V5a2 2 0 0 1 2-2z" />
+            <polyline points="8 10 12 14 16 10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pocket_knife.rs b/packages/yew/src/pocket_knife.rs
new file mode 100644
index 0000000..12e406f
--- /dev/null
+++ b/packages/yew/src/pocket_knife.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PocketKnifeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PocketKnife(props: &PocketKnifeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 2v1c0 1 2 1 2 2S3 6 3 7s2 1 2 2-2 1-2 2 2 1 2 2" />
+            <path d="M18 6h.01" />
+            <path d="M6 18h.01" />
+            <path d="M20.83 8.83a4 4 0 0 0-5.66-5.66l-12 12a4 4 0 1 0 5.66 5.66Z" />
+            <path d="M18 11.66V22a4 4 0 0 0 4-4V6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/podcast.rs b/packages/yew/src/podcast.rs
new file mode 100644
index 0000000..68b8935
--- /dev/null
+++ b/packages/yew/src/podcast.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PodcastProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Podcast(props: &PodcastProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16.85 18.58a9 9 0 1 0-9.7 0" />
+            <path d="M8 14a5 5 0 1 1 8 0" />
+            <circle cx="12" cy="11" r="1" />
+            <path d="M13 17a1 1 0 1 0-2 0l.5 4.5a.5.5 0 1 0 1 0Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pointer.rs b/packages/yew/src/pointer.rs
new file mode 100644
index 0000000..bac7e41
--- /dev/null
+++ b/packages/yew/src/pointer.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PointerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pointer(props: &PointerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 14a8 8 0 0 1-8 8" />
+            <path d="M18 11v-1a2 2 0 0 0-2-2a2 2 0 0 0-2 2" />
+            <path d="M14 10V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1" />
+            <path d="M10 9.5V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v10" />
+            <path
+                d="M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pointer_off.rs b/packages/yew/src/pointer_off.rs
new file mode 100644
index 0000000..3210e96
--- /dev/null
+++ b/packages/yew/src/pointer_off.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PointerOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PointerOff(props: &PointerOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 4.5V4a2 2 0 0 0-2.41-1.957" />
+            <path d="M13.9 8.4a2 2 0 0 0-1.26-1.295" />
+            <path d="M21.7 16.2A8 8 0 0 0 22 14v-3a2 2 0 1 0-4 0v-1a2 2 0 0 0-3.63-1.158" />
+            <path
+                d="m7 15-1.8-1.8a2 2 0 0 0-2.79 2.86L6 19.7a7.74 7.74 0 0 0 6 2.3h2a8 8 0 0 0 5.657-2.343"
+            />
+            <path d="M6 6v8" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/popcorn.rs b/packages/yew/src/popcorn.rs
new file mode 100644
index 0000000..7ff1ebd
--- /dev/null
+++ b/packages/yew/src/popcorn.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PopcornProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Popcorn(props: &PopcornProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 8a2 2 0 0 0 0-4 2 2 0 0 0-4 0 2 2 0 0 0-4 0 2 2 0 0 0-4 0 2 2 0 0 0 0 4" />
+            <path d="M10 22 9 8" />
+            <path d="m14 22 1-14" />
+            <path
+                d="M20 8c.5 0 .9.4.8 1l-2.6 12c-.1.5-.7 1-1.2 1H7c-.6 0-1.1-.4-1.2-1L3.2 9c-.1-.6.3-1 .8-1Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/popsicle.rs b/packages/yew/src/popsicle.rs
new file mode 100644
index 0000000..ff74720
--- /dev/null
+++ b/packages/yew/src/popsicle.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PopsicleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Popsicle(props: &PopsicleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M18.6 14.4c.8-.8.8-2 0-2.8l-8.1-8.1a4.95 4.95 0 1 0-7.1 7.1l8.1 8.1c.9.7 2.1.7 2.9-.1Z"
+            />
+            <path d="m22 22-5.5-5.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pound_sterling.rs b/packages/yew/src/pound_sterling.rs
new file mode 100644
index 0000000..d88434f
--- /dev/null
+++ b/packages/yew/src/pound_sterling.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PoundSterlingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PoundSterling(props: &PoundSterlingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 7c0-5.333-8-5.333-8 0" />
+            <path d="M10 7v14" />
+            <path d="M6 21h12" />
+            <path d="M6 13h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/power.rs b/packages/yew/src/power.rs
new file mode 100644
index 0000000..3405930
--- /dev/null
+++ b/packages/yew/src/power.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PowerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Power(props: &PowerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v10" />
+            <path d="M18.4 6.6a9 9 0 1 1-12.77.04" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/power_off.rs b/packages/yew/src/power_off.rs
new file mode 100644
index 0000000..881cc2c
--- /dev/null
+++ b/packages/yew/src/power_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PowerOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PowerOff(props: &PowerOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.36 6.64A9 9 0 0 1 20.77 15" />
+            <path d="M6.16 6.16a9 9 0 1 0 12.68 12.68" />
+            <path d="M12 2v4" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/presentation.rs b/packages/yew/src/presentation.rs
new file mode 100644
index 0000000..c42183f
--- /dev/null
+++ b/packages/yew/src/presentation.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PresentationProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Presentation(props: &PresentationProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 3h20" />
+            <path d="M21 3v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V3" />
+            <path d="m7 21 5-5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/printer.rs b/packages/yew/src/printer.rs
new file mode 100644
index 0000000..16e350d
--- /dev/null
+++ b/packages/yew/src/printer.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PrinterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Printer(props: &PrinterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2" />
+            <path d="M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6" />
+            <rect x="6" y="14" width="12" height="8" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/printer_check.rs b/packages/yew/src/printer_check.rs
new file mode 100644
index 0000000..04197da
--- /dev/null
+++ b/packages/yew/src/printer_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PrinterCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn PrinterCheck(props: &PrinterCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.5 22H7a1 1 0 0 1-1-1v-6a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v.5" />
+            <path d="m16 19 2 2 4-4" />
+            <path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v2" />
+            <path d="M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/projector.rs b/packages/yew/src/projector.rs
new file mode 100644
index 0000000..8f36759
--- /dev/null
+++ b/packages/yew/src/projector.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ProjectorProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Projector(props: &ProjectorProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 7 3 5" />
+            <path d="M9 6V3" />
+            <path d="m13 7 2-2" />
+            <circle cx="9" cy="13" r="3" />
+            <path
+                d="M11.83 12H20a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-4a2 2 0 0 1 2-2h2.17"
+            />
+            <path d="M16 16h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/proportions.rs b/packages/yew/src/proportions.rs
new file mode 100644
index 0000000..646f801
--- /dev/null
+++ b/packages/yew/src/proportions.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ProportionsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Proportions(props: &ProportionsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+            <path d="M12 9v11" />
+            <path d="M2 9h13a2 2 0 0 1 2 2v9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/puzzle.rs b/packages/yew/src/puzzle.rs
new file mode 100644
index 0000000..dc8953a
--- /dev/null
+++ b/packages/yew/src/puzzle.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PuzzleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Puzzle(props: &PuzzleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M15.39 4.39a1 1 0 0 0 1.68-.474 2.5 2.5 0 1 1 3.014 3.015 1 1 0 0 0-.474 1.68l1.683 1.682a2.414 2.414 0 0 1 0 3.414L19.61 15.39a1 1 0 0 1-1.68-.474 2.5 2.5 0 1 0-3.014 3.015 1 1 0 0 1 .474 1.68l-1.683 1.682a2.414 2.414 0 0 1-3.414 0L8.61 19.61a1 1 0 0 0-1.68.474 2.5 2.5 0 1 1-3.014-3.015 1 1 0 0 0 .474-1.68l-1.683-1.682a2.414 2.414 0 0 1 0-3.414L4.39 8.61a1 1 0 0 1 1.68.474 2.5 2.5 0 1 0 3.014-3.015 1 1 0 0 1-.474-1.68l1.683-1.682a2.414 2.414 0 0 1 3.414 0z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/pyramid.rs b/packages/yew/src/pyramid.rs
new file mode 100644
index 0000000..a6f87c7
--- /dev/null
+++ b/packages/yew/src/pyramid.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct PyramidProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Pyramid(props: &PyramidProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.5 16.88a1 1 0 0 1-.32-1.43l9-13.02a1 1 0 0 1 1.64 0l9 13.01a1 1 0 0 1-.32 1.44l-8.51 4.86a2 2 0 0 1-1.98 0Z"
+            />
+            <path d="M12 2v20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/qr_code.rs b/packages/yew/src/qr_code.rs
new file mode 100644
index 0000000..0533fec
--- /dev/null
+++ b/packages/yew/src/qr_code.rs
@@ -0,0 +1,55 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct QrCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn QrCode(props: &QrCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="5" height="5" x="3" y="3" rx="1" />
+            <rect width="5" height="5" x="16" y="3" rx="1" />
+            <rect width="5" height="5" x="3" y="16" rx="1" />
+            <path d="M21 16h-3a2 2 0 0 0-2 2v3" />
+            <path d="M21 21v.01" />
+            <path d="M12 7v3a2 2 0 0 1-2 2H7" />
+            <path d="M3 12h.01" />
+            <path d="M12 3h.01" />
+            <path d="M12 16v.01" />
+            <path d="M16 12h1" />
+            <path d="M21 12v.01" />
+            <path d="M12 21v-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/quote.rs b/packages/yew/src/quote.rs
new file mode 100644
index 0000000..7b4c938
--- /dev/null
+++ b/packages/yew/src/quote.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct QuoteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Quote(props: &QuoteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M16 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z"
+            />
+            <path
+                d="M5 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rabbit.rs b/packages/yew/src/rabbit.rs
new file mode 100644
index 0000000..279795a
--- /dev/null
+++ b/packages/yew/src/rabbit.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RabbitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rabbit(props: &RabbitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 16a3 3 0 0 1 2.24 5" />
+            <path d="M18 12h.01" />
+            <path
+                d="M18 21h-8a4 4 0 0 1-4-4 7 7 0 0 1 7-7h.2L9.6 6.4a1 1 0 1 1 2.8-2.8L15.8 7h.2c3.3 0 6 2.7 6 6v1a2 2 0 0 1-2 2h-1a3 3 0 0 0-3 3"
+            />
+            <path d="M20 8.54V4a2 2 0 1 0-4 0v3" />
+            <path d="M7.612 12.524a3 3 0 1 0-1.6 4.3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/radar.rs b/packages/yew/src/radar.rs
new file mode 100644
index 0000000..b776955
--- /dev/null
+++ b/packages/yew/src/radar.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RadarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Radar(props: &RadarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19.07 4.93A10 10 0 0 0 6.99 3.34" />
+            <path d="M4 6h.01" />
+            <path d="M2.29 9.62A10 10 0 1 0 21.31 8.35" />
+            <path d="M16.24 7.76A6 6 0 1 0 8.23 16.67" />
+            <path d="M12 18h.01" />
+            <path d="M17.99 11.66A6 6 0 0 1 15.77 16.67" />
+            <circle cx="12" cy="12" r="2" />
+            <path d="m13.41 10.59 5.66-5.66" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/radiation.rs b/packages/yew/src/radiation.rs
new file mode 100644
index 0000000..5d38b93
--- /dev/null
+++ b/packages/yew/src/radiation.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RadiationProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Radiation(props: &RadiationProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 12h.01" />
+            <path
+                d="M7.5 4.2c-.3-.5-.9-.7-1.3-.4C3.9 5.5 2.3 8.1 2 11c-.1.5.4 1 1 1h5c0-1.5.8-2.8 2-3.4-1.1-1.9-2-3.5-2.5-4.4z"
+            />
+            <path
+                d="M21 12c.6 0 1-.4 1-1-.3-2.9-1.8-5.5-4.1-7.1-.4-.3-1.1-.2-1.3.3-.6.9-1.5 2.5-2.6 4.3 1.2.7 2 2 2 3.5h5z"
+            />
+            <path
+                d="M7.5 19.8c-.3.5-.1 1.1.4 1.3 2.6 1.2 5.6 1.2 8.2 0 .5-.2.7-.8.4-1.3-.5-.9-1.4-2.5-2.5-4.3-1.2.7-2.8.7-4 0-1.1 1.8-2 3.4-2.5 4.3z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/radical.rs b/packages/yew/src/radical.rs
new file mode 100644
index 0000000..ad025f0
--- /dev/null
+++ b/packages/yew/src/radical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RadicalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Radical(props: &RadicalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3 12h3.28a1 1 0 0 1 .948.684l2.298 7.934a.5.5 0 0 0 .96-.044L13.82 4.771A1 1 0 0 1 14.792 4H21"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/radio.rs b/packages/yew/src/radio.rs
new file mode 100644
index 0000000..6b2ff62
--- /dev/null
+++ b/packages/yew/src/radio.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RadioProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Radio(props: &RadioProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.9 19.1C1 15.2 1 8.8 4.9 4.9" />
+            <path d="M7.8 16.2c-2.3-2.3-2.3-6.1 0-8.5" />
+            <circle cx="12" cy="12" r="2" />
+            <path d="M16.2 7.8c2.3 2.3 2.3 6.1 0 8.5" />
+            <path d="M19.1 4.9C23 8.8 23 15.1 19.1 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/radio_receiver.rs b/packages/yew/src/radio_receiver.rs
new file mode 100644
index 0000000..aa809b8
--- /dev/null
+++ b/packages/yew/src/radio_receiver.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RadioReceiverProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RadioReceiver(props: &RadioReceiverProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 16v2" />
+            <path d="M19 16v2" />
+            <rect width="20" height="8" x="2" y="8" rx="2" />
+            <path d="M18 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/radio_tower.rs b/packages/yew/src/radio_tower.rs
new file mode 100644
index 0000000..5a8e478
--- /dev/null
+++ b/packages/yew/src/radio_tower.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RadioTowerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RadioTower(props: &RadioTowerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4.9 16.1C1 12.2 1 5.8 4.9 1.9" />
+            <path d="M7.8 4.7a6.14 6.14 0 0 0-.8 7.5" />
+            <circle cx="12" cy="9" r="2" />
+            <path d="M16.2 4.8c2 2 2.26 5.11.8 7.47" />
+            <path d="M19.1 1.9a9.96 9.96 0 0 1 0 14.1" />
+            <path d="M9.5 18h5" />
+            <path d="m8 22 4-11 4 11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/radius.rs b/packages/yew/src/radius.rs
new file mode 100644
index 0000000..1944a1e
--- /dev/null
+++ b/packages/yew/src/radius.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RadiusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Radius(props: &RadiusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20.34 17.52a10 10 0 1 0-2.82 2.82" />
+            <circle cx="19" cy="19" r="2" />
+            <path d="m13.41 13.41 4.18 4.18" />
+            <circle cx="12" cy="12" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rail_symbol.rs b/packages/yew/src/rail_symbol.rs
new file mode 100644
index 0000000..ef27da5
--- /dev/null
+++ b/packages/yew/src/rail_symbol.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RailSymbolProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RailSymbol(props: &RailSymbolProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 15h14" />
+            <path d="M5 9h14" />
+            <path d="m14 20-5-5 6-6-5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rainbow.rs b/packages/yew/src/rainbow.rs
new file mode 100644
index 0000000..871e9c9
--- /dev/null
+++ b/packages/yew/src/rainbow.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RainbowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rainbow(props: &RainbowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 17a10 10 0 0 0-20 0" />
+            <path d="M6 17a6 6 0 0 1 12 0" />
+            <path d="M10 17a2 2 0 0 1 4 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rat.rs b/packages/yew/src/rat.rs
new file mode 100644
index 0000000..ecd82b1
--- /dev/null
+++ b/packages/yew/src/rat.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RatProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rat(props: &RatProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M17 5c0-1.7-1.3-3-3-3s-3 1.3-3 3c0 .8.3 1.5.8 2H11c-3.9 0-7 3.1-7 7c0 2.2 1.8 4 4 4"
+            />
+            <path
+                d="M16.8 3.9c.3-.3.6-.5 1-.7 1.5-.6 3.3.1 3.9 1.6.6 1.5-.1 3.3-1.6 3.9l1.6 2.8c.2.3.2.7.2 1-.2.8-.9 1.2-1.7 1.1 0 0-1.6-.3-2.7-.6H17c-1.7 0-3 1.3-3 3"
+            />
+            <path d="M13.2 18a3 3 0 0 0-2.2-5" />
+            <path d="M13 22H4a2 2 0 0 1 0-4h12" />
+            <path d="M16 9h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ratio.rs b/packages/yew/src/ratio.rs
new file mode 100644
index 0000000..69c25f5
--- /dev/null
+++ b/packages/yew/src/ratio.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RatioProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ratio(props: &RatioProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="12" height="20" x="6" y="2" rx="2" />
+            <rect width="20" height="12" x="2" y="6" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt.rs b/packages/yew/src/receipt.rs
new file mode 100644
index 0000000..efeddf1
--- /dev/null
+++ b/packages/yew/src/receipt.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Receipt(props: &ReceiptProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8" />
+            <path d="M12 17.5v-11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt_cent.rs b/packages/yew/src/receipt_cent.rs
new file mode 100644
index 0000000..b145f01
--- /dev/null
+++ b/packages/yew/src/receipt_cent.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptCentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReceiptCent(props: &ReceiptCentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="M12 6.5v11" />
+            <path d="M15 9.4a4 4 0 1 0 0 5.2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt_euro.rs b/packages/yew/src/receipt_euro.rs
new file mode 100644
index 0000000..e9c8498
--- /dev/null
+++ b/packages/yew/src/receipt_euro.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptEuroProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReceiptEuro(props: &ReceiptEuroProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="M8 12h5" />
+            <path d="M16 9.5a4 4 0 1 0 0 5.2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt_indian_rupee.rs b/packages/yew/src/receipt_indian_rupee.rs
new file mode 100644
index 0000000..ed7f033
--- /dev/null
+++ b/packages/yew/src/receipt_indian_rupee.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptIndianRupeeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReceiptIndianRupee(props: &ReceiptIndianRupeeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="M8 7h8" />
+            <path d="M12 17.5 8 15h1a4 4 0 0 0 0-8" />
+            <path d="M8 11h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt_japanese_yen.rs b/packages/yew/src/receipt_japanese_yen.rs
new file mode 100644
index 0000000..ce00451
--- /dev/null
+++ b/packages/yew/src/receipt_japanese_yen.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptJapaneseYenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReceiptJapaneseYen(props: &ReceiptJapaneseYenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="m12 10 3-3" />
+            <path d="m9 7 3 3v7.5" />
+            <path d="M9 11h6" />
+            <path d="M9 15h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt_pound_sterling.rs b/packages/yew/src/receipt_pound_sterling.rs
new file mode 100644
index 0000000..7bc70d8
--- /dev/null
+++ b/packages/yew/src/receipt_pound_sterling.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptPoundSterlingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReceiptPoundSterling(props: &ReceiptPoundSterlingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="M8 13h5" />
+            <path d="M10 17V9.5a2.5 2.5 0 0 1 5 0" />
+            <path d="M8 17h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt_russian_ruble.rs b/packages/yew/src/receipt_russian_ruble.rs
new file mode 100644
index 0000000..c53a89f
--- /dev/null
+++ b/packages/yew/src/receipt_russian_ruble.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptRussianRubleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReceiptRussianRuble(props: &ReceiptRussianRubleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="M8 15h5" />
+            <path d="M8 11h5a2 2 0 1 0 0-4h-3v10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt_swiss_franc.rs b/packages/yew/src/receipt_swiss_franc.rs
new file mode 100644
index 0000000..a122a64
--- /dev/null
+++ b/packages/yew/src/receipt_swiss_franc.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptSwissFrancProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReceiptSwissFranc(props: &ReceiptSwissFrancProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="M10 17V7h5" />
+            <path d="M10 11h4" />
+            <path d="M8 15h5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/receipt_text.rs b/packages/yew/src/receipt_text.rs
new file mode 100644
index 0000000..b802f20
--- /dev/null
+++ b/packages/yew/src/receipt_text.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReceiptTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReceiptText(props: &ReceiptTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z" />
+            <path d="M14 8H8" />
+            <path d="M16 12H8" />
+            <path d="M13 16H8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rectangle_ellipsis.rs b/packages/yew/src/rectangle_ellipsis.rs
new file mode 100644
index 0000000..a72cbfa
--- /dev/null
+++ b/packages/yew/src/rectangle_ellipsis.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RectangleEllipsisProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RectangleEllipsis(props: &RectangleEllipsisProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="2" />
+            <path d="M12 12h.01" />
+            <path d="M17 12h.01" />
+            <path d="M7 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rectangle_horizontal.rs b/packages/yew/src/rectangle_horizontal.rs
new file mode 100644
index 0000000..f390907
--- /dev/null
+++ b/packages/yew/src/rectangle_horizontal.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RectangleHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RectangleHorizontal(props: &RectangleHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rectangle_vertical.rs b/packages/yew/src/rectangle_vertical.rs
new file mode 100644
index 0000000..9800450
--- /dev/null
+++ b/packages/yew/src/rectangle_vertical.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RectangleVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RectangleVertical(props: &RectangleVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="12" height="20" x="6" y="2" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/recycle.rs b/packages/yew/src/recycle.rs
new file mode 100644
index 0000000..1ba0670
--- /dev/null
+++ b/packages/yew/src/recycle.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RecycleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Recycle(props: &RecycleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 19H4.815a1.83 1.83 0 0 1-1.57-.881 1.785 1.785 0 0 1-.004-1.784L7.196 9.5" />
+            <path d="M11 19h8.203a1.83 1.83 0 0 0 1.556-.89 1.784 1.784 0 0 0 0-1.775l-1.226-2.12" />
+            <path d="m14 16-3 3 3 3" />
+            <path d="M8.293 13.596 7.196 9.5 3.1 10.598" />
+            <path
+                d="m9.344 5.811 1.093-1.892A1.83 1.83 0 0 1 11.985 3a1.784 1.784 0 0 1 1.546.888l3.943 6.843"
+            />
+            <path d="m13.378 9.633 4.096 1.098 1.097-4.096" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/redo.rs b/packages/yew/src/redo.rs
new file mode 100644
index 0000000..72c4e20
--- /dev/null
+++ b/packages/yew/src/redo.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RedoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Redo(props: &RedoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 7v6h-6" />
+            <path d="M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/redo_2.rs b/packages/yew/src/redo_2.rs
new file mode 100644
index 0000000..f7f6949
--- /dev/null
+++ b/packages/yew/src/redo_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Redo2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Redo2(props: &Redo2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 14 5-5-5-5" />
+            <path d="M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/redo_dot.rs b/packages/yew/src/redo_dot.rs
new file mode 100644
index 0000000..e178713
--- /dev/null
+++ b/packages/yew/src/redo_dot.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RedoDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RedoDot(props: &RedoDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="17" r="1" />
+            <path d="M21 7v6h-6" />
+            <path d="M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/refresh_ccw.rs b/packages/yew/src/refresh_ccw.rs
new file mode 100644
index 0000000..a714532
--- /dev/null
+++ b/packages/yew/src/refresh_ccw.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RefreshCcwProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RefreshCcw(props: &RefreshCcwProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" />
+            <path d="M3 3v5h5" />
+            <path d="M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16" />
+            <path d="M16 16h5v5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/refresh_ccw_dot.rs b/packages/yew/src/refresh_ccw_dot.rs
new file mode 100644
index 0000000..87f397d
--- /dev/null
+++ b/packages/yew/src/refresh_ccw_dot.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RefreshCcwDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RefreshCcwDot(props: &RefreshCcwDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 2v6h6" />
+            <path d="M21 12A9 9 0 0 0 6 5.3L3 8" />
+            <path d="M21 22v-6h-6" />
+            <path d="M3 12a9 9 0 0 0 15 6.7l3-2.7" />
+            <circle cx="12" cy="12" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/refresh_cw.rs b/packages/yew/src/refresh_cw.rs
new file mode 100644
index 0000000..a03677d
--- /dev/null
+++ b/packages/yew/src/refresh_cw.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RefreshCwProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RefreshCw(props: &RefreshCwProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8" />
+            <path d="M21 3v5h-5" />
+            <path d="M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16" />
+            <path d="M8 16H3v5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/refresh_cw_off.rs b/packages/yew/src/refresh_cw_off.rs
new file mode 100644
index 0000000..c8f5189
--- /dev/null
+++ b/packages/yew/src/refresh_cw_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RefreshCwOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RefreshCwOff(props: &RefreshCwOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 8L18.74 5.74A9.75 9.75 0 0 0 12 3C11 3 10.03 3.16 9.13 3.47" />
+            <path d="M8 16H3v5" />
+            <path d="M3 12C3 9.51 4 7.26 5.64 5.64" />
+            <path d="m3 16 2.26 2.26A9.75 9.75 0 0 0 12 21c2.49 0 4.74-1 6.36-2.64" />
+            <path d="M21 12c0 1-.16 1.97-.47 2.87" />
+            <path d="M21 3v5h-5" />
+            <path d="M22 22 2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/refrigerator.rs b/packages/yew/src/refrigerator.rs
new file mode 100644
index 0000000..b5b0715
--- /dev/null
+++ b/packages/yew/src/refrigerator.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RefrigeratorProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Refrigerator(props: &RefrigeratorProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 6a4 4 0 0 1 4-4h6a4 4 0 0 1 4 4v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6Z" />
+            <path d="M5 10h14" />
+            <path d="M15 7v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/regex.rs b/packages/yew/src/regex.rs
new file mode 100644
index 0000000..98292dc
--- /dev/null
+++ b/packages/yew/src/regex.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RegexProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Regex(props: &RegexProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 3v10" />
+            <path d="m12.67 5.5 8.66 5" />
+            <path d="m12.67 10.5 8.66-5" />
+            <path d="M9 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/remove_formatting.rs b/packages/yew/src/remove_formatting.rs
new file mode 100644
index 0000000..ee5dcb6
--- /dev/null
+++ b/packages/yew/src/remove_formatting.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RemoveFormattingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RemoveFormatting(props: &RemoveFormattingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 7V4h16v3" />
+            <path d="M5 20h6" />
+            <path d="M13 4 8 20" />
+            <path d="m15 15 5 5" />
+            <path d="m20 15-5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/repeat.rs b/packages/yew/src/repeat.rs
new file mode 100644
index 0000000..20d4a74
--- /dev/null
+++ b/packages/yew/src/repeat.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RepeatProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Repeat(props: &RepeatProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 2 4 4-4 4" />
+            <path d="M3 11v-1a4 4 0 0 1 4-4h14" />
+            <path d="m7 22-4-4 4-4" />
+            <path d="M21 13v1a4 4 0 0 1-4 4H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/repeat_1.rs b/packages/yew/src/repeat_1.rs
new file mode 100644
index 0000000..e37a42d
--- /dev/null
+++ b/packages/yew/src/repeat_1.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Repeat1Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Repeat1(props: &Repeat1Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m17 2 4 4-4 4" />
+            <path d="M3 11v-1a4 4 0 0 1 4-4h14" />
+            <path d="m7 22-4-4 4-4" />
+            <path d="M21 13v1a4 4 0 0 1-4 4H3" />
+            <path d="M11 10h1v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/repeat_2.rs b/packages/yew/src/repeat_2.rs
new file mode 100644
index 0000000..d995ab4
--- /dev/null
+++ b/packages/yew/src/repeat_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Repeat2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Repeat2(props: &Repeat2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 9 3-3 3 3" />
+            <path d="M13 18H7a2 2 0 0 1-2-2V6" />
+            <path d="m22 15-3 3-3-3" />
+            <path d="M11 6h6a2 2 0 0 1 2 2v10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/replace.rs b/packages/yew/src/replace.rs
new file mode 100644
index 0000000..97bb2d4
--- /dev/null
+++ b/packages/yew/src/replace.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReplaceProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Replace(props: &ReplaceProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 4a2 2 0 0 1 2-2" />
+            <path d="M16 10a2 2 0 0 1-2-2" />
+            <path d="M20 2a2 2 0 0 1 2 2" />
+            <path d="M22 8a2 2 0 0 1-2 2" />
+            <path d="m3 7 3 3 3-3" />
+            <path d="M6 10V5a3 3 0 0 1 3-3h1" />
+            <rect x="2" y="14" width="8" height="8" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/replace_all.rs b/packages/yew/src/replace_all.rs
new file mode 100644
index 0000000..8e2a0ae
--- /dev/null
+++ b/packages/yew/src/replace_all.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReplaceAllProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReplaceAll(props: &ReplaceAllProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 14a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2" />
+            <path d="M14 4a2 2 0 0 1 2-2" />
+            <path d="M16 10a2 2 0 0 1-2-2" />
+            <path d="M20 14a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2" />
+            <path d="M20 2a2 2 0 0 1 2 2" />
+            <path d="M22 8a2 2 0 0 1-2 2" />
+            <path d="m3 7 3 3 3-3" />
+            <path d="M6 10V5a 3 3 0 0 1 3-3h1" />
+            <rect x="2" y="14" width="8" height="8" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/reply.rs b/packages/yew/src/reply.rs
new file mode 100644
index 0000000..993da07
--- /dev/null
+++ b/packages/yew/src/reply.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReplyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Reply(props: &ReplyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="9 17 4 12 9 7" />
+            <path d="M20 18v-2a4 4 0 0 0-4-4H4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/reply_all.rs b/packages/yew/src/reply_all.rs
new file mode 100644
index 0000000..451217f
--- /dev/null
+++ b/packages/yew/src/reply_all.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ReplyAllProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ReplyAll(props: &ReplyAllProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="7 17 2 12 7 7" />
+            <polyline points="12 17 7 12 12 7" />
+            <path d="M22 18v-2a4 4 0 0 0-4-4H7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rewind.rs b/packages/yew/src/rewind.rs
new file mode 100644
index 0000000..f78636e
--- /dev/null
+++ b/packages/yew/src/rewind.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RewindProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rewind(props: &RewindProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="11 19 2 12 11 5 11 19" />
+            <polygon points="22 19 13 12 22 5 22 19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ribbon.rs b/packages/yew/src/ribbon.rs
new file mode 100644
index 0000000..4323a56
--- /dev/null
+++ b/packages/yew/src/ribbon.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RibbonProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ribbon(props: &RibbonProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 11.22C11 9.997 10 9 10 8a2 2 0 0 1 4 0c0 1-.998 2.002-2.01 3.22" />
+            <path d="m12 18 2.57-3.5" />
+            <path d="M6.243 9.016a7 7 0 0 1 11.507-.009" />
+            <path d="M9.35 14.53 12 11.22" />
+            <path
+                d="M9.35 14.53C7.728 12.246 6 10.221 6 7a6 5 0 0 1 12 0c-.005 3.22-1.778 5.235-3.43 7.5l3.557 4.527a1 1 0 0 1-.203 1.43l-1.894 1.36a1 1 0 0 1-1.384-.215L12 18l-2.679 3.593a1 1 0 0 1-1.39.213l-1.865-1.353a1 1 0 0 1-.203-1.422z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rocket.rs b/packages/yew/src/rocket.rs
new file mode 100644
index 0000000..6246615
--- /dev/null
+++ b/packages/yew/src/rocket.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RocketProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rocket(props: &RocketProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z"
+            />
+            <path
+                d="m12 15-3-3a22 22 0 0 1 2-3.95A12.88 12.88 0 0 1 22 2c0 2.72-.78 7.5-6 11a22.35 22.35 0 0 1-4 2z"
+            />
+            <path d="M9 12H4s.55-3.03 2-4c1.62-1.08 5 0 5 0" />
+            <path d="M12 15v5s3.03-.55 4-2c1.08-1.62 0-5 0-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rocking_chair.rs b/packages/yew/src/rocking_chair.rs
new file mode 100644
index 0000000..e3c0553
--- /dev/null
+++ b/packages/yew/src/rocking_chair.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RockingChairProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RockingChair(props: &RockingChairProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="3.5 2 6.5 12.5 18 12.5" />
+            <line x1="9.5" x2="5.5" y1="12.5" y2="20" />
+            <line x1="15" x2="18.5" y1="12.5" y2="20" />
+            <path d="M2.75 18a13 13 0 0 0 18.5 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/roller_coaster.rs b/packages/yew/src/roller_coaster.rs
new file mode 100644
index 0000000..c2f758a
--- /dev/null
+++ b/packages/yew/src/roller_coaster.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RollerCoasterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RollerCoaster(props: &RollerCoasterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 19V5" />
+            <path d="M10 19V6.8" />
+            <path d="M14 19v-7.8" />
+            <path d="M18 5v4" />
+            <path d="M18 19v-6" />
+            <path d="M22 19V9" />
+            <path d="M2 19V9a4 4 0 0 1 4-4c2 0 4 1.33 6 4s4 4 6 4a4 4 0 1 0-3-6.65" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rotate_3_d.rs b/packages/yew/src/rotate_3_d.rs
new file mode 100644
index 0000000..5946a08
--- /dev/null
+++ b/packages/yew/src/rotate_3_d.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Rotate3DProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rotate3D(props: &Rotate3DProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M16.466 7.5C15.643 4.237 13.952 2 12 2 9.239 2 7 6.477 7 12s2.239 10 5 10c.342 0 .677-.069 1-.2"
+            />
+            <path d="m15.194 13.707 3.814 1.86-1.86 3.814" />
+            <path
+                d="M19 15.57c-1.804.885-4.274 1.43-7 1.43-5.523 0-10-2.239-10-5s4.477-5 10-5c4.838 0 8.873 1.718 9.8 4"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rotate_ccw.rs b/packages/yew/src/rotate_ccw.rs
new file mode 100644
index 0000000..9507df5
--- /dev/null
+++ b/packages/yew/src/rotate_ccw.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RotateCcwProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RotateCcw(props: &RotateCcwProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" />
+            <path d="M3 3v5h5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rotate_ccw_square.rs b/packages/yew/src/rotate_ccw_square.rs
new file mode 100644
index 0000000..4764cf4
--- /dev/null
+++ b/packages/yew/src/rotate_ccw_square.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RotateCcwSquareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RotateCcwSquare(props: &RotateCcwSquareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 9V7a2 2 0 0 0-2-2h-6" />
+            <path d="m15 2-3 3 3 3" />
+            <path d="M20 13v5a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rotate_cw.rs b/packages/yew/src/rotate_cw.rs
new file mode 100644
index 0000000..f315014
--- /dev/null
+++ b/packages/yew/src/rotate_cw.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RotateCwProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RotateCw(props: &RotateCwProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8" />
+            <path d="M21 3v5h-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rotate_cw_square.rs b/packages/yew/src/rotate_cw_square.rs
new file mode 100644
index 0000000..fd4eb62
--- /dev/null
+++ b/packages/yew/src/rotate_cw_square.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RotateCwSquareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RotateCwSquare(props: &RotateCwSquareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 5H6a2 2 0 0 0-2 2v3" />
+            <path d="m9 8 3-3-3-3" />
+            <path d="M4 14v4a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/route.rs b/packages/yew/src/route.rs
new file mode 100644
index 0000000..89c4acf
--- /dev/null
+++ b/packages/yew/src/route.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RouteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Route(props: &RouteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="19" r="3" />
+            <path d="M9 19h8.5a3.5 3.5 0 0 0 0-7h-11a3.5 3.5 0 0 1 0-7H15" />
+            <circle cx="18" cy="5" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/route_off.rs b/packages/yew/src/route_off.rs
new file mode 100644
index 0000000..e8bad1f
--- /dev/null
+++ b/packages/yew/src/route_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RouteOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RouteOff(props: &RouteOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="19" r="3" />
+            <path d="M9 19h8.5c.4 0 .9-.1 1.3-.2" />
+            <path d="M5.2 5.2A3.5 3.53 0 0 0 6.5 12H12" />
+            <path d="m2 2 20 20" />
+            <path d="M21 15.3a3.5 3.5 0 0 0-3.3-3.3" />
+            <path d="M15 5h-4.3" />
+            <circle cx="18" cy="5" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/router.rs b/packages/yew/src/router.rs
new file mode 100644
index 0000000..a2a01b0
--- /dev/null
+++ b/packages/yew/src/router.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RouterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Router(props: &RouterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="8" x="2" y="14" rx="2" />
+            <path d="M6.01 18H6" />
+            <path d="M10.01 18H10" />
+            <path d="M15 10v4" />
+            <path d="M17.84 7.17a4 4 0 0 0-5.66 0" />
+            <path d="M20.66 4.34a8 8 0 0 0-11.31 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rows_2.rs b/packages/yew/src/rows_2.rs
new file mode 100644
index 0000000..1186df8
--- /dev/null
+++ b/packages/yew/src/rows_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Rows2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rows2(props: &Rows2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 12h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rows_3.rs b/packages/yew/src/rows_3.rs
new file mode 100644
index 0000000..1c3ca35
--- /dev/null
+++ b/packages/yew/src/rows_3.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Rows3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rows3(props: &Rows3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M21 9H3" />
+            <path d="M21 15H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rows_4.rs b/packages/yew/src/rows_4.rs
new file mode 100644
index 0000000..983915c
--- /dev/null
+++ b/packages/yew/src/rows_4.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Rows4Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rows4(props: &Rows4Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M21 7.5H3" />
+            <path d="M21 12H3" />
+            <path d="M21 16.5H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/rss.rs b/packages/yew/src/rss.rs
new file mode 100644
index 0000000..c6fbf26
--- /dev/null
+++ b/packages/yew/src/rss.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RssProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Rss(props: &RssProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 11a9 9 0 0 1 9 9" />
+            <path d="M4 4a16 16 0 0 1 16 16" />
+            <circle cx="5" cy="19" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ruler.rs b/packages/yew/src/ruler.rs
new file mode 100644
index 0000000..ee21202
--- /dev/null
+++ b/packages/yew/src/ruler.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RulerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ruler(props: &RulerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M21.3 15.3a2.4 2.4 0 0 1 0 3.4l-2.6 2.6a2.4 2.4 0 0 1-3.4 0L2.7 8.7a2.41 2.41 0 0 1 0-3.4l2.6-2.6a2.41 2.41 0 0 1 3.4 0Z"
+            />
+            <path d="m14.5 12.5 2-2" />
+            <path d="m11.5 9.5 2-2" />
+            <path d="m8.5 6.5 2-2" />
+            <path d="m17.5 15.5 2-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/russian_ruble.rs b/packages/yew/src/russian_ruble.rs
new file mode 100644
index 0000000..8ec9fa5
--- /dev/null
+++ b/packages/yew/src/russian_ruble.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct RussianRubleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn RussianRuble(props: &RussianRubleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 11h8a4 4 0 0 0 0-8H9v18" />
+            <path d="M6 15h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sailboat.rs b/packages/yew/src/sailboat.rs
new file mode 100644
index 0000000..9d6dbdb
--- /dev/null
+++ b/packages/yew/src/sailboat.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SailboatProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sailboat(props: &SailboatProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 18H2a4 4 0 0 0 4 4h12a4 4 0 0 0 4-4Z" />
+            <path d="M21 14 10 2 3 14h18Z" />
+            <path d="M10 2v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/salad.rs b/packages/yew/src/salad.rs
new file mode 100644
index 0000000..2ed0d17
--- /dev/null
+++ b/packages/yew/src/salad.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SaladProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Salad(props: &SaladProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 21h10" />
+            <path d="M12 21a9 9 0 0 0 9-9H3a9 9 0 0 0 9 9Z" />
+            <path
+                d="M11.38 12a2.4 2.4 0 0 1-.4-4.77 2.4 2.4 0 0 1 3.2-2.77 2.4 2.4 0 0 1 3.47-.63 2.4 2.4 0 0 1 3.37 3.37 2.4 2.4 0 0 1-1.1 3.7 2.51 2.51 0 0 1 .03 1.1"
+            />
+            <path d="m13 12 4-4" />
+            <path d="M10.9 7.25A3.99 3.99 0 0 0 4 10c0 .73.2 1.41.54 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sandwich.rs b/packages/yew/src/sandwich.rs
new file mode 100644
index 0000000..54808e8
--- /dev/null
+++ b/packages/yew/src/sandwich.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SandwichProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sandwich(props: &SandwichProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2.37 11.223 8.372-6.777a2 2 0 0 1 2.516 0l8.371 6.777" />
+            <path d="M21 15a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1h-5.25" />
+            <path d="M3 15a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h9" />
+            <path d="m6.67 15 6.13 4.6a2 2 0 0 0 2.8-.4l3.15-4.2" />
+            <rect width="20" height="4" x="2" y="11" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/satellite.rs b/packages/yew/src/satellite.rs
new file mode 100644
index 0000000..73f1d49
--- /dev/null
+++ b/packages/yew/src/satellite.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SatelliteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Satellite(props: &SatelliteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 7 9 3 5 7l4 4" />
+            <path d="m17 11 4 4-4 4-4-4" />
+            <path d="m8 12 4 4 6-6-4-4Z" />
+            <path d="m16 8 3-3" />
+            <path d="M9 21a6 6 0 0 0-6-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/satellite_dish.rs b/packages/yew/src/satellite_dish.rs
new file mode 100644
index 0000000..de44003
--- /dev/null
+++ b/packages/yew/src/satellite_dish.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SatelliteDishProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SatelliteDish(props: &SatelliteDishProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10a7.31 7.31 0 0 0 10 10Z" />
+            <path d="m9 15 3-3" />
+            <path d="M17 13a6 6 0 0 0-6-6" />
+            <path d="M21 13A10 10 0 0 0 11 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/save.rs b/packages/yew/src/save.rs
new file mode 100644
index 0000000..5ab0a88
--- /dev/null
+++ b/packages/yew/src/save.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SaveProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Save(props: &SaveProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M15.2 3a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2z"
+            />
+            <path d="M17 21v-7a1 1 0 0 0-1-1H8a1 1 0 0 0-1 1v7" />
+            <path d="M7 3v4a1 1 0 0 0 1 1h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/save_all.rs b/packages/yew/src/save_all.rs
new file mode 100644
index 0000000..e345297
--- /dev/null
+++ b/packages/yew/src/save_all.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SaveAllProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SaveAll(props: &SaveAllProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v3a1 1 0 0 0 1 1h5" />
+            <path d="M18 18v-6a1 1 0 0 0-1-1h-6a1 1 0 0 0-1 1v6" />
+            <path d="M18 22H4a2 2 0 0 1-2-2V6" />
+            <path
+                d="M8 18a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9.172a2 2 0 0 1 1.414.586l2.828 2.828A2 2 0 0 1 22 6.828V16a2 2 0 0 1-2.01 2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/save_off.rs b/packages/yew/src/save_off.rs
new file mode 100644
index 0000000..4aebdeb
--- /dev/null
+++ b/packages/yew/src/save_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SaveOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SaveOff(props: &SaveOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 13H8a1 1 0 0 0-1 1v7" />
+            <path d="M14 8h1" />
+            <path d="M17 21v-4" />
+            <path d="m2 2 20 20" />
+            <path d="M20.41 20.41A2 2 0 0 1 19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 .59-1.41" />
+            <path d="M29.5 11.5s5 5 4 5" />
+            <path d="M9 3h6.2a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scale.rs b/packages/yew/src/scale.rs
new file mode 100644
index 0000000..7958806
--- /dev/null
+++ b/packages/yew/src/scale.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScaleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Scale(props: &ScaleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 16 3-8 3 8c-.87.65-1.92 1-3 1s-2.13-.35-3-1Z" />
+            <path d="m2 16 3-8 3 8c-.87.65-1.92 1-3 1s-2.13-.35-3-1Z" />
+            <path d="M7 21h10" />
+            <path d="M12 3v18" />
+            <path d="M3 7h2c2 0 5-1 7-2 2 1 5 2 7 2h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scale_3_d.rs b/packages/yew/src/scale_3_d.rs
new file mode 100644
index 0000000..358f30e
--- /dev/null
+++ b/packages/yew/src/scale_3_d.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Scale3DProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Scale3D(props: &Scale3DProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="19" cy="19" r="2" />
+            <circle cx="5" cy="5" r="2" />
+            <path d="M5 7v12h12" />
+            <path d="m5 19 6-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scaling.rs b/packages/yew/src/scaling.rs
new file mode 100644
index 0000000..debd0ac
--- /dev/null
+++ b/packages/yew/src/scaling.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScalingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Scaling(props: &ScalingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" />
+            <path d="M14 15H9v-5" />
+            <path d="M16 3h5v5" />
+            <path d="M21 3 9 15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scan.rs b/packages/yew/src/scan.rs
new file mode 100644
index 0000000..3a9bc81
--- /dev/null
+++ b/packages/yew/src/scan.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Scan(props: &ScanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scan_barcode.rs b/packages/yew/src/scan_barcode.rs
new file mode 100644
index 0000000..42f7a11
--- /dev/null
+++ b/packages/yew/src/scan_barcode.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScanBarcodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScanBarcode(props: &ScanBarcodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+            <path d="M8 7v10" />
+            <path d="M12 7v10" />
+            <path d="M17 7v10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scan_eye.rs b/packages/yew/src/scan_eye.rs
new file mode 100644
index 0000000..5f5c0c0
--- /dev/null
+++ b/packages/yew/src/scan_eye.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScanEyeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScanEye(props: &ScanEyeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+            <circle cx="12" cy="12" r="1" />
+            <path
+                d="M18.944 12.33a1 1 0 0 0 0-.66 7.5 7.5 0 0 0-13.888 0 1 1 0 0 0 0 .66 7.5 7.5 0 0 0 13.888 0"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scan_face.rs b/packages/yew/src/scan_face.rs
new file mode 100644
index 0000000..c0f5807
--- /dev/null
+++ b/packages/yew/src/scan_face.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScanFaceProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScanFace(props: &ScanFaceProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+            <path d="M8 14s1.5 2 4 2 4-2 4-2" />
+            <path d="M9 9h.01" />
+            <path d="M15 9h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scan_line.rs b/packages/yew/src/scan_line.rs
new file mode 100644
index 0000000..ae6fc52
--- /dev/null
+++ b/packages/yew/src/scan_line.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScanLineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScanLine(props: &ScanLineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+            <path d="M7 12h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scan_qr_code.rs b/packages/yew/src/scan_qr_code.rs
new file mode 100644
index 0000000..4e4c663
--- /dev/null
+++ b/packages/yew/src/scan_qr_code.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScanQrCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScanQrCode(props: &ScanQrCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 12v4a1 1 0 0 1-1 1h-4" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M17 8V7" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M7 17h.01" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+            <rect x="7" y="7" width="5" height="5" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scan_search.rs b/packages/yew/src/scan_search.rs
new file mode 100644
index 0000000..3c9d099
--- /dev/null
+++ b/packages/yew/src/scan_search.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScanSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScanSearch(props: &ScanSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+            <circle cx="12" cy="12" r="3" />
+            <path d="m16 16-1.9-1.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scan_text.rs b/packages/yew/src/scan_text.rs
new file mode 100644
index 0000000..d6d58bd
--- /dev/null
+++ b/packages/yew/src/scan_text.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScanTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScanText(props: &ScanTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7V5a2 2 0 0 1 2-2h2" />
+            <path d="M17 3h2a2 2 0 0 1 2 2v2" />
+            <path d="M21 17v2a2 2 0 0 1-2 2h-2" />
+            <path d="M7 21H5a2 2 0 0 1-2-2v-2" />
+            <path d="M7 8h8" />
+            <path d="M7 12h10" />
+            <path d="M7 16h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/school.rs b/packages/yew/src/school.rs
new file mode 100644
index 0000000..591d3d2
--- /dev/null
+++ b/packages/yew/src/school.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SchoolProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn School(props: &SchoolProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 22v-4a2 2 0 1 0-4 0v4" />
+            <path
+                d="m18 10 3.447 1.724a1 1 0 0 1 .553.894V20a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-7.382a1 1 0 0 1 .553-.894L6 10"
+            />
+            <path d="M18 5v17" />
+            <path d="m4 6 7.106-3.553a2 2 0 0 1 1.788 0L20 6" />
+            <path d="M6 5v17" />
+            <circle cx="12" cy="9" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scissors.rs b/packages/yew/src/scissors.rs
new file mode 100644
index 0000000..6363ec4
--- /dev/null
+++ b/packages/yew/src/scissors.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScissorsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Scissors(props: &ScissorsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="6" r="3" />
+            <path d="M8.12 8.12 12 12" />
+            <path d="M20 4 8.12 15.88" />
+            <circle cx="6" cy="18" r="3" />
+            <path d="M14.8 14.8 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scissors_line_dashed.rs b/packages/yew/src/scissors_line_dashed.rs
new file mode 100644
index 0000000..8c1237a
--- /dev/null
+++ b/packages/yew/src/scissors_line_dashed.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScissorsLineDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScissorsLineDashed(props: &ScissorsLineDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5.42 9.42 8 12" />
+            <circle cx="4" cy="8" r="2" />
+            <path d="m14 6-8.58 8.58" />
+            <circle cx="4" cy="16" r="2" />
+            <path d="M10.8 14.8 14 18" />
+            <path d="M16 12h-2" />
+            <path d="M22 12h-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/screen_share.rs b/packages/yew/src/screen_share.rs
new file mode 100644
index 0000000..0327ec5
--- /dev/null
+++ b/packages/yew/src/screen_share.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScreenShareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScreenShare(props: &ScreenShareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 3H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-3" />
+            <path d="M8 21h8" />
+            <path d="M12 17v4" />
+            <path d="m17 8 5-5" />
+            <path d="M17 3h5v5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/screen_share_off.rs b/packages/yew/src/screen_share_off.rs
new file mode 100644
index 0000000..ec24820
--- /dev/null
+++ b/packages/yew/src/screen_share_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScreenShareOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScreenShareOff(props: &ScreenShareOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 3H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-3" />
+            <path d="M8 21h8" />
+            <path d="M12 17v4" />
+            <path d="m22 3-5 5" />
+            <path d="m17 3 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scroll.rs b/packages/yew/src/scroll.rs
new file mode 100644
index 0000000..8cce179
--- /dev/null
+++ b/packages/yew/src/scroll.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScrollProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Scroll(props: &ScrollProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 17V5a2 2 0 0 0-2-2H4" />
+            <path
+                d="M8 21h12a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1H11a1 1 0 0 0-1 1v1a2 2 0 1 1-4 0V5a2 2 0 1 0-4 0v2a1 1 0 0 0 1 1h3"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/scroll_text.rs b/packages/yew/src/scroll_text.rs
new file mode 100644
index 0000000..d0765f9
--- /dev/null
+++ b/packages/yew/src/scroll_text.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ScrollTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ScrollText(props: &ScrollTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 12h-5" />
+            <path d="M15 8h-5" />
+            <path d="M19 17V5a2 2 0 0 0-2-2H4" />
+            <path
+                d="M8 21h12a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1H11a1 1 0 0 0-1 1v1a2 2 0 1 1-4 0V5a2 2 0 1 0-4 0v2a1 1 0 0 0 1 1h3"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/search.rs b/packages/yew/src/search.rs
new file mode 100644
index 0000000..d7ed7ae
--- /dev/null
+++ b/packages/yew/src/search.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Search(props: &SearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="11" r="8" />
+            <path d="m21 21-4.3-4.3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/search_check.rs b/packages/yew/src/search_check.rs
new file mode 100644
index 0000000..4ee0cbe
--- /dev/null
+++ b/packages/yew/src/search_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SearchCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SearchCheck(props: &SearchCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m8 11 2 2 4-4" />
+            <circle cx="11" cy="11" r="8" />
+            <path d="m21 21-4.3-4.3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/search_code.rs b/packages/yew/src/search_code.rs
new file mode 100644
index 0000000..d1c9879
--- /dev/null
+++ b/packages/yew/src/search_code.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SearchCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SearchCode(props: &SearchCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m13 13.5 2-2.5-2-2.5" />
+            <path d="m21 21-4.3-4.3" />
+            <path d="M9 8.5 7 11l2 2.5" />
+            <circle cx="11" cy="11" r="8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/search_slash.rs b/packages/yew/src/search_slash.rs
new file mode 100644
index 0000000..c339db4
--- /dev/null
+++ b/packages/yew/src/search_slash.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SearchSlashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SearchSlash(props: &SearchSlashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m13.5 8.5-5 5" />
+            <circle cx="11" cy="11" r="8" />
+            <path d="m21 21-4.3-4.3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/search_x.rs b/packages/yew/src/search_x.rs
new file mode 100644
index 0000000..0bd7712
--- /dev/null
+++ b/packages/yew/src/search_x.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SearchXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SearchX(props: &SearchXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m13.5 8.5-5 5" />
+            <path d="m8.5 8.5 5 5" />
+            <circle cx="11" cy="11" r="8" />
+            <path d="m21 21-4.3-4.3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/section.rs b/packages/yew/src/section.rs
new file mode 100644
index 0000000..d10b99f
--- /dev/null
+++ b/packages/yew/src/section.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SectionProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Section(props: &SectionProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 5a4 3 0 0 0-8 0c0 4 8 3 8 7a4 3 0 0 1-8 0" />
+            <path d="M8 19a4 3 0 0 0 8 0c0-4-8-3-8-7a4 3 0 0 1 8 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/send.rs b/packages/yew/src/send.rs
new file mode 100644
index 0000000..f589be4
--- /dev/null
+++ b/packages/yew/src/send.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SendProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Send(props: &SendProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M14.536 21.686a.5.5 0 0 0 .937-.024l6.5-19a.496.496 0 0 0-.635-.635l-19 6.5a.5.5 0 0 0-.024.937l7.93 3.18a2 2 0 0 1 1.112 1.11z"
+            />
+            <path d="m21.854 2.147-10.94 10.939" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/send_horizontal.rs b/packages/yew/src/send_horizontal.rs
new file mode 100644
index 0000000..071c199
--- /dev/null
+++ b/packages/yew/src/send_horizontal.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SendHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SendHorizontal(props: &SendHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M3.714 3.048a.498.498 0 0 0-.683.627l2.843 7.627a2 2 0 0 1 0 1.396l-2.842 7.627a.498.498 0 0 0 .682.627l18-8.5a.5.5 0 0 0 0-.904z"
+            />
+            <path d="M6 12h16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/send_to_back.rs b/packages/yew/src/send_to_back.rs
new file mode 100644
index 0000000..1c51773
--- /dev/null
+++ b/packages/yew/src/send_to_back.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SendToBackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SendToBack(props: &SendToBackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="14" y="14" width="8" height="8" rx="2" />
+            <rect x="2" y="2" width="8" height="8" rx="2" />
+            <path d="M7 14v1a2 2 0 0 0 2 2h1" />
+            <path d="M14 7h1a2 2 0 0 1 2 2v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/separator_horizontal.rs b/packages/yew/src/separator_horizontal.rs
new file mode 100644
index 0000000..656b758
--- /dev/null
+++ b/packages/yew/src/separator_horizontal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SeparatorHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SeparatorHorizontal(props: &SeparatorHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="3" x2="21" y1="12" y2="12" />
+            <polyline points="8 8 12 4 16 8" />
+            <polyline points="16 16 12 20 8 16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/separator_vertical.rs b/packages/yew/src/separator_vertical.rs
new file mode 100644
index 0000000..c75c90f
--- /dev/null
+++ b/packages/yew/src/separator_vertical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SeparatorVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SeparatorVertical(props: &SeparatorVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="12" x2="12" y1="3" y2="21" />
+            <polyline points="8 8 4 12 8 16" />
+            <polyline points="16 16 20 12 16 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/server.rs b/packages/yew/src/server.rs
new file mode 100644
index 0000000..a57d73f
--- /dev/null
+++ b/packages/yew/src/server.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ServerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Server(props: &ServerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="8" x="2" y="2" rx="2" ry="2" />
+            <rect width="20" height="8" x="2" y="14" rx="2" ry="2" />
+            <line x1="6" x2="6.01" y1="6" y2="6" />
+            <line x1="6" x2="6.01" y1="18" y2="18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/server_cog.rs b/packages/yew/src/server_cog.rs
new file mode 100644
index 0000000..92f467b
--- /dev/null
+++ b/packages/yew/src/server_cog.rs
@@ -0,0 +1,58 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ServerCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ServerCog(props: &ServerCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="3" />
+            <path d="M4.5 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-.5" />
+            <path
+                d="M4.5 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-.5"
+            />
+            <path d="M6 6h.01" />
+            <path d="M6 18h.01" />
+            <path d="m15.7 13.4-.9-.3" />
+            <path d="m9.2 10.9-.9-.3" />
+            <path d="m10.6 15.7.3-.9" />
+            <path d="m13.6 15.7-.4-1" />
+            <path d="m10.8 9.3-.4-1" />
+            <path d="m8.3 13.6 1-.4" />
+            <path d="m14.7 10.8 1-.4" />
+            <path d="m13.4 8.3-.3.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/server_crash.rs b/packages/yew/src/server_crash.rs
new file mode 100644
index 0000000..4aa8b83
--- /dev/null
+++ b/packages/yew/src/server_crash.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ServerCrashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ServerCrash(props: &ServerCrashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-2" />
+            <path d="M6 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-2" />
+            <path d="M6 6h.01" />
+            <path d="M6 18h.01" />
+            <path d="m13 6-4 6h6l-4 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/server_off.rs b/packages/yew/src/server_off.rs
new file mode 100644
index 0000000..b6aef51
--- /dev/null
+++ b/packages/yew/src/server_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ServerOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ServerOff(props: &ServerOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 2h13a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-5" />
+            <path d="M10 10 2.5 2.5C2 2 2 2.5 2 5v3a2 2 0 0 0 2 2h6z" />
+            <path d="M22 17v-1a2 2 0 0 0-2-2h-1" />
+            <path d="M4 14a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16.5l1-.5.5.5-8-8H4z" />
+            <path d="M6 18h.01" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/settings.rs b/packages/yew/src/settings.rs
new file mode 100644
index 0000000..3fe3cdc
--- /dev/null
+++ b/packages/yew/src/settings.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SettingsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Settings(props: &SettingsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"
+            />
+            <circle cx="12" cy="12" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/settings_2.rs b/packages/yew/src/settings_2.rs
new file mode 100644
index 0000000..fefda35
--- /dev/null
+++ b/packages/yew/src/settings_2.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Settings2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Settings2(props: &Settings2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 7h-9" />
+            <path d="M14 17H5" />
+            <circle cx="17" cy="17" r="3" />
+            <circle cx="7" cy="7" r="3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shapes.rs b/packages/yew/src/shapes.rs
new file mode 100644
index 0000000..f9cd9df
--- /dev/null
+++ b/packages/yew/src/shapes.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShapesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Shapes(props: &ShapesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M8.3 10a.7.7 0 0 1-.626-1.079L11.4 3a.7.7 0 0 1 1.198-.043L16.3 8.9a.7.7 0 0 1-.572 1.1Z"
+            />
+            <rect x="3" y="14" width="7" height="7" rx="1" />
+            <circle cx="17.5" cy="17.5" r="3.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/share.rs b/packages/yew/src/share.rs
new file mode 100644
index 0000000..b570359
--- /dev/null
+++ b/packages/yew/src/share.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Share(props: &ShareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8" />
+            <polyline points="16 6 12 2 8 6" />
+            <line x1="12" x2="12" y1="2" y2="15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/share_2.rs b/packages/yew/src/share_2.rs
new file mode 100644
index 0000000..c6be57d
--- /dev/null
+++ b/packages/yew/src/share_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Share2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Share2(props: &Share2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="5" r="3" />
+            <circle cx="6" cy="12" r="3" />
+            <circle cx="18" cy="19" r="3" />
+            <line x1="8.59" x2="15.42" y1="13.51" y2="17.49" />
+            <line x1="15.41" x2="8.59" y1="6.51" y2="10.49" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sheet.rs b/packages/yew/src/sheet.rs
new file mode 100644
index 0000000..2923485
--- /dev/null
+++ b/packages/yew/src/sheet.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SheetProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sheet(props: &SheetProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <line x1="3" x2="21" y1="9" y2="9" />
+            <line x1="3" x2="21" y1="15" y2="15" />
+            <line x1="9" x2="9" y1="9" y2="21" />
+            <line x1="15" x2="15" y1="9" y2="21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shell.rs b/packages/yew/src/shell.rs
new file mode 100644
index 0000000..a18d006
--- /dev/null
+++ b/packages/yew/src/shell.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShellProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Shell(props: &ShellProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M14 11a2 2 0 1 1-4 0 4 4 0 0 1 8 0 6 6 0 0 1-12 0 8 8 0 0 1 16 0 10 10 0 1 1-20 0 11.93 11.93 0 0 1 2.42-7.22 2 2 0 1 1 3.16 2.44"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield.rs b/packages/yew/src/shield.rs
new file mode 100644
index 0000000..8f231f4
--- /dev/null
+++ b/packages/yew/src/shield.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Shield(props: &ShieldProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_alert.rs b/packages/yew/src/shield_alert.rs
new file mode 100644
index 0000000..400fc77
--- /dev/null
+++ b/packages/yew/src/shield_alert.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldAlertProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldAlert(props: &ShieldAlertProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="M12 8v4" />
+            <path d="M12 16h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_ban.rs b/packages/yew/src/shield_ban.rs
new file mode 100644
index 0000000..af66963
--- /dev/null
+++ b/packages/yew/src/shield_ban.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldBanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldBan(props: &ShieldBanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="m4.243 5.21 14.39 12.472" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_check.rs b/packages/yew/src/shield_check.rs
new file mode 100644
index 0000000..95538df
--- /dev/null
+++ b/packages/yew/src/shield_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldCheck(props: &ShieldCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="m9 12 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_ellipsis.rs b/packages/yew/src/shield_ellipsis.rs
new file mode 100644
index 0000000..028c59d
--- /dev/null
+++ b/packages/yew/src/shield_ellipsis.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldEllipsisProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldEllipsis(props: &ShieldEllipsisProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="M8 12h.01" />
+            <path d="M12 12h.01" />
+            <path d="M16 12h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_half.rs b/packages/yew/src/shield_half.rs
new file mode 100644
index 0000000..be1edda
--- /dev/null
+++ b/packages/yew/src/shield_half.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldHalfProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldHalf(props: &ShieldHalfProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="M12 22V2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_minus.rs b/packages/yew/src/shield_minus.rs
new file mode 100644
index 0000000..1089e44
--- /dev/null
+++ b/packages/yew/src/shield_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldMinus(props: &ShieldMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="M9 12h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_off.rs b/packages/yew/src/shield_off.rs
new file mode 100644
index 0000000..5816b7a
--- /dev/null
+++ b/packages/yew/src/shield_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldOff(props: &ShieldOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 2 20 20" />
+            <path
+                d="M5 5a1 1 0 0 0-1 1v7c0 5 3.5 7.5 7.67 8.94a1 1 0 0 0 .67.01c2.35-.82 4.48-1.97 5.9-3.71"
+            />
+            <path
+                d="M9.309 3.652A12.252 12.252 0 0 0 11.24 2.28a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1v7a9.784 9.784 0 0 1-.08 1.264"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_plus.rs b/packages/yew/src/shield_plus.rs
new file mode 100644
index 0000000..64a6200
--- /dev/null
+++ b/packages/yew/src/shield_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldPlus(props: &ShieldPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="M9 12h6" />
+            <path d="M12 9v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_question.rs b/packages/yew/src/shield_question.rs
new file mode 100644
index 0000000..d7615bb
--- /dev/null
+++ b/packages/yew/src/shield_question.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldQuestionProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldQuestion(props: &ShieldQuestionProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3" />
+            <path d="M12 17h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shield_x.rs b/packages/yew/src/shield_x.rs
new file mode 100644
index 0000000..f8f88bc
--- /dev/null
+++ b/packages/yew/src/shield_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShieldXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShieldX(props: &ShieldXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"
+            />
+            <path d="m14.5 9.5-5 5" />
+            <path d="m9.5 9.5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ship.rs b/packages/yew/src/ship.rs
new file mode 100644
index 0000000..176ea5d
--- /dev/null
+++ b/packages/yew/src/ship.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShipProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ship(props: &ShipProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 21c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1 .6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"
+            />
+            <path d="M19.38 20A11.6 11.6 0 0 0 21 14l-9-4-9 4c0 2.9.94 5.34 2.81 7.76" />
+            <path d="M19 13V7a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v6" />
+            <path d="M12 10v4" />
+            <path d="M12 2v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ship_wheel.rs b/packages/yew/src/ship_wheel.rs
new file mode 100644
index 0000000..86c1f4c
--- /dev/null
+++ b/packages/yew/src/ship_wheel.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShipWheelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShipWheel(props: &ShipWheelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="8" />
+            <path d="M12 2v7.5" />
+            <path d="m19 5-5.23 5.23" />
+            <path d="M22 12h-7.5" />
+            <path d="m19 19-5.23-5.23" />
+            <path d="M12 14.5V22" />
+            <path d="M10.23 13.77 5 19" />
+            <path d="M9.5 12H2" />
+            <path d="M10.23 10.23 5 5" />
+            <circle cx="12" cy="12" r="2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shirt.rs b/packages/yew/src/shirt.rs
new file mode 100644
index 0000000..de3fb2d
--- /dev/null
+++ b/packages/yew/src/shirt.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShirtProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Shirt(props: &ShirtProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M20.38 3.46 16 2a4 4 0 0 1-8 0L3.62 3.46a2 2 0 0 0-1.34 2.23l.58 3.47a1 1 0 0 0 .99.84H6v10c0 1.1.9 2 2 2h8a2 2 0 0 0 2-2V10h2.15a1 1 0 0 0 .99-.84l.58-3.47a2 2 0 0 0-1.34-2.23z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shopping_bag.rs b/packages/yew/src/shopping_bag.rs
new file mode 100644
index 0000000..a6187b9
--- /dev/null
+++ b/packages/yew/src/shopping_bag.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShoppingBagProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShoppingBag(props: &ShoppingBagProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 2 3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4Z" />
+            <path d="M3 6h18" />
+            <path d="M16 10a4 4 0 0 1-8 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shopping_basket.rs b/packages/yew/src/shopping_basket.rs
new file mode 100644
index 0000000..c69fe67
--- /dev/null
+++ b/packages/yew/src/shopping_basket.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShoppingBasketProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShoppingBasket(props: &ShoppingBasketProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 11-1 9" />
+            <path d="m19 11-4-7" />
+            <path d="M2 11h20" />
+            <path d="m3.5 11 1.6 7.4a2 2 0 0 0 2 1.6h9.8a2 2 0 0 0 2-1.6l1.7-7.4" />
+            <path d="M4.5 15.5h15" />
+            <path d="m5 11 4-7" />
+            <path d="m9 11 1 9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shopping_cart.rs b/packages/yew/src/shopping_cart.rs
new file mode 100644
index 0000000..8764d43
--- /dev/null
+++ b/packages/yew/src/shopping_cart.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShoppingCartProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShoppingCart(props: &ShoppingCartProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="8" cy="21" r="1" />
+            <circle cx="19" cy="21" r="1" />
+            <path
+                d="M2.05 2.05h2l2.66 12.42a2 2 0 0 0 2 1.58h9.78a2 2 0 0 0 1.95-1.57l1.65-7.43H5.12"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shovel.rs b/packages/yew/src/shovel.rs
new file mode 100644
index 0000000..9de7994
--- /dev/null
+++ b/packages/yew/src/shovel.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShovelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Shovel(props: &ShovelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22v-5l5-5 5 5-5 5z" />
+            <path d="M9.5 14.5 16 8" />
+            <path d="m17 2 5 5-.5.5a3.53 3.53 0 0 1-5 0s0 0 0 0a3.53 3.53 0 0 1 0-5L17 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shower_head.rs b/packages/yew/src/shower_head.rs
new file mode 100644
index 0000000..ffa7c0f
--- /dev/null
+++ b/packages/yew/src/shower_head.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShowerHeadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ShowerHead(props: &ShowerHeadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4 4 2.5 2.5" />
+            <path d="M13.5 6.5a4.95 4.95 0 0 0-7 7" />
+            <path d="M15 5 5 15" />
+            <path d="M14 17v.01" />
+            <path d="M10 16v.01" />
+            <path d="M13 13v.01" />
+            <path d="M16 10v.01" />
+            <path d="M11 20v.01" />
+            <path d="M17 14v.01" />
+            <path d="M20 11v.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shrink.rs b/packages/yew/src/shrink.rs
new file mode 100644
index 0000000..f55ccfe
--- /dev/null
+++ b/packages/yew/src/shrink.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShrinkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Shrink(props: &ShrinkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 15 6 6m-6-6v4.8m0-4.8h4.8" />
+            <path d="M9 19.8V15m0 0H4.2M9 15l-6 6" />
+            <path d="M15 4.2V9m0 0h4.8M15 9l6-6" />
+            <path d="M9 4.2V9m0 0H4.2M9 9 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shrub.rs b/packages/yew/src/shrub.rs
new file mode 100644
index 0000000..905056a
--- /dev/null
+++ b/packages/yew/src/shrub.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShrubProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Shrub(props: &ShrubProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-7l-2-2" />
+            <path d="M17 8v.8A6 6 0 0 1 13.8 20H10A6.5 6.5 0 0 1 7 8a5 5 0 0 1 10 0Z" />
+            <path d="m14 14-2 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/shuffle.rs b/packages/yew/src/shuffle.rs
new file mode 100644
index 0000000..bce019f
--- /dev/null
+++ b/packages/yew/src/shuffle.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ShuffleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Shuffle(props: &ShuffleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 18h1.4c1.3 0 2.5-.6 3.3-1.7l6.1-8.6c.7-1.1 2-1.7 3.3-1.7H22" />
+            <path d="m18 2 4 4-4 4" />
+            <path d="M2 6h1.9c1.5 0 2.9.9 3.6 2.2" />
+            <path d="M22 18h-5.9c-1.3 0-2.6-.7-3.3-1.8l-.5-.8" />
+            <path d="m18 14 4 4-4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sigma.rs b/packages/yew/src/sigma.rs
new file mode 100644
index 0000000..14327ad
--- /dev/null
+++ b/packages/yew/src/sigma.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SigmaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sigma(props: &SigmaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M18 7V5a1 1 0 0 0-1-1H6.5a.5.5 0 0 0-.4.8l4.5 6a2 2 0 0 1 0 2.4l-4.5 6a.5.5 0 0 0 .4.8H17a1 1 0 0 0 1-1v-2"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/signal.rs b/packages/yew/src/signal.rs
new file mode 100644
index 0000000..eb81f25
--- /dev/null
+++ b/packages/yew/src/signal.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SignalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Signal(props: &SignalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01" />
+            <path d="M7 20v-4" />
+            <path d="M12 20v-8" />
+            <path d="M17 20V8" />
+            <path d="M22 4v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/signal_high.rs b/packages/yew/src/signal_high.rs
new file mode 100644
index 0000000..7ee70cb
--- /dev/null
+++ b/packages/yew/src/signal_high.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SignalHighProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SignalHigh(props: &SignalHighProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01" />
+            <path d="M7 20v-4" />
+            <path d="M12 20v-8" />
+            <path d="M17 20V8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/signal_low.rs b/packages/yew/src/signal_low.rs
new file mode 100644
index 0000000..2408bde
--- /dev/null
+++ b/packages/yew/src/signal_low.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SignalLowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SignalLow(props: &SignalLowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01" />
+            <path d="M7 20v-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/signal_medium.rs b/packages/yew/src/signal_medium.rs
new file mode 100644
index 0000000..a578aa9
--- /dev/null
+++ b/packages/yew/src/signal_medium.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SignalMediumProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SignalMedium(props: &SignalMediumProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01" />
+            <path d="M7 20v-4" />
+            <path d="M12 20v-8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/signal_zero.rs b/packages/yew/src/signal_zero.rs
new file mode 100644
index 0000000..97d803a
--- /dev/null
+++ b/packages/yew/src/signal_zero.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SignalZeroProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SignalZero(props: &SignalZeroProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 20h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/signature.rs b/packages/yew/src/signature.rs
new file mode 100644
index 0000000..dc74bf8
--- /dev/null
+++ b/packages/yew/src/signature.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SignatureProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Signature(props: &SignatureProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m21 17-2.156-1.868A.5.5 0 0 0 18 15.5v.5a1 1 0 0 1-1 1h-2a1 1 0 0 1-1-1c0-2.545-3.991-3.97-8.5-4a1 1 0 0 0 0 5c4.153 0 4.745-11.295 5.708-13.5a2.5 2.5 0 1 1 3.31 3.284"
+            />
+            <path d="M3 21h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/signpost.rs b/packages/yew/src/signpost.rs
new file mode 100644
index 0000000..3c2bbb9
--- /dev/null
+++ b/packages/yew/src/signpost.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SignpostProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Signpost(props: &SignpostProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 13v8" />
+            <path d="M12 3v3" />
+            <path
+                d="M18 6a2 2 0 0 1 1.387.56l2.307 2.22a1 1 0 0 1 0 1.44l-2.307 2.22A2 2 0 0 1 18 13H6a2 2 0 0 1-1.387-.56l-2.306-2.22a1 1 0 0 1 0-1.44l2.306-2.22A2 2 0 0 1 6 6z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/signpost_big.rs b/packages/yew/src/signpost_big.rs
new file mode 100644
index 0000000..29a3875
--- /dev/null
+++ b/packages/yew/src/signpost_big.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SignpostBigProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SignpostBig(props: &SignpostBigProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9H4L2 7l2-2h6" />
+            <path d="M14 5h6l2 2-2 2h-6" />
+            <path d="M10 22V4a2 2 0 1 1 4 0v18" />
+            <path d="M8 22h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/siren.rs b/packages/yew/src/siren.rs
new file mode 100644
index 0000000..ad2b9e0
--- /dev/null
+++ b/packages/yew/src/siren.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SirenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Siren(props: &SirenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 18v-6a5 5 0 1 1 10 0v6" />
+            <path d="M5 21a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-1a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2z" />
+            <path d="M21 12h1" />
+            <path d="M18.5 4.5 18 5" />
+            <path d="M2 12h1" />
+            <path d="M12 2v1" />
+            <path d="m4.929 4.929.707.707" />
+            <path d="M12 12v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/skip_back.rs b/packages/yew/src/skip_back.rs
new file mode 100644
index 0000000..f0901a8
--- /dev/null
+++ b/packages/yew/src/skip_back.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SkipBackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SkipBack(props: &SkipBackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="19 20 9 12 19 4 19 20" />
+            <line x1="5" x2="5" y1="19" y2="5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/skip_forward.rs b/packages/yew/src/skip_forward.rs
new file mode 100644
index 0000000..3e6d789
--- /dev/null
+++ b/packages/yew/src/skip_forward.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SkipForwardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SkipForward(props: &SkipForwardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polygon points="5 4 15 12 5 20 5 4" />
+            <line x1="19" x2="19" y1="5" y2="19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/skull.rs b/packages/yew/src/skull.rs
new file mode 100644
index 0000000..a51184b
--- /dev/null
+++ b/packages/yew/src/skull.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SkullProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Skull(props: &SkullProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m12.5 17-.5-1-.5 1h1z" />
+            <path
+                d="M15 22a1 1 0 0 0 1-1v-1a2 2 0 0 0 1.56-3.25 8 8 0 1 0-11.12 0A2 2 0 0 0 8 20v1a1 1 0 0 0 1 1z"
+            />
+            <circle cx="15" cy="12" r="1" />
+            <circle cx="9" cy="12" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/slack.rs b/packages/yew/src/slack.rs
new file mode 100644
index 0000000..c36dc24
--- /dev/null
+++ b/packages/yew/src/slack.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SlackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Slack(props: &SlackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="3" height="8" x="13" y="2" rx="1.5" />
+            <path d="M19 8.5V10h1.5A1.5 1.5 0 1 0 19 8.5" />
+            <rect width="3" height="8" x="8" y="14" rx="1.5" />
+            <path d="M5 15.5V14H3.5A1.5 1.5 0 1 0 5 15.5" />
+            <rect width="8" height="3" x="14" y="13" rx="1.5" />
+            <path d="M15.5 19H14v1.5a1.5 1.5 0 1 0 1.5-1.5" />
+            <rect width="8" height="3" x="2" y="8" rx="1.5" />
+            <path d="M8.5 5H10V3.5A1.5 1.5 0 1 0 8.5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/slash.rs b/packages/yew/src/slash.rs
new file mode 100644
index 0000000..1ef26e7
--- /dev/null
+++ b/packages/yew/src/slash.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SlashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Slash(props: &SlashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 2 2 22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/slice.rs b/packages/yew/src/slice.rs
new file mode 100644
index 0000000..7aa225b
--- /dev/null
+++ b/packages/yew/src/slice.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SliceProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Slice(props: &SliceProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11 16.586V19a1 1 0 0 1-1 1H2L18.37 3.63a1 1 0 1 1 3 3l-9.663 9.663a1 1 0 0 1-1.414 0L8 14"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sliders_horizontal.rs b/packages/yew/src/sliders_horizontal.rs
new file mode 100644
index 0000000..530c4fa
--- /dev/null
+++ b/packages/yew/src/sliders_horizontal.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SlidersHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SlidersHorizontal(props: &SlidersHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="21" x2="14" y1="4" y2="4" />
+            <line x1="10" x2="3" y1="4" y2="4" />
+            <line x1="21" x2="12" y1="12" y2="12" />
+            <line x1="8" x2="3" y1="12" y2="12" />
+            <line x1="21" x2="16" y1="20" y2="20" />
+            <line x1="12" x2="3" y1="20" y2="20" />
+            <line x1="14" x2="14" y1="2" y2="6" />
+            <line x1="8" x2="8" y1="10" y2="14" />
+            <line x1="16" x2="16" y1="18" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sliders_vertical.rs b/packages/yew/src/sliders_vertical.rs
new file mode 100644
index 0000000..63bd36d
--- /dev/null
+++ b/packages/yew/src/sliders_vertical.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SlidersVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SlidersVertical(props: &SlidersVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="4" x2="4" y1="21" y2="14" />
+            <line x1="4" x2="4" y1="10" y2="3" />
+            <line x1="12" x2="12" y1="21" y2="12" />
+            <line x1="12" x2="12" y1="8" y2="3" />
+            <line x1="20" x2="20" y1="21" y2="16" />
+            <line x1="20" x2="20" y1="12" y2="3" />
+            <line x1="2" x2="6" y1="14" y2="14" />
+            <line x1="10" x2="14" y1="8" y2="8" />
+            <line x1="18" x2="22" y1="16" y2="16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/smartphone.rs b/packages/yew/src/smartphone.rs
new file mode 100644
index 0000000..c8414be
--- /dev/null
+++ b/packages/yew/src/smartphone.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SmartphoneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Smartphone(props: &SmartphoneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="20" x="5" y="2" rx="2" ry="2" />
+            <path d="M12 18h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/smartphone_charging.rs b/packages/yew/src/smartphone_charging.rs
new file mode 100644
index 0000000..75addfc
--- /dev/null
+++ b/packages/yew/src/smartphone_charging.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SmartphoneChargingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SmartphoneCharging(props: &SmartphoneChargingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="14" height="20" x="5" y="2" rx="2" ry="2" />
+            <path d="M12.667 8 10 12h4l-2.667 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/smartphone_nfc.rs b/packages/yew/src/smartphone_nfc.rs
new file mode 100644
index 0000000..3f215b8
--- /dev/null
+++ b/packages/yew/src/smartphone_nfc.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SmartphoneNfcProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SmartphoneNfc(props: &SmartphoneNfcProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="7" height="12" x="2" y="6" rx="1" />
+            <path d="M13 8.32a7.43 7.43 0 0 1 0 7.36" />
+            <path d="M16.46 6.21a11.76 11.76 0 0 1 0 11.58" />
+            <path d="M19.91 4.1a15.91 15.91 0 0 1 .01 15.8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/smile.rs b/packages/yew/src/smile.rs
new file mode 100644
index 0000000..e8a53a7
--- /dev/null
+++ b/packages/yew/src/smile.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SmileProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Smile(props: &SmileProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <path d="M8 14s1.5 2 4 2 4-2 4-2" />
+            <line x1="9" x2="9.01" y1="9" y2="9" />
+            <line x1="15" x2="15.01" y1="9" y2="9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/smile_plus.rs b/packages/yew/src/smile_plus.rs
new file mode 100644
index 0000000..3028b89
--- /dev/null
+++ b/packages/yew/src/smile_plus.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SmilePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SmilePlus(props: &SmilePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 11v1a10 10 0 1 1-9-10" />
+            <path d="M8 14s1.5 2 4 2 4-2 4-2" />
+            <line x1="9" x2="9.01" y1="9" y2="9" />
+            <line x1="15" x2="15.01" y1="9" y2="9" />
+            <path d="M16 5h6" />
+            <path d="M19 2v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/snail.rs b/packages/yew/src/snail.rs
new file mode 100644
index 0000000..10301e9
--- /dev/null
+++ b/packages/yew/src/snail.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SnailProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Snail(props: &SnailProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 13a6 6 0 1 0 12 0 4 4 0 1 0-8 0 2 2 0 0 0 4 0" />
+            <circle cx="10" cy="13" r="8" />
+            <path d="M2 21h12c4.4 0 8-3.6 8-8V7a2 2 0 1 0-4 0v6" />
+            <path d="M18 3 19.1 5.2" />
+            <path d="M22 3 20.9 5.2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/snowflake.rs b/packages/yew/src/snowflake.rs
new file mode 100644
index 0000000..abb3fc4
--- /dev/null
+++ b/packages/yew/src/snowflake.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SnowflakeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Snowflake(props: &SnowflakeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="2" x2="22" y1="12" y2="12" />
+            <line x1="12" x2="12" y1="2" y2="22" />
+            <path d="m20 16-4-4 4-4" />
+            <path d="m4 8 4 4-4 4" />
+            <path d="m16 4-4 4-4-4" />
+            <path d="m8 20 4-4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sofa.rs b/packages/yew/src/sofa.rs
new file mode 100644
index 0000000..d744933
--- /dev/null
+++ b/packages/yew/src/sofa.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SofaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sofa(props: &SofaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M20 9V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v3" />
+            <path
+                d="M2 16a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-11a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z"
+            />
+            <path d="M4 18v2" />
+            <path d="M20 18v2" />
+            <path d="M12 4v9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/soup.rs b/packages/yew/src/soup.rs
new file mode 100644
index 0000000..72aea74
--- /dev/null
+++ b/packages/yew/src/soup.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SoupProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Soup(props: &SoupProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 21a9 9 0 0 0 9-9H3a9 9 0 0 0 9 9Z" />
+            <path d="M7 21h10" />
+            <path d="M19.5 12 22 6" />
+            <path d="M16.25 3c.27.1.8.53.75 1.36-.06.83-.93 1.2-1 2.02-.05.78.34 1.24.73 1.62" />
+            <path d="M11.25 3c.27.1.8.53.74 1.36-.05.83-.93 1.2-.98 2.02-.06.78.33 1.24.72 1.62" />
+            <path d="M6.25 3c.27.1.8.53.75 1.36-.06.83-.93 1.2-1 2.02-.05.78.34 1.24.74 1.62" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/space.rs b/packages/yew/src/space.rs
new file mode 100644
index 0000000..cdc1e8d
--- /dev/null
+++ b/packages/yew/src/space.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SpaceProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Space(props: &SpaceProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/spade.rs b/packages/yew/src/spade.rs
new file mode 100644
index 0000000..cd838ec
--- /dev/null
+++ b/packages/yew/src/spade.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SpadeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Spade(props: &SpadeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M5 9c-1.5 1.5-3 3.2-3 5.5A5.5 5.5 0 0 0 7.5 20c1.8 0 3-.5 4.5-2 1.5 1.5 2.7 2 4.5 2a5.5 5.5 0 0 0 5.5-5.5c0-2.3-1.5-4-3-5.5l-7-7-7 7Z"
+            />
+            <path d="M12 18v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sparkle.rs b/packages/yew/src/sparkle.rs
new file mode 100644
index 0000000..1f915f5
--- /dev/null
+++ b/packages/yew/src/sparkle.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SparkleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sparkle(props: &SparkleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .963 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.963 0z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sparkles.rs b/packages/yew/src/sparkles.rs
new file mode 100644
index 0000000..ff7584b
--- /dev/null
+++ b/packages/yew/src/sparkles.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SparklesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sparkles(props: &SparklesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .963 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.963 0z"
+            />
+            <path d="M20 3v4" />
+            <path d="M22 5h-4" />
+            <path d="M4 17v2" />
+            <path d="M5 18H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/speaker.rs b/packages/yew/src/speaker.rs
new file mode 100644
index 0000000..055a795
--- /dev/null
+++ b/packages/yew/src/speaker.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SpeakerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Speaker(props: &SpeakerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="20" x="4" y="2" rx="2" />
+            <path d="M12 6h.01" />
+            <circle cx="12" cy="14" r="4" />
+            <path d="M12 14h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/speech.rs b/packages/yew/src/speech.rs
new file mode 100644
index 0000000..f4c2b75
--- /dev/null
+++ b/packages/yew/src/speech.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SpeechProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Speech(props: &SpeechProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M8.8 20v-4.1l1.9.2a2.3 2.3 0 0 0 2.164-2.1V8.3A5.37 5.37 0 0 0 2 8.25c0 2.8.656 3.054 1 4.55a5.77 5.77 0 0 1 .029 2.758L2 20"
+            />
+            <path d="M19.8 17.8a7.5 7.5 0 0 0 .003-10.603" />
+            <path d="M17 15a3.5 3.5 0 0 0-.025-4.975" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/spell_check.rs b/packages/yew/src/spell_check.rs
new file mode 100644
index 0000000..c3bc9a3
--- /dev/null
+++ b/packages/yew/src/spell_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SpellCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SpellCheck(props: &SpellCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 16 6-12 6 12" />
+            <path d="M8 12h8" />
+            <path d="m16 20 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/spell_check_2.rs b/packages/yew/src/spell_check_2.rs
new file mode 100644
index 0000000..3877482
--- /dev/null
+++ b/packages/yew/src/spell_check_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SpellCheck2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SpellCheck2(props: &SpellCheck2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m6 16 6-12 6 12" />
+            <path d="M8 12h8" />
+            <path
+                d="M4 21c1.1 0 1.1-1 2.3-1s1.1 1 2.3 1c1.1 0 1.1-1 2.3-1 1.1 0 1.1 1 2.3 1 1.1 0 1.1-1 2.3-1 1.1 0 1.1 1 2.3 1 1.1 0 1.1-1 2.3-1"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/spline.rs b/packages/yew/src/spline.rs
new file mode 100644
index 0000000..c2acb8c
--- /dev/null
+++ b/packages/yew/src/spline.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SplineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Spline(props: &SplineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="19" cy="5" r="2" />
+            <circle cx="5" cy="19" r="2" />
+            <path d="M5 17A12 12 0 0 1 17 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/split.rs b/packages/yew/src/split.rs
new file mode 100644
index 0000000..52d08c8
--- /dev/null
+++ b/packages/yew/src/split.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SplitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Split(props: &SplitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 3h5v5" />
+            <path d="M8 3H3v5" />
+            <path d="M12 22v-8.3a4 4 0 0 0-1.172-2.872L3 3" />
+            <path d="m15 9 6-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/spray_can.rs b/packages/yew/src/spray_can.rs
new file mode 100644
index 0000000..01c39a4
--- /dev/null
+++ b/packages/yew/src/spray_can.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SprayCanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SprayCan(props: &SprayCanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 3h.01" />
+            <path d="M7 5h.01" />
+            <path d="M11 7h.01" />
+            <path d="M3 7h.01" />
+            <path d="M7 9h.01" />
+            <path d="M3 11h.01" />
+            <rect width="4" height="4" x="15" y="5" />
+            <path d="m19 9 2 2v10c0 .6-.4 1-1 1h-6c-.6 0-1-.4-1-1V11l2-2" />
+            <path d="m13 14 8-2" />
+            <path d="m13 19 8-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sprout.rs b/packages/yew/src/sprout.rs
new file mode 100644
index 0000000..060cb05
--- /dev/null
+++ b/packages/yew/src/sprout.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SproutProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sprout(props: &SproutProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 20h10" />
+            <path d="M10 20c5.5-2.5.8-6.4 3-10" />
+            <path
+                d="M9.5 9.4c1.1.8 1.8 2.2 2.3 3.7-2 .4-3.5.4-4.8-.3-1.2-.6-2.3-1.9-3-4.2 2.8-.5 4.4 0 5.5.8z"
+            />
+            <path
+                d="M14.1 6a7 7 0 0 0-1.1 4c1.9-.1 3.3-.6 4.3-1.4 1-1 1.6-2.3 1.7-4.6-2.7.1-4 1-4.9 2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square.rs b/packages/yew/src/square.rs
new file mode 100644
index 0000000..03550ae
--- /dev/null
+++ b/packages/yew/src/square.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Square(props: &SquareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_activity.rs b/packages/yew/src/square_activity.rs
new file mode 100644
index 0000000..7a877ef
--- /dev/null
+++ b/packages/yew/src/square_activity.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareActivityProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareActivity(props: &SquareActivityProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M17 12h-2l-2 5-2-10-2 5H7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_down.rs b/packages/yew/src/square_arrow_down.rs
new file mode 100644
index 0000000..f36d43d
--- /dev/null
+++ b/packages/yew/src/square_arrow_down.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowDown(props: &SquareArrowDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M12 8v8" />
+            <path d="m8 12 4 4 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_down_left.rs b/packages/yew/src/square_arrow_down_left.rs
new file mode 100644
index 0000000..0cf0309
--- /dev/null
+++ b/packages/yew/src/square_arrow_down_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowDownLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowDownLeft(props: &SquareArrowDownLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m16 8-8 8" />
+            <path d="M16 16H8V8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_down_right.rs b/packages/yew/src/square_arrow_down_right.rs
new file mode 100644
index 0000000..8e25080
--- /dev/null
+++ b/packages/yew/src/square_arrow_down_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowDownRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowDownRight(props: &SquareArrowDownRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m8 8 8 8" />
+            <path d="M16 8v8H8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_left.rs b/packages/yew/src/square_arrow_left.rs
new file mode 100644
index 0000000..36bba92
--- /dev/null
+++ b/packages/yew/src/square_arrow_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowLeft(props: &SquareArrowLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m12 8-4 4 4 4" />
+            <path d="M16 12H8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_out_down_left.rs b/packages/yew/src/square_arrow_out_down_left.rs
new file mode 100644
index 0000000..698036d
--- /dev/null
+++ b/packages/yew/src/square_arrow_out_down_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowOutDownLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowOutDownLeft(props: &SquareArrowOutDownLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 21h6a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6" />
+            <path d="m3 21 9-9" />
+            <path d="M9 21H3v-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_out_down_right.rs b/packages/yew/src/square_arrow_out_down_right.rs
new file mode 100644
index 0000000..151695c
--- /dev/null
+++ b/packages/yew/src/square_arrow_out_down_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowOutDownRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowOutDownRight(props: &SquareArrowOutDownRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 11V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6" />
+            <path d="m21 21-9-9" />
+            <path d="M21 15v6h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_out_up_left.rs b/packages/yew/src/square_arrow_out_up_left.rs
new file mode 100644
index 0000000..cdf4f57
--- /dev/null
+++ b/packages/yew/src/square_arrow_out_up_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowOutUpLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowOutUpLeft(props: &SquareArrowOutUpLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-6" />
+            <path d="m3 3 9 9" />
+            <path d="M3 9V3h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_out_up_right.rs b/packages/yew/src/square_arrow_out_up_right.rs
new file mode 100644
index 0000000..e0f35f6
--- /dev/null
+++ b/packages/yew/src/square_arrow_out_up_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowOutUpRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowOutUpRight(props: &SquareArrowOutUpRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h6" />
+            <path d="m21 3-9 9" />
+            <path d="M15 3h6v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_right.rs b/packages/yew/src/square_arrow_right.rs
new file mode 100644
index 0000000..c6e7d31
--- /dev/null
+++ b/packages/yew/src/square_arrow_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowRight(props: &SquareArrowRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M8 12h8" />
+            <path d="m12 16 4-4-4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_up.rs b/packages/yew/src/square_arrow_up.rs
new file mode 100644
index 0000000..2c172ab
--- /dev/null
+++ b/packages/yew/src/square_arrow_up.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowUp(props: &SquareArrowUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m16 12-4-4-4 4" />
+            <path d="M12 16V8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_up_left.rs b/packages/yew/src/square_arrow_up_left.rs
new file mode 100644
index 0000000..034841c
--- /dev/null
+++ b/packages/yew/src/square_arrow_up_left.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowUpLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowUpLeft(props: &SquareArrowUpLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M8 16V8h8" />
+            <path d="M16 16 8 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_arrow_up_right.rs b/packages/yew/src/square_arrow_up_right.rs
new file mode 100644
index 0000000..0006462
--- /dev/null
+++ b/packages/yew/src/square_arrow_up_right.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareArrowUpRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareArrowUpRight(props: &SquareArrowUpRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M8 8h8v8" />
+            <path d="m8 16 8-8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_asterisk.rs b/packages/yew/src/square_asterisk.rs
new file mode 100644
index 0000000..c87c711
--- /dev/null
+++ b/packages/yew/src/square_asterisk.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareAsteriskProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareAsterisk(props: &SquareAsteriskProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M12 8v8" />
+            <path d="m8.5 14 7-4" />
+            <path d="m8.5 10 7 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_bottom_dashed_scissors.rs b/packages/yew/src/square_bottom_dashed_scissors.rs
new file mode 100644
index 0000000..9d225ab
--- /dev/null
+++ b/packages/yew/src/square_bottom_dashed_scissors.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareBottomDashedScissorsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareBottomDashedScissors(props: &SquareBottomDashedScissorsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2" />
+            <path d="M10 22H8" />
+            <path d="M16 22h-2" />
+            <circle cx="8" cy="8" r="2" />
+            <path d="M9.414 9.414 12 12" />
+            <path d="M14.8 14.8 18 18" />
+            <circle cx="8" cy="16" r="2" />
+            <path d="m18 6-8.586 8.586" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_chart_gantt.rs b/packages/yew/src/square_chart_gantt.rs
new file mode 100644
index 0000000..6cb5296
--- /dev/null
+++ b/packages/yew/src/square_chart_gantt.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareChartGanttProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareChartGantt(props: &SquareChartGanttProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M9 8h7" />
+            <path d="M8 12h6" />
+            <path d="M11 16h5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_check.rs b/packages/yew/src/square_check.rs
new file mode 100644
index 0000000..969310e
--- /dev/null
+++ b/packages/yew/src/square_check.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareCheck(props: &SquareCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m9 12 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_check_big.rs b/packages/yew/src/square_check_big.rs
new file mode 100644
index 0000000..96b0dc1
--- /dev/null
+++ b/packages/yew/src/square_check_big.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareCheckBigProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareCheckBig(props: &SquareCheckBigProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 10.5V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h12.5" />
+            <path d="m9 11 3 3L22 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_chevron_down.rs b/packages/yew/src/square_chevron_down.rs
new file mode 100644
index 0000000..e0b769d
--- /dev/null
+++ b/packages/yew/src/square_chevron_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareChevronDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareChevronDown(props: &SquareChevronDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m16 10-4 4-4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_chevron_left.rs b/packages/yew/src/square_chevron_left.rs
new file mode 100644
index 0000000..ff0b3d9
--- /dev/null
+++ b/packages/yew/src/square_chevron_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareChevronLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareChevronLeft(props: &SquareChevronLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m14 16-4-4 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_chevron_right.rs b/packages/yew/src/square_chevron_right.rs
new file mode 100644
index 0000000..2cc3acc
--- /dev/null
+++ b/packages/yew/src/square_chevron_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareChevronRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareChevronRight(props: &SquareChevronRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m10 8 4 4-4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_chevron_up.rs b/packages/yew/src/square_chevron_up.rs
new file mode 100644
index 0000000..0539741
--- /dev/null
+++ b/packages/yew/src/square_chevron_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareChevronUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareChevronUp(props: &SquareChevronUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m8 14 4-4 4 4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_code.rs b/packages/yew/src/square_code.rs
new file mode 100644
index 0000000..a53f1f8
--- /dev/null
+++ b/packages/yew/src/square_code.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareCode(props: &SquareCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9.5 8 12l2 2.5" />
+            <path d="m14 9.5 2 2.5-2 2.5" />
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_dashed.rs b/packages/yew/src/square_dashed.rs
new file mode 100644
index 0000000..f4929f2
--- /dev/null
+++ b/packages/yew/src/square_dashed.rs
@@ -0,0 +1,55 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareDashedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareDashed(props: &SquareDashedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 3a2 2 0 0 0-2 2" />
+            <path d="M19 3a2 2 0 0 1 2 2" />
+            <path d="M21 19a2 2 0 0 1-2 2" />
+            <path d="M5 21a2 2 0 0 1-2-2" />
+            <path d="M9 3h1" />
+            <path d="M9 21h1" />
+            <path d="M14 3h1" />
+            <path d="M14 21h1" />
+            <path d="M3 9v1" />
+            <path d="M21 9v1" />
+            <path d="M3 14v1" />
+            <path d="M21 14v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_dashed_bottom.rs b/packages/yew/src/square_dashed_bottom.rs
new file mode 100644
index 0000000..e33ad35
--- /dev/null
+++ b/packages/yew/src/square_dashed_bottom.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareDashedBottomProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareDashedBottom(props: &SquareDashedBottomProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 21a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2" />
+            <path d="M9 21h1" />
+            <path d="M14 21h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_dashed_bottom_code.rs b/packages/yew/src/square_dashed_bottom_code.rs
new file mode 100644
index 0000000..8f782c7
--- /dev/null
+++ b/packages/yew/src/square_dashed_bottom_code.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareDashedBottomCodeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareDashedBottomCode(props: &SquareDashedBottomCodeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9.5 8 12l2 2.5" />
+            <path d="M14 21h1" />
+            <path d="m14 9.5 2 2.5-2 2.5" />
+            <path d="M5 21a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2" />
+            <path d="M9 21h1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_dashed_kanban.rs b/packages/yew/src/square_dashed_kanban.rs
new file mode 100644
index 0000000..4d78e4d
--- /dev/null
+++ b/packages/yew/src/square_dashed_kanban.rs
@@ -0,0 +1,58 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareDashedKanbanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareDashedKanban(props: &SquareDashedKanbanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 7v7" />
+            <path d="M12 7v4" />
+            <path d="M16 7v9" />
+            <path d="M5 3a2 2 0 0 0-2 2" />
+            <path d="M9 3h1" />
+            <path d="M14 3h1" />
+            <path d="M19 3a2 2 0 0 1 2 2" />
+            <path d="M21 9v1" />
+            <path d="M21 14v1" />
+            <path d="M21 19a2 2 0 0 1-2 2" />
+            <path d="M14 21h1" />
+            <path d="M9 21h1" />
+            <path d="M5 21a2 2 0 0 1-2-2" />
+            <path d="M3 14v1" />
+            <path d="M3 9v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_dashed_mouse_pointer.rs b/packages/yew/src/square_dashed_mouse_pointer.rs
new file mode 100644
index 0000000..5b5908b
--- /dev/null
+++ b/packages/yew/src/square_dashed_mouse_pointer.rs
@@ -0,0 +1,55 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareDashedMousePointerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareDashedMousePointer(props: &SquareDashedMousePointerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z"
+            />
+            <path d="M5 3a2 2 0 0 0-2 2" />
+            <path d="M19 3a2 2 0 0 1 2 2" />
+            <path d="M5 21a2 2 0 0 1-2-2" />
+            <path d="M9 3h1" />
+            <path d="M9 21h2" />
+            <path d="M14 3h1" />
+            <path d="M3 9v1" />
+            <path d="M21 9v2" />
+            <path d="M3 14v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_divide.rs b/packages/yew/src/square_divide.rs
new file mode 100644
index 0000000..ccc54d8
--- /dev/null
+++ b/packages/yew/src/square_divide.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareDivideProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareDivide(props: &SquareDivideProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <line x1="8" x2="16" y1="12" y2="12" />
+            <line x1="12" x2="12" y1="16" y2="16" />
+            <line x1="12" x2="12" y1="8" y2="8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_dot.rs b/packages/yew/src/square_dot.rs
new file mode 100644
index 0000000..72fa101
--- /dev/null
+++ b/packages/yew/src/square_dot.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareDot(props: &SquareDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <circle cx="12" cy="12" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_equal.rs b/packages/yew/src/square_equal.rs
new file mode 100644
index 0000000..f6a8f26
--- /dev/null
+++ b/packages/yew/src/square_equal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareEqualProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareEqual(props: &SquareEqualProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M7 10h10" />
+            <path d="M7 14h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_function.rs b/packages/yew/src/square_function.rs
new file mode 100644
index 0000000..1092900
--- /dev/null
+++ b/packages/yew/src/square_function.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareFunctionProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareFunction(props: &SquareFunctionProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <path d="M9 17c2 0 2.8-1 2.8-2.8V10c0-2 1-3.3 3.2-3" />
+            <path d="M9 11.2h5.7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_kanban.rs b/packages/yew/src/square_kanban.rs
new file mode 100644
index 0000000..222933a
--- /dev/null
+++ b/packages/yew/src/square_kanban.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareKanbanProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareKanban(props: &SquareKanbanProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M8 7v7" />
+            <path d="M12 7v4" />
+            <path d="M16 7v9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_library.rs b/packages/yew/src/square_library.rs
new file mode 100644
index 0000000..0299a34
--- /dev/null
+++ b/packages/yew/src/square_library.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareLibraryProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareLibrary(props: &SquareLibraryProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M7 7v10" />
+            <path d="M11 7v10" />
+            <path d="m15 7 2 10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_m.rs b/packages/yew/src/square_m.rs
new file mode 100644
index 0000000..b0fc26a
--- /dev/null
+++ b/packages/yew/src/square_m.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareMProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareM(props: &SquareMProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M8 16V8l4 4 4-4v8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_menu.rs b/packages/yew/src/square_menu.rs
new file mode 100644
index 0000000..3ebedba
--- /dev/null
+++ b/packages/yew/src/square_menu.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareMenuProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareMenu(props: &SquareMenuProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M7 8h10" />
+            <path d="M7 12h10" />
+            <path d="M7 16h10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_minus.rs b/packages/yew/src/square_minus.rs
new file mode 100644
index 0000000..e272c64
--- /dev/null
+++ b/packages/yew/src/square_minus.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareMinus(props: &SquareMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M8 12h8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_mouse_pointer.rs b/packages/yew/src/square_mouse_pointer.rs
new file mode 100644
index 0000000..261f1e0
--- /dev/null
+++ b/packages/yew/src/square_mouse_pointer.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareMousePointerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareMousePointer(props: &SquareMousePointerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z"
+            />
+            <path d="M21 11V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_parking.rs b/packages/yew/src/square_parking.rs
new file mode 100644
index 0000000..ccdc156
--- /dev/null
+++ b/packages/yew/src/square_parking.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareParkingProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareParking(props: &SquareParkingProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M9 17V7h4a3 3 0 0 1 0 6H9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_parking_off.rs b/packages/yew/src/square_parking_off.rs
new file mode 100644
index 0000000..8d36567
--- /dev/null
+++ b/packages/yew/src/square_parking_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareParkingOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareParkingOff(props: &SquareParkingOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.6 3.6A2 2 0 0 1 5 3h14a2 2 0 0 1 2 2v14a2 2 0 0 1-.59 1.41" />
+            <path d="M3 8.7V19a2 2 0 0 0 2 2h10.3" />
+            <path d="m2 2 20 20" />
+            <path d="M13 13a3 3 0 1 0 0-6H9v2" />
+            <path d="M9 17v-2.3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_pen.rs b/packages/yew/src/square_pen.rs
new file mode 100644
index 0000000..27c464e
--- /dev/null
+++ b/packages/yew/src/square_pen.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquarePenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquarePen(props: &SquarePenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" />
+            <path
+                d="M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_percent.rs b/packages/yew/src/square_percent.rs
new file mode 100644
index 0000000..c583060
--- /dev/null
+++ b/packages/yew/src/square_percent.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquarePercentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquarePercent(props: &SquarePercentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m15 9-6 6" />
+            <path d="M9 9h.01" />
+            <path d="M15 15h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_pi.rs b/packages/yew/src/square_pi.rs
new file mode 100644
index 0000000..6221536
--- /dev/null
+++ b/packages/yew/src/square_pi.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquarePiProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquarePi(props: &SquarePiProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M7 7h10" />
+            <path d="M10 7v10" />
+            <path d="M16 17a2 2 0 0 1-2-2V7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_pilcrow.rs b/packages/yew/src/square_pilcrow.rs
new file mode 100644
index 0000000..a758ee6
--- /dev/null
+++ b/packages/yew/src/square_pilcrow.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquarePilcrowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquarePilcrow(props: &SquarePilcrowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M12 12H9.5a2.5 2.5 0 0 1 0-5H17" />
+            <path d="M12 7v10" />
+            <path d="M16 7v10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_play.rs b/packages/yew/src/square_play.rs
new file mode 100644
index 0000000..f1c856f
--- /dev/null
+++ b/packages/yew/src/square_play.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquarePlayProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquarePlay(props: &SquarePlayProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="m9 8 6 4-6 4Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_plus.rs b/packages/yew/src/square_plus.rs
new file mode 100644
index 0000000..26dab4e
--- /dev/null
+++ b/packages/yew/src/square_plus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquarePlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquarePlus(props: &SquarePlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M8 12h8" />
+            <path d="M12 8v8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_power.rs b/packages/yew/src/square_power.rs
new file mode 100644
index 0000000..d5dcbcb
--- /dev/null
+++ b/packages/yew/src/square_power.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquarePowerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquarePower(props: &SquarePowerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 7v4" />
+            <path d="M7.998 9.003a5 5 0 1 0 8-.005" />
+            <rect x="3" y="3" width="18" height="18" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_radical.rs b/packages/yew/src/square_radical.rs
new file mode 100644
index 0000000..cb6868b
--- /dev/null
+++ b/packages/yew/src/square_radical.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareRadicalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareRadical(props: &SquareRadicalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 12h2l2 5 2-10h4" />
+            <rect x="3" y="3" width="18" height="18" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_scissors.rs b/packages/yew/src/square_scissors.rs
new file mode 100644
index 0000000..66febb2
--- /dev/null
+++ b/packages/yew/src/square_scissors.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareScissorsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareScissors(props: &SquareScissorsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="20" x="2" y="2" rx="2" />
+            <circle cx="8" cy="8" r="2" />
+            <path d="M9.414 9.414 12 12" />
+            <path d="M14.8 14.8 18 18" />
+            <circle cx="8" cy="16" r="2" />
+            <path d="m18 6-8.586 8.586" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_sigma.rs b/packages/yew/src/square_sigma.rs
new file mode 100644
index 0000000..3405139
--- /dev/null
+++ b/packages/yew/src/square_sigma.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareSigmaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareSigma(props: &SquareSigmaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M16 8.9V7H8l4 5-4 5h8v-1.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_slash.rs b/packages/yew/src/square_slash.rs
new file mode 100644
index 0000000..772463b
--- /dev/null
+++ b/packages/yew/src/square_slash.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareSlashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareSlash(props: &SquareSlashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <line x1="9" x2="15" y1="15" y2="9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_split_horizontal.rs b/packages/yew/src/square_split_horizontal.rs
new file mode 100644
index 0000000..199b82a
--- /dev/null
+++ b/packages/yew/src/square_split_horizontal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareSplitHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareSplitHorizontal(props: &SquareSplitHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 19H5c-1 0-2-1-2-2V7c0-1 1-2 2-2h3" />
+            <path d="M16 5h3c1 0 2 1 2 2v10c0 1-1 2-2 2h-3" />
+            <line x1="12" x2="12" y1="4" y2="20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_split_vertical.rs b/packages/yew/src/square_split_vertical.rs
new file mode 100644
index 0000000..faec675
--- /dev/null
+++ b/packages/yew/src/square_split_vertical.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareSplitVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareSplitVertical(props: &SquareSplitVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 8V5c0-1 1-2 2-2h10c1 0 2 1 2 2v3" />
+            <path d="M19 16v3c0 1-1 2-2 2H7c-1 0-2-1-2-2v-3" />
+            <line x1="4" x2="20" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_square.rs b/packages/yew/src/square_square.rs
new file mode 100644
index 0000000..043e553
--- /dev/null
+++ b/packages/yew/src/square_square.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareSquareProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareSquare(props: &SquareSquareProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect x="3" y="3" width="18" height="18" rx="2" />
+            <rect x="8" y="8" width="8" height="8" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_stack.rs b/packages/yew/src/square_stack.rs
new file mode 100644
index 0000000..19342a1
--- /dev/null
+++ b/packages/yew/src/square_stack.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareStackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareStack(props: &SquareStackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 10c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h4c1.1 0 2 .9 2 2" />
+            <path d="M10 16c-1.1 0-2-.9-2-2v-4c0-1.1.9-2 2-2h4c1.1 0 2 .9 2 2" />
+            <rect width="8" height="8" x="14" y="14" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_terminal.rs b/packages/yew/src/square_terminal.rs
new file mode 100644
index 0000000..b69fd4b
--- /dev/null
+++ b/packages/yew/src/square_terminal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareTerminalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareTerminal(props: &SquareTerminalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m7 11 2-2-2-2" />
+            <path d="M11 13h4" />
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_user.rs b/packages/yew/src/square_user.rs
new file mode 100644
index 0000000..a6040ab
--- /dev/null
+++ b/packages/yew/src/square_user.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareUserProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareUser(props: &SquareUserProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <circle cx="12" cy="10" r="3" />
+            <path d="M7 21v-2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_user_round.rs b/packages/yew/src/square_user_round.rs
new file mode 100644
index 0000000..64300c1
--- /dev/null
+++ b/packages/yew/src/square_user_round.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareUserRoundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareUserRound(props: &SquareUserRoundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 21a6 6 0 0 0-12 0" />
+            <circle cx="12" cy="11" r="4" />
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/square_x.rs b/packages/yew/src/square_x.rs
new file mode 100644
index 0000000..352a873
--- /dev/null
+++ b/packages/yew/src/square_x.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquareXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SquareX(props: &SquareXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <path d="m15 9-6 6" />
+            <path d="m9 9 6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/squircle.rs b/packages/yew/src/squircle.rs
new file mode 100644
index 0000000..a3a35ee
--- /dev/null
+++ b/packages/yew/src/squircle.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquircleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Squircle(props: &SquircleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3c7.2 0 9 1.8 9 9s-1.8 9-9 9-9-1.8-9-9 1.8-9 9-9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/squirrel.rs b/packages/yew/src/squirrel.rs
new file mode 100644
index 0000000..38269f5
--- /dev/null
+++ b/packages/yew/src/squirrel.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SquirrelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Squirrel(props: &SquirrelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.236 22a3 3 0 0 0-2.2-5" />
+            <path d="M16 20a3 3 0 0 1 3-3h1a2 2 0 0 0 2-2v-2a4 4 0 0 0-4-4V4" />
+            <path d="M18 13h.01" />
+            <path
+                d="M18 6a4 4 0 0 0-4 4 7 7 0 0 0-7 7c0-5 4-5 4-10.5a4.5 4.5 0 1 0-9 0 2.5 2.5 0 0 0 5 0C7 10 3 11 3 17c0 2.8 2.2 5 5 5h10"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/stamp.rs b/packages/yew/src/stamp.rs
new file mode 100644
index 0000000..c38e57f
--- /dev/null
+++ b/packages/yew/src/stamp.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StampProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Stamp(props: &StampProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 22h14" />
+            <path
+                d="M19.27 13.73A2.5 2.5 0 0 0 17.5 13h-11A2.5 2.5 0 0 0 4 15.5V17a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1v-1.5c0-.66-.26-1.3-.73-1.77Z"
+            />
+            <path d="M14 13V8.5C14 7 15 7 15 5a3 3 0 0 0-3-3c-1.66 0-3 1-3 3s1 2 1 3.5V13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/star.rs b/packages/yew/src/star.rs
new file mode 100644
index 0000000..2c4dbe2
--- /dev/null
+++ b/packages/yew/src/star.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StarProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Star(props: &StarProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11.525 2.295a.53.53 0 0 1 .95 0l2.31 4.679a2.123 2.123 0 0 0 1.595 1.16l5.166.756a.53.53 0 0 1 .294.904l-3.736 3.638a2.123 2.123 0 0 0-.611 1.878l.882 5.14a.53.53 0 0 1-.771.56l-4.618-2.428a2.122 2.122 0 0 0-1.973 0L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.122 2.122 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.122 2.122 0 0 0 1.597-1.16z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/star_half.rs b/packages/yew/src/star_half.rs
new file mode 100644
index 0000000..f90f35e
--- /dev/null
+++ b/packages/yew/src/star_half.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StarHalfProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn StarHalf(props: &StarHalfProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12 18.338a2.1 2.1 0 0 0-.987.244L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.12 2.12 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.12 2.12 0 0 0 1.597-1.16l2.309-4.679A.53.53 0 0 1 12 2"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/star_off.rs b/packages/yew/src/star_off.rs
new file mode 100644
index 0000000..fd4753e
--- /dev/null
+++ b/packages/yew/src/star_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StarOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn StarOff(props: &StarOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8.34 8.34 2 9.27l5 4.87L5.82 21 12 17.77 18.18 21l-.59-3.43" />
+            <path d="M18.42 12.76 22 9.27l-6.91-1L12 2l-1.44 2.91" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/step_back.rs b/packages/yew/src/step_back.rs
new file mode 100644
index 0000000..474f171
--- /dev/null
+++ b/packages/yew/src/step_back.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StepBackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn StepBack(props: &StepBackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="18" x2="18" y1="20" y2="4" />
+            <polygon points="14,20 4,12 14,4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/step_forward.rs b/packages/yew/src/step_forward.rs
new file mode 100644
index 0000000..1e7c2ce
--- /dev/null
+++ b/packages/yew/src/step_forward.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StepForwardProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn StepForward(props: &StepForwardProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="6" x2="6" y1="4" y2="20" />
+            <polygon points="10,4 20,12 10,20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/stethoscope.rs b/packages/yew/src/stethoscope.rs
new file mode 100644
index 0000000..e5015e6
--- /dev/null
+++ b/packages/yew/src/stethoscope.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StethoscopeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Stethoscope(props: &StethoscopeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 2v2" />
+            <path d="M5 2v2" />
+            <path d="M5 3H4a2 2 0 0 0-2 2v4a6 6 0 0 0 12 0V5a2 2 0 0 0-2-2h-1" />
+            <path d="M8 15a6 6 0 0 0 12 0v-3" />
+            <circle cx="20" cy="10" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sticker.rs b/packages/yew/src/sticker.rs
new file mode 100644
index 0000000..4d406bd
--- /dev/null
+++ b/packages/yew/src/sticker.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StickerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sticker(props: &StickerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15.5 3H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h14a2 2 0 0 0 2-2V8.5L15.5 3Z" />
+            <path d="M14 3v4a2 2 0 0 0 2 2h4" />
+            <path d="M8 13h.01" />
+            <path d="M16 13h.01" />
+            <path d="M10 16s.8 1 2 1c1.3 0 2-1 2-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sticky_note.rs b/packages/yew/src/sticky_note.rs
new file mode 100644
index 0000000..f072e51
--- /dev/null
+++ b/packages/yew/src/sticky_note.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StickyNoteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn StickyNote(props: &StickyNoteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V8Z" />
+            <path d="M15 3v4a2 2 0 0 0 2 2h4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/store.rs b/packages/yew/src/store.rs
new file mode 100644
index 0000000..fa26e63
--- /dev/null
+++ b/packages/yew/src/store.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StoreProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Store(props: &StoreProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 7 4.41-4.41A2 2 0 0 1 7.83 2h8.34a2 2 0 0 1 1.42.59L22 7" />
+            <path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8" />
+            <path d="M15 22v-4a2 2 0 0 0-2-2h-2a2 2 0 0 0-2 2v4" />
+            <path d="M2 7h20" />
+            <path
+                d="M22 7v3a2 2 0 0 1-2 2a2.7 2.7 0 0 1-1.59-.63.7.7 0 0 0-.82 0A2.7 2.7 0 0 1 16 12a2.7 2.7 0 0 1-1.59-.63.7.7 0 0 0-.82 0A2.7 2.7 0 0 1 12 12a2.7 2.7 0 0 1-1.59-.63.7.7 0 0 0-.82 0A2.7 2.7 0 0 1 8 12a2.7 2.7 0 0 1-1.59-.63.7.7 0 0 0-.82 0A2.7 2.7 0 0 1 4 12a2 2 0 0 1-2-2V7"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/stretch_horizontal.rs b/packages/yew/src/stretch_horizontal.rs
new file mode 100644
index 0000000..e8f530f
--- /dev/null
+++ b/packages/yew/src/stretch_horizontal.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StretchHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn StretchHorizontal(props: &StretchHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="6" x="2" y="4" rx="2" />
+            <rect width="20" height="6" x="2" y="14" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/stretch_vertical.rs b/packages/yew/src/stretch_vertical.rs
new file mode 100644
index 0000000..7243bb2
--- /dev/null
+++ b/packages/yew/src/stretch_vertical.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StretchVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn StretchVertical(props: &StretchVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="6" height="20" x="4" y="2" rx="2" />
+            <rect width="6" height="20" x="14" y="2" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/strikethrough.rs b/packages/yew/src/strikethrough.rs
new file mode 100644
index 0000000..6b301c2
--- /dev/null
+++ b/packages/yew/src/strikethrough.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct StrikethroughProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Strikethrough(props: &StrikethroughProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 4H9a3 3 0 0 0-2.83 4" />
+            <path d="M14 12a4 4 0 0 1 0 8H6" />
+            <line x1="4" x2="20" y1="12" y2="12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/subscript.rs b/packages/yew/src/subscript.rs
new file mode 100644
index 0000000..06c4aaa
--- /dev/null
+++ b/packages/yew/src/subscript.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SubscriptProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Subscript(props: &SubscriptProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4 5 8 8" />
+            <path d="m12 5-8 8" />
+            <path
+                d="M20 19h-4c0-1.5.44-2 1.5-2.5S20 15.33 20 14c0-.47-.17-.93-.48-1.29a2.11 2.11 0 0 0-2.62-.44c-.42.24-.74.62-.9 1.07"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sun.rs b/packages/yew/src/sun.rs
new file mode 100644
index 0000000..44c087e
--- /dev/null
+++ b/packages/yew/src/sun.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SunProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sun(props: &SunProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="4" />
+            <path d="M12 2v2" />
+            <path d="M12 20v2" />
+            <path d="m4.93 4.93 1.41 1.41" />
+            <path d="m17.66 17.66 1.41 1.41" />
+            <path d="M2 12h2" />
+            <path d="M20 12h2" />
+            <path d="m6.34 17.66-1.41 1.41" />
+            <path d="m19.07 4.93-1.41 1.41" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sun_dim.rs b/packages/yew/src/sun_dim.rs
new file mode 100644
index 0000000..59585dc
--- /dev/null
+++ b/packages/yew/src/sun_dim.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SunDimProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SunDim(props: &SunDimProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="4" />
+            <path d="M12 4h.01" />
+            <path d="M20 12h.01" />
+            <path d="M12 20h.01" />
+            <path d="M4 12h.01" />
+            <path d="M17.657 6.343h.01" />
+            <path d="M17.657 17.657h.01" />
+            <path d="M6.343 17.657h.01" />
+            <path d="M6.343 6.343h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sun_medium.rs b/packages/yew/src/sun_medium.rs
new file mode 100644
index 0000000..be196b7
--- /dev/null
+++ b/packages/yew/src/sun_medium.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SunMediumProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SunMedium(props: &SunMediumProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="4" />
+            <path d="M12 3v1" />
+            <path d="M12 20v1" />
+            <path d="M3 12h1" />
+            <path d="M20 12h1" />
+            <path d="m18.364 5.636-.707.707" />
+            <path d="m6.343 17.657-.707.707" />
+            <path d="m5.636 5.636.707.707" />
+            <path d="m17.657 17.657.707.707" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sun_moon.rs b/packages/yew/src/sun_moon.rs
new file mode 100644
index 0000000..79bf778
--- /dev/null
+++ b/packages/yew/src/sun_moon.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SunMoonProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SunMoon(props: &SunMoonProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 8a2.83 2.83 0 0 0 4 4 4 4 0 1 1-4-4" />
+            <path d="M12 2v2" />
+            <path d="M12 20v2" />
+            <path d="m4.9 4.9 1.4 1.4" />
+            <path d="m17.7 17.7 1.4 1.4" />
+            <path d="M2 12h2" />
+            <path d="M20 12h2" />
+            <path d="m6.3 17.7-1.4 1.4" />
+            <path d="m19.1 4.9-1.4 1.4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sun_snow.rs b/packages/yew/src/sun_snow.rs
new file mode 100644
index 0000000..285154d
--- /dev/null
+++ b/packages/yew/src/sun_snow.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SunSnowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SunSnow(props: &SunSnowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 9a3 3 0 1 0 0 6" />
+            <path d="M2 12h1" />
+            <path d="M14 21V3" />
+            <path d="M10 4V3" />
+            <path d="M10 21v-1" />
+            <path d="m3.64 18.36.7-.7" />
+            <path d="m4.34 6.34-.7-.7" />
+            <path d="M14 12h8" />
+            <path d="m17 4-3 3" />
+            <path d="m14 17 3 3" />
+            <path d="m21 15-3-3 3-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sunrise.rs b/packages/yew/src/sunrise.rs
new file mode 100644
index 0000000..fae0a2e
--- /dev/null
+++ b/packages/yew/src/sunrise.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SunriseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sunrise(props: &SunriseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v8" />
+            <path d="m4.93 10.93 1.41 1.41" />
+            <path d="M2 18h2" />
+            <path d="M20 18h2" />
+            <path d="m19.07 10.93-1.41 1.41" />
+            <path d="M22 22H2" />
+            <path d="m8 6 4-4 4 4" />
+            <path d="M16 18a4 4 0 0 0-8 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sunset.rs b/packages/yew/src/sunset.rs
new file mode 100644
index 0000000..d79707a
--- /dev/null
+++ b/packages/yew/src/sunset.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SunsetProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sunset(props: &SunsetProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 10V2" />
+            <path d="m4.93 10.93 1.41 1.41" />
+            <path d="M2 18h2" />
+            <path d="M20 18h2" />
+            <path d="m19.07 10.93-1.41 1.41" />
+            <path d="M22 22H2" />
+            <path d="m16 6-4 4-4-4" />
+            <path d="M16 18a4 4 0 0 0-8 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/superscript.rs b/packages/yew/src/superscript.rs
new file mode 100644
index 0000000..e7ea9eb
--- /dev/null
+++ b/packages/yew/src/superscript.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SuperscriptProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Superscript(props: &SuperscriptProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4 19 8-8" />
+            <path d="m12 19-8-8" />
+            <path
+                d="M20 12h-4c0-1.5.442-2 1.5-2.5S20 8.334 20 7.002c0-.472-.17-.93-.484-1.29a2.105 2.105 0 0 0-2.617-.436c-.42.239-.738.614-.899 1.06"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/swatch_book.rs b/packages/yew/src/swatch_book.rs
new file mode 100644
index 0000000..fb1aa3f
--- /dev/null
+++ b/packages/yew/src/swatch_book.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SwatchBookProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SwatchBook(props: &SwatchBookProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 17a4 4 0 0 1-8 0V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2Z" />
+            <path d="M16.7 13H19a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H7" />
+            <path d="M 7 17h.01" />
+            <path
+                d="m11 8 2.3-2.3a2.4 2.4 0 0 1 3.404.004L18.6 7.6a2.4 2.4 0 0 1 .026 3.434L9.9 19.8"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/swiss_franc.rs b/packages/yew/src/swiss_franc.rs
new file mode 100644
index 0000000..b6455f3
--- /dev/null
+++ b/packages/yew/src/swiss_franc.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SwissFrancProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SwissFranc(props: &SwissFrancProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 21V3h8" />
+            <path d="M6 16h9" />
+            <path d="M10 9.5h7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/switch_camera.rs b/packages/yew/src/switch_camera.rs
new file mode 100644
index 0000000..1eb9ef2
--- /dev/null
+++ b/packages/yew/src/switch_camera.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SwitchCameraProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn SwitchCamera(props: &SwitchCameraProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11 19H4a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h5" />
+            <path d="M13 5h7a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-5" />
+            <circle cx="12" cy="12" r="3" />
+            <path d="m18 22-3-3 3-3" />
+            <path d="m6 2 3 3-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/sword.rs b/packages/yew/src/sword.rs
new file mode 100644
index 0000000..fdd119e
--- /dev/null
+++ b/packages/yew/src/sword.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SwordProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Sword(props: &SwordProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="14.5 17.5 3 6 3 3 6 3 17.5 14.5" />
+            <line x1="13" x2="19" y1="19" y2="13" />
+            <line x1="16" x2="20" y1="16" y2="20" />
+            <line x1="19" x2="21" y1="21" y2="19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/swords.rs b/packages/yew/src/swords.rs
new file mode 100644
index 0000000..18fc02d
--- /dev/null
+++ b/packages/yew/src/swords.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SwordsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Swords(props: &SwordsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="14.5 17.5 3 6 3 3 6 3 17.5 14.5" />
+            <line x1="13" x2="19" y1="19" y2="13" />
+            <line x1="16" x2="20" y1="16" y2="20" />
+            <line x1="19" x2="21" y1="21" y2="19" />
+            <polyline points="14.5 6.5 18 3 21 3 21 6 17.5 9.5" />
+            <line x1="5" x2="9" y1="14" y2="18" />
+            <line x1="7" x2="4" y1="17" y2="20" />
+            <line x1="3" x2="5" y1="19" y2="21" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/syringe.rs b/packages/yew/src/syringe.rs
new file mode 100644
index 0000000..11f8a6a
--- /dev/null
+++ b/packages/yew/src/syringe.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct SyringeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Syringe(props: &SyringeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m18 2 4 4" />
+            <path d="m17 7 3-3" />
+            <path d="M19 9 8.7 19.3c-1 1-2.5 1-3.4 0l-.6-.6c-1-1-1-2.5 0-3.4L15 5" />
+            <path d="m9 11 4 4" />
+            <path d="m5 19-3 3" />
+            <path d="m14 4 6 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/table.rs b/packages/yew/src/table.rs
new file mode 100644
index 0000000..fd6978b
--- /dev/null
+++ b/packages/yew/src/table.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TableProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Table(props: &TableProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 3v18" />
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 9h18" />
+            <path d="M3 15h18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/table_2.rs b/packages/yew/src/table_2.rs
new file mode 100644
index 0000000..02861b8
--- /dev/null
+++ b/packages/yew/src/table_2.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Table2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Table2(props: &Table2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/table_cells_merge.rs b/packages/yew/src/table_cells_merge.rs
new file mode 100644
index 0000000..c61e61c
--- /dev/null
+++ b/packages/yew/src/table_cells_merge.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TableCellsMergeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TableCellsMerge(props: &TableCellsMergeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 21v-6" />
+            <path d="M12 9V3" />
+            <path d="M3 15h18" />
+            <path d="M3 9h18" />
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/table_cells_split.rs b/packages/yew/src/table_cells_split.rs
new file mode 100644
index 0000000..4d2f17d
--- /dev/null
+++ b/packages/yew/src/table_cells_split.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TableCellsSplitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TableCellsSplit(props: &TableCellsSplitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 15V9" />
+            <path d="M3 15h18" />
+            <path d="M3 9h18" />
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/table_columns_split.rs b/packages/yew/src/table_columns_split.rs
new file mode 100644
index 0000000..2f2a61b
--- /dev/null
+++ b/packages/yew/src/table_columns_split.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TableColumnsSplitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TableColumnsSplit(props: &TableColumnsSplitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 14v2" />
+            <path d="M14 20v2" />
+            <path d="M14 2v2" />
+            <path d="M14 8v2" />
+            <path d="M2 15h8" />
+            <path d="M2 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H2" />
+            <path d="M2 9h8" />
+            <path d="M22 15h-4" />
+            <path d="M22 3h-2a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h2" />
+            <path d="M22 9h-4" />
+            <path d="M5 3v18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/table_of_contents.rs b/packages/yew/src/table_of_contents.rs
new file mode 100644
index 0000000..a73be20
--- /dev/null
+++ b/packages/yew/src/table_of_contents.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TableOfContentsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TableOfContents(props: &TableOfContentsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12H3" />
+            <path d="M16 18H3" />
+            <path d="M16 6H3" />
+            <path d="M21 12h.01" />
+            <path d="M21 18h.01" />
+            <path d="M21 6h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/table_properties.rs b/packages/yew/src/table_properties.rs
new file mode 100644
index 0000000..424039a
--- /dev/null
+++ b/packages/yew/src/table_properties.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TablePropertiesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TableProperties(props: &TablePropertiesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 3v18" />
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M21 9H3" />
+            <path d="M21 15H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/table_rows_split.rs b/packages/yew/src/table_rows_split.rs
new file mode 100644
index 0000000..693e1b2
--- /dev/null
+++ b/packages/yew/src/table_rows_split.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TableRowsSplitProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TableRowsSplit(props: &TableRowsSplitProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 10h2" />
+            <path d="M15 22v-8" />
+            <path d="M15 2v4" />
+            <path d="M2 10h2" />
+            <path d="M20 10h2" />
+            <path d="M3 19h18" />
+            <path d="M3 22v-6a2 2 135 0 1 2-2h14a2 2 45 0 1 2 2v6" />
+            <path d="M3 2v2a2 2 45 0 0 2 2h14a2 2 135 0 0 2-2V2" />
+            <path d="M8 10h2" />
+            <path d="M9 22v-8" />
+            <path d="M9 2v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tablet.rs b/packages/yew/src/tablet.rs
new file mode 100644
index 0000000..8d9a8b7
--- /dev/null
+++ b/packages/yew/src/tablet.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TabletProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tablet(props: &TabletProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="20" x="4" y="2" rx="2" ry="2" />
+            <line x1="12" x2="12.01" y1="18" y2="18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tablet_smartphone.rs b/packages/yew/src/tablet_smartphone.rs
new file mode 100644
index 0000000..4157ced
--- /dev/null
+++ b/packages/yew/src/tablet_smartphone.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TabletSmartphoneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TabletSmartphone(props: &TabletSmartphoneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="10" height="14" x="3" y="8" rx="2" />
+            <path d="M5 4a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2h-2.4" />
+            <path d="M8 18h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tablets.rs b/packages/yew/src/tablets.rs
new file mode 100644
index 0000000..1e5be0e
--- /dev/null
+++ b/packages/yew/src/tablets.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TabletsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tablets(props: &TabletsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="7" cy="7" r="5" />
+            <circle cx="17" cy="17" r="5" />
+            <path d="M12 17h10" />
+            <path d="m3.46 10.54 7.08-7.08" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tag.rs b/packages/yew/src/tag.rs
new file mode 100644
index 0000000..8e3d297
--- /dev/null
+++ b/packages/yew/src/tag.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TagProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tag(props: &TagProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M12.586 2.586A2 2 0 0 0 11.172 2H4a2 2 0 0 0-2 2v7.172a2 2 0 0 0 .586 1.414l8.704 8.704a2.426 2.426 0 0 0 3.42 0l6.58-6.58a2.426 2.426 0 0 0 0-3.42z"
+            />
+            <circle cx="7.5" cy="7.5" r=".5" fill="currentColor" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tags.rs b/packages/yew/src/tags.rs
new file mode 100644
index 0000000..7ff0b58
--- /dev/null
+++ b/packages/yew/src/tags.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TagsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tags(props: &TagsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m15 5 6.3 6.3a2.4 2.4 0 0 1 0 3.4L17 19" />
+            <path
+                d="M9.586 5.586A2 2 0 0 0 8.172 5H3a1 1 0 0 0-1 1v5.172a2 2 0 0 0 .586 1.414L8.29 18.29a2.426 2.426 0 0 0 3.42 0l3.58-3.58a2.426 2.426 0 0 0 0-3.42z"
+            />
+            <circle cx="6.5" cy="9.5" r=".5" fill="currentColor" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tally_1.rs b/packages/yew/src/tally_1.rs
new file mode 100644
index 0000000..552546c
--- /dev/null
+++ b/packages/yew/src/tally_1.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Tally1Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tally1(props: &Tally1Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tally_2.rs b/packages/yew/src/tally_2.rs
new file mode 100644
index 0000000..11a371d
--- /dev/null
+++ b/packages/yew/src/tally_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Tally2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tally2(props: &Tally2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16" />
+            <path d="M9 4v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tally_3.rs b/packages/yew/src/tally_3.rs
new file mode 100644
index 0000000..d7aa180
--- /dev/null
+++ b/packages/yew/src/tally_3.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Tally3Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tally3(props: &Tally3Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16" />
+            <path d="M9 4v16" />
+            <path d="M14 4v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tally_4.rs b/packages/yew/src/tally_4.rs
new file mode 100644
index 0000000..a23c667
--- /dev/null
+++ b/packages/yew/src/tally_4.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Tally4Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tally4(props: &Tally4Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16" />
+            <path d="M9 4v16" />
+            <path d="M14 4v16" />
+            <path d="M19 4v16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tally_5.rs b/packages/yew/src/tally_5.rs
new file mode 100644
index 0000000..b66e4f1
--- /dev/null
+++ b/packages/yew/src/tally_5.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Tally5Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tally5(props: &Tally5Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4v16" />
+            <path d="M9 4v16" />
+            <path d="M14 4v16" />
+            <path d="M19 4v16" />
+            <path d="M22 6 2 18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tangent.rs b/packages/yew/src/tangent.rs
new file mode 100644
index 0000000..ae2a089
--- /dev/null
+++ b/packages/yew/src/tangent.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TangentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tangent(props: &TangentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="17" cy="4" r="2" />
+            <path d="M15.59 5.41 5.41 15.59" />
+            <circle cx="4" cy="17" r="2" />
+            <path d="M12 22s-4-9-1.5-11.5S22 12 22 12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/target.rs b/packages/yew/src/target.rs
new file mode 100644
index 0000000..f3103cd
--- /dev/null
+++ b/packages/yew/src/target.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TargetProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Target(props: &TargetProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="10" />
+            <circle cx="12" cy="12" r="6" />
+            <circle cx="12" cy="12" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/telescope.rs b/packages/yew/src/telescope.rs
new file mode 100644
index 0000000..e7ac0c6
--- /dev/null
+++ b/packages/yew/src/telescope.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TelescopeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Telescope(props: &TelescopeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m10.065 12.493-6.18 1.318a.934.934 0 0 1-1.108-.702l-.537-2.15a1.07 1.07 0 0 1 .691-1.265l13.504-4.44"
+            />
+            <path d="m13.56 11.747 4.332-.924" />
+            <path d="m16 21-3.105-6.21" />
+            <path
+                d="M16.485 5.94a2 2 0 0 1 1.455-2.425l1.09-.272a1 1 0 0 1 1.212.727l1.515 6.06a1 1 0 0 1-.727 1.213l-1.09.272a2 2 0 0 1-2.425-1.455z"
+            />
+            <path d="m6.158 8.633 1.114 4.456" />
+            <path d="m8 21 3.105-6.21" />
+            <circle cx="12" cy="13" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tent.rs b/packages/yew/src/tent.rs
new file mode 100644
index 0000000..9743bf7
--- /dev/null
+++ b/packages/yew/src/tent.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tent(props: &TentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3.5 21 14 3" />
+            <path d="M20.5 21 10 3" />
+            <path d="M15.5 21 12 15l-3.5 6" />
+            <path d="M2 21h20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tent_tree.rs b/packages/yew/src/tent_tree.rs
new file mode 100644
index 0000000..17de90c
--- /dev/null
+++ b/packages/yew/src/tent_tree.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TentTreeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TentTree(props: &TentTreeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="4" cy="4" r="2" />
+            <path d="m14 5 3-3 3 3" />
+            <path d="m14 10 3-3 3 3" />
+            <path d="M17 14V2" />
+            <path d="M17 14H7l-5 8h20Z" />
+            <path d="M8 14v8" />
+            <path d="m9 14 5 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/terminal.rs b/packages/yew/src/terminal.rs
new file mode 100644
index 0000000..aeb0ee9
--- /dev/null
+++ b/packages/yew/src/terminal.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TerminalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Terminal(props: &TerminalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="4 17 10 11 4 5" />
+            <line x1="12" x2="20" y1="19" y2="19" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/test_tube.rs b/packages/yew/src/test_tube.rs
new file mode 100644
index 0000000..8860583
--- /dev/null
+++ b/packages/yew/src/test_tube.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TestTubeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TestTube(props: &TestTubeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.5 2v17.5c0 1.4-1.1 2.5-2.5 2.5c-1.4 0-2.5-1.1-2.5-2.5V2" />
+            <path d="M8.5 2h7" />
+            <path d="M14.5 16h-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/test_tube_diagonal.rs b/packages/yew/src/test_tube_diagonal.rs
new file mode 100644
index 0000000..f120024
--- /dev/null
+++ b/packages/yew/src/test_tube_diagonal.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TestTubeDiagonalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TestTubeDiagonal(props: &TestTubeDiagonalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 7 6.82 21.18a2.83 2.83 0 0 1-3.99-.01a2.83 2.83 0 0 1 0-4L17 3" />
+            <path d="m16 2 6 6" />
+            <path d="M12 16H4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/test_tubes.rs b/packages/yew/src/test_tubes.rs
new file mode 100644
index 0000000..61685e9
--- /dev/null
+++ b/packages/yew/src/test_tubes.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TestTubesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TestTubes(props: &TestTubesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 2v17.5A2.5 2.5 0 0 1 6.5 22A2.5 2.5 0 0 1 4 19.5V2" />
+            <path d="M20 2v17.5a2.5 2.5 0 0 1-2.5 2.5a2.5 2.5 0 0 1-2.5-2.5V2" />
+            <path d="M3 2h7" />
+            <path d="M14 2h7" />
+            <path d="M9 16H4" />
+            <path d="M20 16h-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/text.rs b/packages/yew/src/text.rs
new file mode 100644
index 0000000..ebf20fa
--- /dev/null
+++ b/packages/yew/src/text.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Text(props: &TextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 6.1H3" />
+            <path d="M21 12.1H3" />
+            <path d="M15.1 18H3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/text_cursor.rs b/packages/yew/src/text_cursor.rs
new file mode 100644
index 0000000..090b8ac
--- /dev/null
+++ b/packages/yew/src/text_cursor.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TextCursorProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TextCursor(props: &TextCursorProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 22h-1a4 4 0 0 1-4-4V6a4 4 0 0 1 4-4h1" />
+            <path d="M7 22h1a4 4 0 0 0 4-4v-1" />
+            <path d="M7 2h1a4 4 0 0 1 4 4v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/text_cursor_input.rs b/packages/yew/src/text_cursor_input.rs
new file mode 100644
index 0000000..f9f337f
--- /dev/null
+++ b/packages/yew/src/text_cursor_input.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TextCursorInputProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TextCursorInput(props: &TextCursorInputProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 4h1a3 3 0 0 1 3 3 3 3 0 0 1 3-3h1" />
+            <path d="M13 20h-1a3 3 0 0 1-3-3 3 3 0 0 1-3 3H5" />
+            <path d="M5 16H4a2 2 0 0 1-2-2v-4a2 2 0 0 1 2-2h1" />
+            <path d="M13 8h7a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-7" />
+            <path d="M9 7v10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/text_quote.rs b/packages/yew/src/text_quote.rs
new file mode 100644
index 0000000..14840e1
--- /dev/null
+++ b/packages/yew/src/text_quote.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TextQuoteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TextQuote(props: &TextQuoteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 6H3" />
+            <path d="M21 12H8" />
+            <path d="M21 18H8" />
+            <path d="M3 12v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/text_search.rs b/packages/yew/src/text_search.rs
new file mode 100644
index 0000000..26d894b
--- /dev/null
+++ b/packages/yew/src/text_search.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TextSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TextSearch(props: &TextSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 6H3" />
+            <path d="M10 12H3" />
+            <path d="M10 18H3" />
+            <circle cx="17" cy="15" r="3" />
+            <path d="m21 19-1.9-1.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/text_select.rs b/packages/yew/src/text_select.rs
new file mode 100644
index 0000000..2c4448e
--- /dev/null
+++ b/packages/yew/src/text_select.rs
@@ -0,0 +1,58 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TextSelectProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TextSelect(props: &TextSelectProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M5 3a2 2 0 0 0-2 2" />
+            <path d="M19 3a2 2 0 0 1 2 2" />
+            <path d="M21 19a2 2 0 0 1-2 2" />
+            <path d="M5 21a2 2 0 0 1-2-2" />
+            <path d="M9 3h1" />
+            <path d="M9 21h1" />
+            <path d="M14 3h1" />
+            <path d="M14 21h1" />
+            <path d="M3 9v1" />
+            <path d="M21 9v1" />
+            <path d="M3 14v1" />
+            <path d="M21 14v1" />
+            <line x1="7" x2="15" y1="8" y2="8" />
+            <line x1="7" x2="17" y1="12" y2="12" />
+            <line x1="7" x2="13" y1="16" y2="16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/theater.rs b/packages/yew/src/theater.rs
new file mode 100644
index 0000000..08792f2
--- /dev/null
+++ b/packages/yew/src/theater.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TheaterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Theater(props: &TheaterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 10s3-3 3-8" />
+            <path d="M22 10s-3-3-3-8" />
+            <path d="M10 2c0 4.4-3.6 8-8 8" />
+            <path d="M14 2c0 4.4 3.6 8 8 8" />
+            <path d="M2 10s2 2 2 5" />
+            <path d="M22 10s-2 2-2 5" />
+            <path d="M8 15h8" />
+            <path d="M2 22v-1a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1" />
+            <path d="M14 22v-1a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/thermometer.rs b/packages/yew/src/thermometer.rs
new file mode 100644
index 0000000..d333362
--- /dev/null
+++ b/packages/yew/src/thermometer.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ThermometerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Thermometer(props: &ThermometerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/thermometer_snowflake.rs b/packages/yew/src/thermometer_snowflake.rs
new file mode 100644
index 0000000..e57085b
--- /dev/null
+++ b/packages/yew/src/thermometer_snowflake.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ThermometerSnowflakeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ThermometerSnowflake(props: &ThermometerSnowflakeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 12h10" />
+            <path d="M9 4v16" />
+            <path d="m3 9 3 3-3 3" />
+            <path d="M12 6 9 9 6 6" />
+            <path d="m6 18 3-3 1.5 1.5" />
+            <path d="M20 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/thermometer_sun.rs b/packages/yew/src/thermometer_sun.rs
new file mode 100644
index 0000000..3d66475
--- /dev/null
+++ b/packages/yew/src/thermometer_sun.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ThermometerSunProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ThermometerSun(props: &ThermometerSunProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 9a4 4 0 0 0-2 7.5" />
+            <path d="M12 3v2" />
+            <path d="m6.6 18.4-1.4 1.4" />
+            <path d="M20 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z" />
+            <path d="M4 13H2" />
+            <path d="M6.34 7.34 4.93 5.93" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/thumbs_down.rs b/packages/yew/src/thumbs_down.rs
new file mode 100644
index 0000000..bf0cc94
--- /dev/null
+++ b/packages/yew/src/thumbs_down.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ThumbsDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ThumbsDown(props: &ThumbsDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 14V2" />
+            <path
+                d="M9 18.12 10 14H4.17a2 2 0 0 1-1.92-2.56l2.33-8A2 2 0 0 1 6.5 2H20a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.76a2 2 0 0 0-1.79 1.11L12 22a3.13 3.13 0 0 1-3-3.88Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/thumbs_up.rs b/packages/yew/src/thumbs_up.rs
new file mode 100644
index 0000000..a94dae2
--- /dev/null
+++ b/packages/yew/src/thumbs_up.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ThumbsUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ThumbsUp(props: &ThumbsUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 10v12" />
+            <path
+                d="M15 5.88 14 10h5.83a2 2 0 0 1 1.92 2.56l-2.33 8A2 2 0 0 1 17.5 22H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2h2.76a2 2 0 0 0 1.79-1.11L12 2a3.13 3.13 0 0 1 3 3.88Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ticket.rs b/packages/yew/src/ticket.rs
new file mode 100644
index 0000000..e3bc133
--- /dev/null
+++ b/packages/yew/src/ticket.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ticket(props: &TicketProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"
+            />
+            <path d="M13 5v2" />
+            <path d="M13 17v2" />
+            <path d="M13 11v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ticket_check.rs b/packages/yew/src/ticket_check.rs
new file mode 100644
index 0000000..8095037
--- /dev/null
+++ b/packages/yew/src/ticket_check.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TicketCheck(props: &TicketCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"
+            />
+            <path d="m9 12 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ticket_minus.rs b/packages/yew/src/ticket_minus.rs
new file mode 100644
index 0000000..cd84b7b
--- /dev/null
+++ b/packages/yew/src/ticket_minus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TicketMinus(props: &TicketMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"
+            />
+            <path d="M9 12h6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ticket_percent.rs b/packages/yew/src/ticket_percent.rs
new file mode 100644
index 0000000..aeef7b7
--- /dev/null
+++ b/packages/yew/src/ticket_percent.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketPercentProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TicketPercent(props: &TicketPercentProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9a3 3 0 1 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 1 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"
+            />
+            <path d="M9 9h.01" />
+            <path d="m15 9-6 6" />
+            <path d="M15 15h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ticket_plus.rs b/packages/yew/src/ticket_plus.rs
new file mode 100644
index 0000000..edfadd5
--- /dev/null
+++ b/packages/yew/src/ticket_plus.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TicketPlus(props: &TicketPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"
+            />
+            <path d="M9 12h6" />
+            <path d="M12 9v6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ticket_slash.rs b/packages/yew/src/ticket_slash.rs
new file mode 100644
index 0000000..8bf80a0
--- /dev/null
+++ b/packages/yew/src/ticket_slash.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketSlashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TicketSlash(props: &TicketSlashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"
+            />
+            <path d="m9.5 14.5 5-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ticket_x.rs b/packages/yew/src/ticket_x.rs
new file mode 100644
index 0000000..fdf88fb
--- /dev/null
+++ b/packages/yew/src/ticket_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TicketX(props: &TicketXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"
+            />
+            <path d="m9.5 14.5 5-5" />
+            <path d="m9.5 9.5 5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tickets.rs b/packages/yew/src/tickets.rs
new file mode 100644
index 0000000..69675fa
--- /dev/null
+++ b/packages/yew/src/tickets.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tickets(props: &TicketsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m4.5 8 10.58-5.06a1 1 0 0 1 1.342.488L18.5 8" />
+            <path d="M6 10V8" />
+            <path d="M6 14v1" />
+            <path d="M6 19v2" />
+            <rect x="2" y="8" width="20" height="13" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tickets_plane.rs b/packages/yew/src/tickets_plane.rs
new file mode 100644
index 0000000..f8db89a
--- /dev/null
+++ b/packages/yew/src/tickets_plane.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TicketsPlaneProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TicketsPlane(props: &TicketsPlaneProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.5 17h1.227a2 2 0 0 0 1.345-.52L18 12" />
+            <path d="m12 13.5 3.75.5" />
+            <path d="m4.5 8 10.58-5.06a1 1 0 0 1 1.342.488L18.5 8" />
+            <path d="M6 10V8" />
+            <path d="M6 14v1" />
+            <path d="M6 19v2" />
+            <rect x="2" y="8" width="20" height="13" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/timer.rs b/packages/yew/src/timer.rs
new file mode 100644
index 0000000..c4cadfc
--- /dev/null
+++ b/packages/yew/src/timer.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TimerProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Timer(props: &TimerProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="10" x2="14" y1="2" y2="2" />
+            <line x1="12" x2="15" y1="14" y2="11" />
+            <circle cx="12" cy="14" r="8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/timer_off.rs b/packages/yew/src/timer_off.rs
new file mode 100644
index 0000000..5136bce
--- /dev/null
+++ b/packages/yew/src/timer_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TimerOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TimerOff(props: &TimerOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2h4" />
+            <path d="M4.6 11a8 8 0 0 0 1.7 8.7 8 8 0 0 0 8.7 1.7" />
+            <path d="M7.4 7.4a8 8 0 0 1 10.3 1 8 8 0 0 1 .9 10.2" />
+            <path d="m2 2 20 20" />
+            <path d="M12 12v-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/timer_reset.rs b/packages/yew/src/timer_reset.rs
new file mode 100644
index 0000000..ba9158e
--- /dev/null
+++ b/packages/yew/src/timer_reset.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TimerResetProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TimerReset(props: &TimerResetProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2h4" />
+            <path d="M12 14v-4" />
+            <path d="M4 13a8 8 0 0 1 8-7 8 8 0 1 1-5.3 14L4 17.6" />
+            <path d="M9 17H4v5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/toggle_left.rs b/packages/yew/src/toggle_left.rs
new file mode 100644
index 0000000..072c840
--- /dev/null
+++ b/packages/yew/src/toggle_left.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ToggleLeftProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ToggleLeft(props: &ToggleLeftProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="6" ry="6" />
+            <circle cx="8" cy="12" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/toggle_right.rs b/packages/yew/src/toggle_right.rs
new file mode 100644
index 0000000..a9114b9
--- /dev/null
+++ b/packages/yew/src/toggle_right.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ToggleRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ToggleRight(props: &ToggleRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="12" x="2" y="6" rx="6" ry="6" />
+            <circle cx="16" cy="12" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/toilet.rs b/packages/yew/src/toilet.rs
new file mode 100644
index 0000000..238eb10
--- /dev/null
+++ b/packages/yew/src/toilet.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ToiletProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Toilet(props: &ToiletProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M7 12h13a1 1 0 0 1 1 1 5 5 0 0 1-5 5h-.598a.5.5 0 0 0-.424.765l1.544 2.47a.5.5 0 0 1-.424.765H5.402a.5.5 0 0 1-.424-.765L7 18"
+            />
+            <path d="M8 18a5 5 0 0 1-5-5V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tornado.rs b/packages/yew/src/tornado.rs
new file mode 100644
index 0000000..8d33239
--- /dev/null
+++ b/packages/yew/src/tornado.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TornadoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tornado(props: &TornadoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 4H3" />
+            <path d="M18 8H6" />
+            <path d="M19 12H9" />
+            <path d="M16 16h-6" />
+            <path d="M11 20H9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/torus.rs b/packages/yew/src/torus.rs
new file mode 100644
index 0000000..c1f92e6
--- /dev/null
+++ b/packages/yew/src/torus.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TorusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Torus(props: &TorusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <ellipse cx="12" cy="11" rx="3" ry="2" />
+            <ellipse cx="12" cy="12.5" rx="10" ry="8.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/touchpad.rs b/packages/yew/src/touchpad.rs
new file mode 100644
index 0000000..f63a8f8
--- /dev/null
+++ b/packages/yew/src/touchpad.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TouchpadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Touchpad(props: &TouchpadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+            <path d="M2 14h20" />
+            <path d="M12 20v-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/touchpad_off.rs b/packages/yew/src/touchpad_off.rs
new file mode 100644
index 0000000..3623ab5
--- /dev/null
+++ b/packages/yew/src/touchpad_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TouchpadOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TouchpadOff(props: &TouchpadOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M4 4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h16" />
+            <path d="M2 14h12" />
+            <path d="M22 14h-2" />
+            <path d="M12 20v-6" />
+            <path d="m2 2 20 20" />
+            <path d="M22 16V6a2 2 0 0 0-2-2H10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tower_control.rs b/packages/yew/src/tower_control.rs
new file mode 100644
index 0000000..c89c22e
--- /dev/null
+++ b/packages/yew/src/tower_control.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TowerControlProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TowerControl(props: &TowerControlProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18.2 12.27 20 6H4l1.8 6.27a1 1 0 0 0 .95.73h10.5a1 1 0 0 0 .96-.73Z" />
+            <path d="M8 13v9" />
+            <path d="M16 22v-9" />
+            <path d="m9 6 1 7" />
+            <path d="m15 6-1 7" />
+            <path d="M12 6V2" />
+            <path d="M13 2h-2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/toy_brick.rs b/packages/yew/src/toy_brick.rs
new file mode 100644
index 0000000..22a6e19
--- /dev/null
+++ b/packages/yew/src/toy_brick.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ToyBrickProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ToyBrick(props: &ToyBrickProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="12" x="3" y="8" rx="1" />
+            <path d="M10 8V5c0-.6-.4-1-1-1H6a1 1 0 0 0-1 1v3" />
+            <path d="M19 8V5c0-.6-.4-1-1-1h-3a1 1 0 0 0-1 1v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tractor.rs b/packages/yew/src/tractor.rs
new file mode 100644
index 0000000..29b833c
--- /dev/null
+++ b/packages/yew/src/tractor.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TractorProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tractor(props: &TractorProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m10 11 11 .9a1 1 0 0 1 .8 1.1l-.665 4.158a1 1 0 0 1-.988.842H20" />
+            <path d="M16 18h-5" />
+            <path d="M18 5a1 1 0 0 0-1 1v5.573" />
+            <path d="M3 4h8.129a1 1 0 0 1 .99.863L13 11.246" />
+            <path d="M4 11V4" />
+            <path d="M7 15h.01" />
+            <path d="M8 10.1V4" />
+            <circle cx="18" cy="18" r="2" />
+            <circle cx="7" cy="15" r="5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/traffic_cone.rs b/packages/yew/src/traffic_cone.rs
new file mode 100644
index 0000000..ee12058
--- /dev/null
+++ b/packages/yew/src/traffic_cone.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrafficConeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TrafficCone(props: &TrafficConeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9.3 6.2a4.55 4.55 0 0 0 5.4 0" />
+            <path d="M7.9 10.7c.9.8 2.4 1.3 4.1 1.3s3.2-.5 4.1-1.3" />
+            <path
+                d="M13.9 3.5a1.93 1.93 0 0 0-3.8-.1l-3 10c-.1.2-.1.4-.1.6 0 1.7 2.2 3 5 3s5-1.3 5-3c0-.2 0-.4-.1-.5Z"
+            />
+            <path
+                d="m7.5 12.2-4.7 2.7c-.5.3-.8.7-.8 1.1s.3.8.8 1.1l7.6 4.5c.9.5 2.1.5 3 0l7.6-4.5c.7-.3 1-.7 1-1.1s-.3-.8-.8-1.1l-4.7-2.8"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/train_front.rs b/packages/yew/src/train_front.rs
new file mode 100644
index 0000000..7c2c6bb
--- /dev/null
+++ b/packages/yew/src/train_front.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrainFrontProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TrainFront(props: &TrainFrontProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 3.1V7a4 4 0 0 0 8 0V3.1" />
+            <path d="m9 15-1-1" />
+            <path d="m15 15 1-1" />
+            <path d="M9 19c-2.8 0-5-2.2-5-5v-4a8 8 0 0 1 16 0v4c0 2.8-2.2 5-5 5Z" />
+            <path d="m8 19-2 3" />
+            <path d="m16 19 2 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/train_front_tunnel.rs b/packages/yew/src/train_front_tunnel.rs
new file mode 100644
index 0000000..abeeacd
--- /dev/null
+++ b/packages/yew/src/train_front_tunnel.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrainFrontTunnelProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TrainFrontTunnel(props: &TrainFrontTunnelProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22V12a10 10 0 1 1 20 0v10" />
+            <path d="M15 6.8v1.4a3 2.8 0 1 1-6 0V6.8" />
+            <path d="M10 15h.01" />
+            <path d="M14 15h.01" />
+            <path d="M10 19a4 4 0 0 1-4-4v-3a6 6 0 1 1 12 0v3a4 4 0 0 1-4 4Z" />
+            <path d="m9 19-2 3" />
+            <path d="m15 19 2 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/train_track.rs b/packages/yew/src/train_track.rs
new file mode 100644
index 0000000..6488979
--- /dev/null
+++ b/packages/yew/src/train_track.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrainTrackProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TrainTrack(props: &TrainTrackProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 17 17 2" />
+            <path d="m2 14 8 8" />
+            <path d="m5 11 8 8" />
+            <path d="m8 8 8 8" />
+            <path d="m11 5 8 8" />
+            <path d="m14 2 8 8" />
+            <path d="M7 22 22 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tram_front.rs b/packages/yew/src/tram_front.rs
new file mode 100644
index 0000000..6a6c365
--- /dev/null
+++ b/packages/yew/src/tram_front.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TramFrontProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TramFront(props: &TramFrontProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="16" height="16" x="4" y="3" rx="2" />
+            <path d="M4 11h16" />
+            <path d="M12 3v8" />
+            <path d="m8 19-2 3" />
+            <path d="m18 22-2-3" />
+            <path d="M8 15h.01" />
+            <path d="M16 15h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/trash.rs b/packages/yew/src/trash.rs
new file mode 100644
index 0000000..1dd7ba2
--- /dev/null
+++ b/packages/yew/src/trash.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrashProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Trash(props: &TrashProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 6h18" />
+            <path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6" />
+            <path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/trash_2.rs b/packages/yew/src/trash_2.rs
new file mode 100644
index 0000000..bd29456
--- /dev/null
+++ b/packages/yew/src/trash_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Trash2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Trash2(props: &Trash2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 6h18" />
+            <path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6" />
+            <path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2" />
+            <line x1="10" x2="10" y1="11" y2="17" />
+            <line x1="14" x2="14" y1="11" y2="17" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tree_deciduous.rs b/packages/yew/src/tree_deciduous.rs
new file mode 100644
index 0000000..b7dac4d
--- /dev/null
+++ b/packages/yew/src/tree_deciduous.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TreeDeciduousProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TreeDeciduous(props: &TreeDeciduousProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M8 19a4 4 0 0 1-2.24-7.32A3.5 3.5 0 0 1 9 6.03V6a3 3 0 1 1 6 0v.04a3.5 3.5 0 0 1 3.24 5.65A4 4 0 0 1 16 19Z"
+            />
+            <path d="M12 19v3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tree_palm.rs b/packages/yew/src/tree_palm.rs
new file mode 100644
index 0000000..32d29f7
--- /dev/null
+++ b/packages/yew/src/tree_palm.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TreePalmProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TreePalm(props: &TreePalmProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13 8c0-2.76-2.46-5-5.5-5S2 5.24 2 8h2l1-1 1 1h4" />
+            <path d="M13 7.14A5.82 5.82 0 0 1 16.5 6c3.04 0 5.5 2.24 5.5 5h-3l-1-1-1 1h-3" />
+            <path
+                d="M5.89 9.71c-2.15 2.15-2.3 5.47-.35 7.43l4.24-4.25.7-.7.71-.71 2.12-2.12c-1.95-1.96-5.27-1.8-7.42.35"
+            />
+            <path d="M11 15.5c.5 2.5-.17 4.5-1 6.5h4c2-5.5-.5-12-1-14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tree_pine.rs b/packages/yew/src/tree_pine.rs
new file mode 100644
index 0000000..20cdf22
--- /dev/null
+++ b/packages/yew/src/tree_pine.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TreePineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TreePine(props: &TreePineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m17 14 3 3.3a1 1 0 0 1-.7 1.7H4.7a1 1 0 0 1-.7-1.7L7 14h-.3a1 1 0 0 1-.7-1.7L9 9h-.2A1 1 0 0 1 8 7.3L12 3l4 4.3a1 1 0 0 1-.8 1.7H15l3 3.3a1 1 0 0 1-.7 1.7H17Z"
+            />
+            <path d="M12 22v-3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/trees.rs b/packages/yew/src/trees.rs
new file mode 100644
index 0000000..772071e
--- /dev/null
+++ b/packages/yew/src/trees.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TreesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Trees(props: &TreesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 10v.2A3 3 0 0 1 8.9 16H5a3 3 0 0 1-1-5.8V10a3 3 0 0 1 6 0Z" />
+            <path d="M7 16v6" />
+            <path d="M13 19v3" />
+            <path
+                d="M12 19h8.3a1 1 0 0 0 .7-1.7L18 14h.3a1 1 0 0 0 .7-1.7L16 9h.2a1 1 0 0 0 .8-1.7L13 3l-1.4 1.5"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/trello.rs b/packages/yew/src/trello.rs
new file mode 100644
index 0000000..527ae62
--- /dev/null
+++ b/packages/yew/src/trello.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrelloProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Trello(props: &TrelloProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" />
+            <rect width="3" height="9" x="7" y="7" />
+            <rect width="3" height="5" x="14" y="7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/trending_down.rs b/packages/yew/src/trending_down.rs
new file mode 100644
index 0000000..3434996
--- /dev/null
+++ b/packages/yew/src/trending_down.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrendingDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TrendingDown(props: &TrendingDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="22 17 13.5 8.5 8.5 13.5 2 7" />
+            <polyline points="16 17 22 17 22 11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/trending_up.rs b/packages/yew/src/trending_up.rs
new file mode 100644
index 0000000..2c53456
--- /dev/null
+++ b/packages/yew/src/trending_up.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrendingUpProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TrendingUp(props: &TrendingUpProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="22 7 13.5 15.5 8.5 10.5 2 17" />
+            <polyline points="16 7 22 7 22 13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/trending_up_down.rs b/packages/yew/src/trending_up_down.rs
new file mode 100644
index 0000000..6933346
--- /dev/null
+++ b/packages/yew/src/trending_up_down.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrendingUpDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TrendingUpDown(props: &TrendingUpDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14.828 14.828 21 21" />
+            <path d="M21 16v5h-5" />
+            <path d="m21 3-9 9-4-4-6 6" />
+            <path d="M21 8V3h-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/triangle.rs b/packages/yew/src/triangle.rs
new file mode 100644
index 0000000..fda3e62
--- /dev/null
+++ b/packages/yew/src/triangle.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TriangleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Triangle(props: &TriangleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M13.73 4a2 2 0 0 0-3.46 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/triangle_alert.rs b/packages/yew/src/triangle_alert.rs
new file mode 100644
index 0000000..937a811
--- /dev/null
+++ b/packages/yew/src/triangle_alert.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TriangleAlertProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TriangleAlert(props: &TriangleAlertProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3" />
+            <path d="M12 9v4" />
+            <path d="M12 17h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/triangle_right.rs b/packages/yew/src/triangle_right.rs
new file mode 100644
index 0000000..04c1831
--- /dev/null
+++ b/packages/yew/src/triangle_right.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TriangleRightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TriangleRight(props: &TriangleRightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 18a2 2 0 0 1-2 2H3c-1.1 0-1.3-.6-.4-1.3L20.4 4.3c.9-.7 1.6-.4 1.6.7Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/trophy.rs b/packages/yew/src/trophy.rs
new file mode 100644
index 0000000..2b9c4c7
--- /dev/null
+++ b/packages/yew/src/trophy.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TrophyProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Trophy(props: &TrophyProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 9H4.5a2.5 2.5 0 0 1 0-5H6" />
+            <path d="M18 9h1.5a2.5 2.5 0 0 0 0-5H18" />
+            <path d="M4 22h16" />
+            <path d="M10 14.66V17c0 .55-.47.98-.97 1.21C7.85 18.75 7 20.24 7 22" />
+            <path d="M14 14.66V17c0 .55.47.98.97 1.21C16.15 18.75 17 20.24 17 22" />
+            <path d="M18 2H6v7a6 6 0 0 0 12 0V2Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/truck.rs b/packages/yew/src/truck.rs
new file mode 100644
index 0000000..ffc4e8b
--- /dev/null
+++ b/packages/yew/src/truck.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TruckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Truck(props: &TruckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2" />
+            <path d="M15 18H9" />
+            <path
+                d="M19 18h2a1 1 0 0 0 1-1v-3.65a1 1 0 0 0-.22-.624l-3.48-4.35A1 1 0 0 0 17.52 8H14"
+            />
+            <circle cx="17" cy="18" r="2" />
+            <circle cx="7" cy="18" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/turtle.rs b/packages/yew/src/turtle.rs
new file mode 100644
index 0000000..5ca084b
--- /dev/null
+++ b/packages/yew/src/turtle.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TurtleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Turtle(props: &TurtleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m12 10 2 4v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3a8 8 0 1 0-16 0v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3l2-4h4Z"
+            />
+            <path d="M4.82 7.9 8 10" />
+            <path d="M15.18 7.9 12 10" />
+            <path d="M16.93 10H20a2 2 0 0 1 0 4H2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tv.rs b/packages/yew/src/tv.rs
new file mode 100644
index 0000000..2cc3ae5
--- /dev/null
+++ b/packages/yew/src/tv.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TvProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Tv(props: &TvProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="15" x="2" y="7" rx="2" ry="2" />
+            <polyline points="17 2 12 7 7 2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tv_minimal.rs b/packages/yew/src/tv_minimal.rs
new file mode 100644
index 0000000..8d45bd0
--- /dev/null
+++ b/packages/yew/src/tv_minimal.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TvMinimalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TvMinimal(props: &TvMinimalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M7 21h10" />
+            <rect width="20" height="14" x="2" y="3" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/tv_minimal_play.rs b/packages/yew/src/tv_minimal_play.rs
new file mode 100644
index 0000000..63f4c03
--- /dev/null
+++ b/packages/yew/src/tv_minimal_play.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TvMinimalPlayProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TvMinimalPlay(props: &TvMinimalPlayProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M10 7.75a.75.75 0 0 1 1.142-.638l3.664 2.249a.75.75 0 0 1 0 1.278l-3.664 2.25a.75.75 0 0 1-1.142-.64z"
+            />
+            <path d="M7 21h10" />
+            <rect width="20" height="14" x="2" y="3" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/twitch.rs b/packages/yew/src/twitch.rs
new file mode 100644
index 0000000..cc5e8f1
--- /dev/null
+++ b/packages/yew/src/twitch.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TwitchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Twitch(props: &TwitchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 2H3v16h5v4l4-4h5l4-4V2zm-10 9V7m5 4V7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/twitter.rs b/packages/yew/src/twitter.rs
new file mode 100644
index 0000000..3c7db6e
--- /dev/null
+++ b/packages/yew/src/twitter.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TwitterProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Twitter(props: &TwitterProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M22 4s-.7 2.1-2 3.4c1.6 10-9.4 17.3-18 11.6 2.2.1 4.4-.6 6-2C3 15.5.5 9.6 3 5c2.2 2.6 5.6 4.1 9 4-.9-4.2 4-6.6 7-3.8 1.1 0 3-1.2 3-1.2z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/type.rs b/packages/yew/src/type.rs
new file mode 100644
index 0000000..e9eb7fd
--- /dev/null
+++ b/packages/yew/src/type.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TypeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Type(props: &TypeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <polyline points="4 7 4 4 20 4 20 7" />
+            <line x1="9" x2="15" y1="20" y2="20" />
+            <line x1="12" x2="12" y1="4" y2="20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/type_outline.rs b/packages/yew/src/type_outline.rs
new file mode 100644
index 0000000..cd169d5
--- /dev/null
+++ b/packages/yew/src/type_outline.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct TypeOutlineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn TypeOutline(props: &TypeOutlineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M14 16.5a.5.5 0 0 0 .5.5h.5a2 2 0 0 1 0 4H9a2 2 0 0 1 0-4h.5a.5.5 0 0 0 .5-.5v-9a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5V8a2 2 0 0 1-4 0V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v3a2 2 0 0 1-4 0v-.5a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/umbrella.rs b/packages/yew/src/umbrella.rs
new file mode 100644
index 0000000..9628ec8
--- /dev/null
+++ b/packages/yew/src/umbrella.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UmbrellaProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Umbrella(props: &UmbrellaProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M22 12a10.06 10.06 1 0 0-20 0Z" />
+            <path d="M12 12v8a2 2 0 0 0 4 0" />
+            <path d="M12 2v1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/umbrella_off.rs b/packages/yew/src/umbrella_off.rs
new file mode 100644
index 0000000..0952d58
--- /dev/null
+++ b/packages/yew/src/umbrella_off.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UmbrellaOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UmbrellaOff(props: &UmbrellaOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v1" />
+            <path d="M15.5 21a1.85 1.85 0 0 1-3.5-1v-8H2a10 10 0 0 1 3.428-6.575" />
+            <path d="M17.5 12H22A10 10 0 0 0 9.004 3.455" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/underline.rs b/packages/yew/src/underline.rs
new file mode 100644
index 0000000..4859984
--- /dev/null
+++ b/packages/yew/src/underline.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UnderlineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Underline(props: &UnderlineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M6 4v6a6 6 0 0 0 12 0V4" />
+            <line x1="4" x2="20" y1="20" y2="20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/undo.rs b/packages/yew/src/undo.rs
new file mode 100644
index 0000000..79e972c
--- /dev/null
+++ b/packages/yew/src/undo.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UndoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Undo(props: &UndoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 7v6h6" />
+            <path d="M21 17a9 9 0 0 0-9-9 9 9 0 0 0-6 2.3L3 13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/undo_2.rs b/packages/yew/src/undo_2.rs
new file mode 100644
index 0000000..78b2a26
--- /dev/null
+++ b/packages/yew/src/undo_2.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Undo2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Undo2(props: &Undo2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M9 14 4 9l5-5" />
+            <path d="M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5a5.5 5.5 0 0 1-5.5 5.5H11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/undo_dot.rs b/packages/yew/src/undo_dot.rs
new file mode 100644
index 0000000..32ba2a8
--- /dev/null
+++ b/packages/yew/src/undo_dot.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UndoDotProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UndoDot(props: &UndoDotProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 17a9 9 0 0 0-15-6.7L3 13" />
+            <path d="M3 7v6h6" />
+            <circle cx="12" cy="17" r="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/unfold_horizontal.rs b/packages/yew/src/unfold_horizontal.rs
new file mode 100644
index 0000000..c2f3bfd
--- /dev/null
+++ b/packages/yew/src/unfold_horizontal.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UnfoldHorizontalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UnfoldHorizontal(props: &UnfoldHorizontalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 12h6" />
+            <path d="M8 12H2" />
+            <path d="M12 2v2" />
+            <path d="M12 8v2" />
+            <path d="M12 14v2" />
+            <path d="M12 20v2" />
+            <path d="m19 15 3-3-3-3" />
+            <path d="m5 9-3 3 3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/unfold_vertical.rs b/packages/yew/src/unfold_vertical.rs
new file mode 100644
index 0000000..ace0872
--- /dev/null
+++ b/packages/yew/src/unfold_vertical.rs
@@ -0,0 +1,51 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UnfoldVerticalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UnfoldVertical(props: &UnfoldVerticalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 22v-6" />
+            <path d="M12 8V2" />
+            <path d="M4 12H2" />
+            <path d="M10 12H8" />
+            <path d="M16 12h-2" />
+            <path d="M22 12h-2" />
+            <path d="m15 19-3 3-3-3" />
+            <path d="m15 5-3-3-3 3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/ungroup.rs b/packages/yew/src/ungroup.rs
new file mode 100644
index 0000000..b7eb784
--- /dev/null
+++ b/packages/yew/src/ungroup.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UngroupProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Ungroup(props: &UngroupProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="6" x="5" y="4" rx="1" />
+            <rect width="8" height="6" x="11" y="14" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/university.rs b/packages/yew/src/university.rs
new file mode 100644
index 0000000..fe808ad
--- /dev/null
+++ b/packages/yew/src/university.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UniversityProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn University(props: &UniversityProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="10" r="1" />
+            <path d="M22 20V8h-4l-6-4-6 4H2v12a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2" />
+            <path d="M6 17v.01" />
+            <path d="M6 13v.01" />
+            <path d="M18 17v.01" />
+            <path d="M18 13v.01" />
+            <path d="M14 22v-5a2 2 0 0 0-2-2a2 2 0 0 0-2 2v5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/unlink.rs b/packages/yew/src/unlink.rs
new file mode 100644
index 0000000..53b5551
--- /dev/null
+++ b/packages/yew/src/unlink.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UnlinkProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Unlink(props: &UnlinkProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m18.84 12.25 1.72-1.71h-.02a5.004 5.004 0 0 0-.12-7.07 5.006 5.006 0 0 0-6.95 0l-1.72 1.71"
+            />
+            <path
+                d="m5.17 11.75-1.71 1.71a5.004 5.004 0 0 0 .12 7.07 5.006 5.006 0 0 0 6.95 0l1.71-1.71"
+            />
+            <line x1="8" x2="8" y1="2" y2="5" />
+            <line x1="2" x2="5" y1="8" y2="8" />
+            <line x1="16" x2="16" y1="19" y2="22" />
+            <line x1="19" x2="22" y1="16" y2="16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/unlink_2.rs b/packages/yew/src/unlink_2.rs
new file mode 100644
index 0000000..73ecf80
--- /dev/null
+++ b/packages/yew/src/unlink_2.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Unlink2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Unlink2(props: &Unlink2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 7h2a5 5 0 0 1 0 10h-2m-6 0H7A5 5 0 0 1 7 7h2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/unplug.rs b/packages/yew/src/unplug.rs
new file mode 100644
index 0000000..cc3c921
--- /dev/null
+++ b/packages/yew/src/unplug.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UnplugProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Unplug(props: &UnplugProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 5 3-3" />
+            <path d="m2 22 3-3" />
+            <path d="M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z" />
+            <path d="M7.5 13.5 10 11" />
+            <path d="M10.5 16.5 13 14" />
+            <path d="m12 6 6 6 2.3-2.3a2.4 2.4 0 0 0 0-3.4l-2.6-2.6a2.4 2.4 0 0 0-3.4 0Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/upload.rs b/packages/yew/src/upload.rs
new file mode 100644
index 0000000..73d469c
--- /dev/null
+++ b/packages/yew/src/upload.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UploadProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Upload(props: &UploadProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+            <polyline points="17 8 12 3 7 8" />
+            <line x1="12" x2="12" y1="3" y2="15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/usb.rs b/packages/yew/src/usb.rs
new file mode 100644
index 0000000..d4d206a
--- /dev/null
+++ b/packages/yew/src/usb.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UsbProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Usb(props: &UsbProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="10" cy="7" r="1" />
+            <circle cx="4" cy="20" r="1" />
+            <path d="M4.7 19.3 19 5" />
+            <path d="m21 3-3 1 2 2Z" />
+            <path d="M9.26 7.68 5 12l2 5" />
+            <path d="m10 14 5 2 3.5-3.5" />
+            <path d="m18 12 1-1 1 1-1 1Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user.rs b/packages/yew/src/user.rs
new file mode 100644
index 0000000..fcfa2bc
--- /dev/null
+++ b/packages/yew/src/user.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn User(props: &UserProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M19 21v-2a4 4 0 0 0-4-4H9a4 4 0 0 0-4 4v2" />
+            <circle cx="12" cy="7" r="4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_check.rs b/packages/yew/src/user_check.rs
new file mode 100644
index 0000000..12b62b4
--- /dev/null
+++ b/packages/yew/src/user_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserCheck(props: &UserCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2" />
+            <circle cx="9" cy="7" r="4" />
+            <polyline points="16 11 18 13 22 9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_cog.rs b/packages/yew/src/user_cog.rs
new file mode 100644
index 0000000..8ec2b94
--- /dev/null
+++ b/packages/yew/src/user_cog.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserCog(props: &UserCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="18" cy="15" r="3" />
+            <circle cx="9" cy="7" r="4" />
+            <path d="M10 15H6a4 4 0 0 0-4 4v2" />
+            <path d="m21.7 16.4-.9-.3" />
+            <path d="m15.2 13.9-.9-.3" />
+            <path d="m16.6 18.7.3-.9" />
+            <path d="m19.1 12.2.3-.9" />
+            <path d="m19.6 18.7-.4-1" />
+            <path d="m16.8 12.3-.4-1" />
+            <path d="m14.3 16.6 1-.4" />
+            <path d="m20.7 13.8 1-.4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_minus.rs b/packages/yew/src/user_minus.rs
new file mode 100644
index 0000000..bd7b8e3
--- /dev/null
+++ b/packages/yew/src/user_minus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserMinus(props: &UserMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2" />
+            <circle cx="9" cy="7" r="4" />
+            <line x1="22" x2="16" y1="11" y2="11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_pen.rs b/packages/yew/src/user_pen.rs
new file mode 100644
index 0000000..3f7d1ef
--- /dev/null
+++ b/packages/yew/src/user_pen.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserPenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserPen(props: &UserPenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.5 15H7a4 4 0 0 0-4 4v2" />
+            <path
+                d="M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"
+            />
+            <circle cx="10" cy="7" r="4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_plus.rs b/packages/yew/src/user_plus.rs
new file mode 100644
index 0000000..a8bbe43
--- /dev/null
+++ b/packages/yew/src/user_plus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserPlus(props: &UserPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2" />
+            <circle cx="9" cy="7" r="4" />
+            <line x1="19" x2="19" y1="8" y2="14" />
+            <line x1="22" x2="16" y1="11" y2="11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_round.rs b/packages/yew/src/user_round.rs
new file mode 100644
index 0000000..fee2b65
--- /dev/null
+++ b/packages/yew/src/user_round.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserRoundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserRound(props: &UserRoundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="8" r="5" />
+            <path d="M20 21a8 8 0 0 0-16 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_round_check.rs b/packages/yew/src/user_round_check.rs
new file mode 100644
index 0000000..d83b466
--- /dev/null
+++ b/packages/yew/src/user_round_check.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserRoundCheckProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserRoundCheck(props: &UserRoundCheckProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 13.292-6" />
+            <circle cx="10" cy="8" r="5" />
+            <path d="m16 19 2 2 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_round_cog.rs b/packages/yew/src/user_round_cog.rs
new file mode 100644
index 0000000..1ebf325
--- /dev/null
+++ b/packages/yew/src/user_round_cog.rs
@@ -0,0 +1,54 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserRoundCogProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserRoundCog(props: &UserRoundCogProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 10.434-7.62" />
+            <circle cx="10" cy="8" r="5" />
+            <circle cx="18" cy="18" r="3" />
+            <path d="m19.5 14.3-.4.9" />
+            <path d="m16.9 20.8-.4.9" />
+            <path d="m21.7 19.5-.9-.4" />
+            <path d="m15.2 16.9-.9-.4" />
+            <path d="m21.7 16.5-.9.4" />
+            <path d="m15.2 19.1-.9.4" />
+            <path d="m19.5 21.7-.4-.9" />
+            <path d="m16.9 15.2-.4-.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_round_minus.rs b/packages/yew/src/user_round_minus.rs
new file mode 100644
index 0000000..85c0d14
--- /dev/null
+++ b/packages/yew/src/user_round_minus.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserRoundMinusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserRoundMinus(props: &UserRoundMinusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 13.292-6" />
+            <circle cx="10" cy="8" r="5" />
+            <path d="M22 19h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_round_pen.rs b/packages/yew/src/user_round_pen.rs
new file mode 100644
index 0000000..17458cf
--- /dev/null
+++ b/packages/yew/src/user_round_pen.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserRoundPenProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserRoundPen(props: &UserRoundPenProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 10.821-7.487" />
+            <path
+                d="M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"
+            />
+            <circle cx="10" cy="8" r="5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_round_plus.rs b/packages/yew/src/user_round_plus.rs
new file mode 100644
index 0000000..c5b64ba
--- /dev/null
+++ b/packages/yew/src/user_round_plus.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserRoundPlusProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserRoundPlus(props: &UserRoundPlusProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 13.292-6" />
+            <circle cx="10" cy="8" r="5" />
+            <path d="M19 16v6" />
+            <path d="M22 19h-6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_round_search.rs b/packages/yew/src/user_round_search.rs
new file mode 100644
index 0000000..e3c1e26
--- /dev/null
+++ b/packages/yew/src/user_round_search.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserRoundSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserRoundSearch(props: &UserRoundSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="10" cy="8" r="5" />
+            <path d="M2 21a8 8 0 0 1 10.434-7.62" />
+            <circle cx="18" cy="18" r="3" />
+            <path d="m22 22-1.9-1.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_round_x.rs b/packages/yew/src/user_round_x.rs
new file mode 100644
index 0000000..fb6a6a2
--- /dev/null
+++ b/packages/yew/src/user_round_x.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserRoundXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserRoundX(props: &UserRoundXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 21a8 8 0 0 1 11.873-7" />
+            <circle cx="10" cy="8" r="5" />
+            <path d="m17 17 5 5" />
+            <path d="m22 17-5 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_search.rs b/packages/yew/src/user_search.rs
new file mode 100644
index 0000000..2e41e17
--- /dev/null
+++ b/packages/yew/src/user_search.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserSearchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserSearch(props: &UserSearchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="10" cy="7" r="4" />
+            <path d="M10.3 15H7a4 4 0 0 0-4 4v2" />
+            <circle cx="17" cy="17" r="3" />
+            <path d="m21 21-1.9-1.9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/user_x.rs b/packages/yew/src/user_x.rs
new file mode 100644
index 0000000..967a2c7
--- /dev/null
+++ b/packages/yew/src/user_x.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UserXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UserX(props: &UserXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2" />
+            <circle cx="9" cy="7" r="4" />
+            <line x1="17" x2="22" y1="8" y2="13" />
+            <line x1="22" x2="17" y1="8" y2="13" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/users.rs b/packages/yew/src/users.rs
new file mode 100644
index 0000000..2d56519
--- /dev/null
+++ b/packages/yew/src/users.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UsersProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Users(props: &UsersProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2" />
+            <circle cx="9" cy="7" r="4" />
+            <path d="M22 21v-2a4 4 0 0 0-3-3.87" />
+            <path d="M16 3.13a4 4 0 0 1 0 7.75" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/users_round.rs b/packages/yew/src/users_round.rs
new file mode 100644
index 0000000..2f33735
--- /dev/null
+++ b/packages/yew/src/users_round.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UsersRoundProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UsersRound(props: &UsersRoundProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 21a8 8 0 0 0-16 0" />
+            <circle cx="10" cy="8" r="5" />
+            <path d="M22 20c0-3.37-2-6.5-4-8a5 5 0 0 0-.45-8.3" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/utensils.rs b/packages/yew/src/utensils.rs
new file mode 100644
index 0000000..d79ed26
--- /dev/null
+++ b/packages/yew/src/utensils.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UtensilsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Utensils(props: &UtensilsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 2v7c0 1.1.9 2 2 2h4a2 2 0 0 0 2-2V2" />
+            <path d="M7 2v20" />
+            <path d="M21 15V2a5 5 0 0 0-5 5v6c0 1.1.9 2 2 2h3Zm0 0v7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/utensils_crossed.rs b/packages/yew/src/utensils_crossed.rs
new file mode 100644
index 0000000..1a3924e
--- /dev/null
+++ b/packages/yew/src/utensils_crossed.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UtensilsCrossedProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UtensilsCrossed(props: &UtensilsCrossedProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 2-2.3 2.3a3 3 0 0 0 0 4.2l1.8 1.8a3 3 0 0 0 4.2 0L22 8" />
+            <path d="M15 15 3.3 3.3a4.2 4.2 0 0 0 0 6l7.3 7.3c.7.7 2 .7 2.8 0L15 15Zm0 0 7 7" />
+            <path d="m2.1 21.8 6.4-6.3" />
+            <path d="m19 5-7 7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/utility_pole.rs b/packages/yew/src/utility_pole.rs
new file mode 100644
index 0000000..6401571
--- /dev/null
+++ b/packages/yew/src/utility_pole.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct UtilityPoleProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn UtilityPole(props: &UtilityPoleProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 2v20" />
+            <path d="M2 5h20" />
+            <path d="M3 3v2" />
+            <path d="M7 3v2" />
+            <path d="M17 3v2" />
+            <path d="M21 3v2" />
+            <path d="m19 5-7 7-7-7" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/variable.rs b/packages/yew/src/variable.rs
new file mode 100644
index 0000000..e4dc828
--- /dev/null
+++ b/packages/yew/src/variable.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VariableProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Variable(props: &VariableProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 21s-4-3-4-9 4-9 4-9" />
+            <path d="M16 3s4 3 4 9-4 9-4 9" />
+            <line x1="15" x2="9" y1="9" y2="15" />
+            <line x1="9" x2="15" y1="9" y2="15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/vault.rs b/packages/yew/src/vault.rs
new file mode 100644
index 0000000..59db4cf
--- /dev/null
+++ b/packages/yew/src/vault.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VaultProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Vault(props: &VaultProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <circle cx="7.5" cy="7.5" r=".5" fill="currentColor" />
+            <path d="m7.9 7.9 2.7 2.7" />
+            <circle cx="16.5" cy="7.5" r=".5" fill="currentColor" />
+            <path d="m13.4 10.6 2.7-2.7" />
+            <circle cx="7.5" cy="16.5" r=".5" fill="currentColor" />
+            <path d="m7.9 16.1 2.7-2.7" />
+            <circle cx="16.5" cy="16.5" r=".5" fill="currentColor" />
+            <path d="m13.4 13.4 2.7 2.7" />
+            <circle cx="12" cy="12" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/vegan.rs b/packages/yew/src/vegan.rs
new file mode 100644
index 0000000..1f5d38c
--- /dev/null
+++ b/packages/yew/src/vegan.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VeganProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Vegan(props: &VeganProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 8q6 0 6-6-6 0-6 6" />
+            <path d="M17.41 3.59a10 10 0 1 0 3 3" />
+            <path d="M2 2a26.6 26.6 0 0 1 10 20c.9-6.82 1.5-9.5 4-14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/venetian_mask.rs b/packages/yew/src/venetian_mask.rs
new file mode 100644
index 0000000..23c1095
--- /dev/null
+++ b/packages/yew/src/venetian_mask.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VenetianMaskProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn VenetianMask(props: &VenetianMaskProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 12a5 5 0 0 0 5 5 8 8 0 0 1 5 2 8 8 0 0 1 5-2 5 5 0 0 0 5-5V7h-5a8 8 0 0 0-5 2 8 8 0 0 0-5-2H2Z"
+            />
+            <path d="M6 11c1.5 0 3 .5 3 2-2 0-3 0-3-2Z" />
+            <path d="M18 11c-1.5 0-3 .5-3 2 2 0 3 0 3-2Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/vibrate.rs b/packages/yew/src/vibrate.rs
new file mode 100644
index 0000000..791acd0
--- /dev/null
+++ b/packages/yew/src/vibrate.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VibrateProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Vibrate(props: &VibrateProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 8 2 2-2 2 2 2-2 2" />
+            <path d="m22 8-2 2 2 2-2 2 2 2" />
+            <rect width="8" height="14" x="8" y="5" rx="1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/vibrate_off.rs b/packages/yew/src/vibrate_off.rs
new file mode 100644
index 0000000..1db0f16
--- /dev/null
+++ b/packages/yew/src/vibrate_off.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VibrateOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn VibrateOff(props: &VibrateOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 8 2 2-2 2 2 2-2 2" />
+            <path d="m22 8-2 2 2 2-2 2 2 2" />
+            <path d="M8 8v10c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2" />
+            <path d="M16 10.34V6c0-.55-.45-1-1-1h-4.34" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/video.rs b/packages/yew/src/video.rs
new file mode 100644
index 0000000..a4709df
--- /dev/null
+++ b/packages/yew/src/video.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VideoProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Video(props: &VideoProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m16 13 5.223 3.482a.5.5 0 0 0 .777-.416V7.87a.5.5 0 0 0-.752-.432L16 10.5" />
+            <rect x="2" y="6" width="14" height="12" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/video_off.rs b/packages/yew/src/video_off.rs
new file mode 100644
index 0000000..ad86bba
--- /dev/null
+++ b/packages/yew/src/video_off.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VideoOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn VideoOff(props: &VideoOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.66 6H14a2 2 0 0 1 2 2v2.5l5.248-3.062A.5.5 0 0 1 22 7.87v8.196" />
+            <path d="M16 16a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h2" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/videotape.rs b/packages/yew/src/videotape.rs
new file mode 100644
index 0000000..cf6dab2
--- /dev/null
+++ b/packages/yew/src/videotape.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VideotapeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Videotape(props: &VideotapeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="20" height="16" x="2" y="4" rx="2" />
+            <path d="M2 8h20" />
+            <circle cx="8" cy="14" r="2" />
+            <path d="M8 12h8" />
+            <circle cx="16" cy="14" r="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/view.rs b/packages/yew/src/view.rs
new file mode 100644
index 0000000..3f5e6f6
--- /dev/null
+++ b/packages/yew/src/view.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ViewProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn View(props: &ViewProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M21 17v2a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-2" />
+            <path d="M21 7V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2" />
+            <circle cx="12" cy="12" r="1" />
+            <path
+                d="M18.944 12.33a1 1 0 0 0 0-.66 7.5 7.5 0 0 0-13.888 0 1 1 0 0 0 0 .66 7.5 7.5 0 0 0 13.888 0"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/voicemail.rs b/packages/yew/src/voicemail.rs
new file mode 100644
index 0000000..e711c8d
--- /dev/null
+++ b/packages/yew/src/voicemail.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VoicemailProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Voicemail(props: &VoicemailProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="6" cy="12" r="4" />
+            <circle cx="18" cy="12" r="4" />
+            <line x1="6" x2="18" y1="16" y2="16" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/volleyball.rs b/packages/yew/src/volleyball.rs
new file mode 100644
index 0000000..f09eb3a
--- /dev/null
+++ b/packages/yew/src/volleyball.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VolleyballProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Volleyball(props: &VolleyballProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M11.1 7.1a16.55 16.55 0 0 1 10.9 4" />
+            <path d="M12 12a12.6 12.6 0 0 1-8.7 5" />
+            <path d="M16.8 13.6a16.55 16.55 0 0 1-9 7.5" />
+            <path d="M20.7 17a12.8 12.8 0 0 0-8.7-5 13.3 13.3 0 0 1 0-10" />
+            <path d="M6.3 3.8a16.55 16.55 0 0 0 1.9 11.5" />
+            <circle cx="12" cy="12" r="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/volume.rs b/packages/yew/src/volume.rs
new file mode 100644
index 0000000..b0b5c0b
--- /dev/null
+++ b/packages/yew/src/volume.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VolumeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Volume(props: &VolumeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/volume_1.rs b/packages/yew/src/volume_1.rs
new file mode 100644
index 0000000..1f6b32e
--- /dev/null
+++ b/packages/yew/src/volume_1.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Volume1Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Volume1(props: &Volume1Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"
+            />
+            <path d="M16 9a5 5 0 0 1 0 6" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/volume_2.rs b/packages/yew/src/volume_2.rs
new file mode 100644
index 0000000..db4b88c
--- /dev/null
+++ b/packages/yew/src/volume_2.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct Volume2Props {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Volume2(props: &Volume2Props) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"
+            />
+            <path d="M16 9a5 5 0 0 1 0 6" />
+            <path d="M19.364 18.364a9 9 0 0 0 0-12.728" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/volume_off.rs b/packages/yew/src/volume_off.rs
new file mode 100644
index 0000000..67d921f
--- /dev/null
+++ b/packages/yew/src/volume_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VolumeOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn VolumeOff(props: &VolumeOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M16 9a5 5 0 0 1 .95 2.293" />
+            <path d="M19.364 5.636a9 9 0 0 1 1.889 9.96" />
+            <path d="m2 2 20 20" />
+            <path
+                d="m7 7-.587.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298V11"
+            />
+            <path d="M9.828 4.172A.686.686 0 0 1 11 4.657v.686" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/volume_x.rs b/packages/yew/src/volume_x.rs
new file mode 100644
index 0000000..d316c85
--- /dev/null
+++ b/packages/yew/src/volume_x.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VolumeXProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn VolumeX(props: &VolumeXProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"
+            />
+            <line x1="22" x2="16" y1="9" y2="15" />
+            <line x1="16" x2="22" y1="9" y2="15" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/vote.rs b/packages/yew/src/vote.rs
new file mode 100644
index 0000000..e7fd29c
--- /dev/null
+++ b/packages/yew/src/vote.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct VoteProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Vote(props: &VoteProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m9 12 2 2 4-4" />
+            <path d="M5 7c0-1.1.9-2 2-2h10a2 2 0 0 1 2 2v12H5V7Z" />
+            <path d="M22 19H2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wallet.rs b/packages/yew/src/wallet.rs
new file mode 100644
index 0000000..69034f9
--- /dev/null
+++ b/packages/yew/src/wallet.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WalletProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Wallet(props: &WalletProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M19 7V4a1 1 0 0 0-1-1H5a2 2 0 0 0 0 4h15a1 1 0 0 1 1 1v4h-3a2 2 0 0 0 0 4h3a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1"
+            />
+            <path d="M3 5v14a2 2 0 0 0 2 2h15a1 1 0 0 0 1-1v-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wallet_cards.rs b/packages/yew/src/wallet_cards.rs
new file mode 100644
index 0000000..591e315
--- /dev/null
+++ b/packages/yew/src/wallet_cards.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WalletCardsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WalletCards(props: &WalletCardsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="18" height="18" x="3" y="3" rx="2" />
+            <path d="M3 9a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2" />
+            <path
+                d="M3 11h3c.8 0 1.6.3 2.1.9l1.1.9c1.6 1.6 4.1 1.6 5.7 0l1.1-.9c.5-.5 1.3-.9 2.1-.9H21"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wallet_minimal.rs b/packages/yew/src/wallet_minimal.rs
new file mode 100644
index 0000000..038e888
--- /dev/null
+++ b/packages/yew/src/wallet_minimal.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WalletMinimalProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WalletMinimal(props: &WalletMinimalProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 14h.01" />
+            <path d="M7 7h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wallpaper.rs b/packages/yew/src/wallpaper.rs
new file mode 100644
index 0000000..b9d8954
--- /dev/null
+++ b/packages/yew/src/wallpaper.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WallpaperProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Wallpaper(props: &WallpaperProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="8" cy="9" r="2" />
+            <path
+                d="m9 17 6.1-6.1a2 2 0 0 1 2.81.01L22 15V5a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2"
+            />
+            <path d="M8 21h8" />
+            <path d="M12 17v4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wand.rs b/packages/yew/src/wand.rs
new file mode 100644
index 0000000..9541dee
--- /dev/null
+++ b/packages/yew/src/wand.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WandProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Wand(props: &WandProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M15 4V2" />
+            <path d="M15 16v-2" />
+            <path d="M8 9h2" />
+            <path d="M20 9h2" />
+            <path d="M17.8 11.8 19 13" />
+            <path d="M15 9h.01" />
+            <path d="M17.8 6.2 19 5" />
+            <path d="m3 21 9-9" />
+            <path d="M12.2 6.2 11 5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wand_sparkles.rs b/packages/yew/src/wand_sparkles.rs
new file mode 100644
index 0000000..2665489
--- /dev/null
+++ b/packages/yew/src/wand_sparkles.rs
@@ -0,0 +1,53 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WandSparklesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WandSparkles(props: &WandSparklesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="m21.64 3.64-1.28-1.28a1.21 1.21 0 0 0-1.72 0L2.36 18.64a1.21 1.21 0 0 0 0 1.72l1.28 1.28a1.2 1.2 0 0 0 1.72 0L21.64 5.36a1.2 1.2 0 0 0 0-1.72"
+            />
+            <path d="m14 7 3 3" />
+            <path d="M5 6v4" />
+            <path d="M19 14v4" />
+            <path d="M10 2v2" />
+            <path d="M7 8H3" />
+            <path d="M21 16h-4" />
+            <path d="M11 3H9" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/warehouse.rs b/packages/yew/src/warehouse.rs
new file mode 100644
index 0000000..503309c
--- /dev/null
+++ b/packages/yew/src/warehouse.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WarehouseProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Warehouse(props: &WarehouseProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M22 8.35V20a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8.35A2 2 0 0 1 3.26 6.5l8-3.2a2 2 0 0 1 1.48 0l8 3.2A2 2 0 0 1 22 8.35Z"
+            />
+            <path d="M6 18h12" />
+            <path d="M6 14h12" />
+            <rect width="12" height="12" x="6" y="10" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/washing_machine.rs b/packages/yew/src/washing_machine.rs
new file mode 100644
index 0000000..64dcd48
--- /dev/null
+++ b/packages/yew/src/washing_machine.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WashingMachineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WashingMachine(props: &WashingMachineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M3 6h3" />
+            <path d="M17 6h.01" />
+            <rect width="18" height="20" x="3" y="2" rx="2" />
+            <circle cx="12" cy="13" r="5" />
+            <path d="M12 18a2.5 2.5 0 0 0 0-5 2.5 2.5 0 0 1 0-5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/watch.rs b/packages/yew/src/watch.rs
new file mode 100644
index 0000000..38b84fd
--- /dev/null
+++ b/packages/yew/src/watch.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WatchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Watch(props: &WatchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="12" r="6" />
+            <polyline points="12 10 12 12 13 13" />
+            <path d="m16.13 7.66-.81-4.05a2 2 0 0 0-2-1.61h-2.68a2 2 0 0 0-2 1.61l-.78 4.05" />
+            <path d="m7.88 16.36.8 4a2 2 0 0 0 2 1.61h2.72a2 2 0 0 0 2-1.61l.81-4.05" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/waves.rs b/packages/yew/src/waves.rs
new file mode 100644
index 0000000..7e55296
--- /dev/null
+++ b/packages/yew/src/waves.rs
@@ -0,0 +1,52 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WavesProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Waves(props: &WavesProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2 6c.6.5 1.2 1 2.5 1C7 7 7 5 9.5 5c2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"
+            />
+            <path
+                d="M2 12c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"
+            />
+            <path
+                d="M2 18c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/waypoints.rs b/packages/yew/src/waypoints.rs
new file mode 100644
index 0000000..4909332
--- /dev/null
+++ b/packages/yew/src/waypoints.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WaypointsProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Waypoints(props: &WaypointsProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="4.5" r="2.5" />
+            <path d="m10.2 6.3-3.9 3.9" />
+            <circle cx="4.5" cy="12" r="2.5" />
+            <path d="M7 12h10" />
+            <circle cx="19.5" cy="12" r="2.5" />
+            <path d="m13.8 17.7 3.9-3.9" />
+            <circle cx="12" cy="19.5" r="2.5" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/webcam.rs b/packages/yew/src/webcam.rs
new file mode 100644
index 0000000..f761214
--- /dev/null
+++ b/packages/yew/src/webcam.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WebcamProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Webcam(props: &WebcamProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="10" r="8" />
+            <circle cx="12" cy="10" r="3" />
+            <path d="M7 22h10" />
+            <path d="M12 22v-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/webhook.rs b/packages/yew/src/webhook.rs
new file mode 100644
index 0000000..1d2e8ed
--- /dev/null
+++ b/packages/yew/src/webhook.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WebhookProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Webhook(props: &WebhookProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 16.98h-5.99c-1.1 0-1.95.94-2.48 1.9A4 4 0 0 1 2 17c.01-.7.2-1.4.57-2" />
+            <path d="m6 17 3.13-5.78c.53-.97.1-2.18-.5-3.1a4 4 0 1 1 6.89-4.06" />
+            <path d="m12 6 3.13 5.73C15.66 12.7 16.9 13 18 13a4 4 0 0 1 0 8" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/webhook_off.rs b/packages/yew/src/webhook_off.rs
new file mode 100644
index 0000000..b304670
--- /dev/null
+++ b/packages/yew/src/webhook_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WebhookOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WebhookOff(props: &WebhookOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M17 17h-5c-1.09-.02-1.94.92-2.5 1.9A3 3 0 1 1 2.57 15" />
+            <path d="M9 3.4a4 4 0 0 1 6.52.66" />
+            <path d="m6 17 3.1-5.8a2.5 2.5 0 0 0 .057-2.05" />
+            <path d="M20.3 20.3a4 4 0 0 1-2.3.7" />
+            <path d="M18.6 13a4 4 0 0 1 3.357 3.414" />
+            <path d="m12 6 .6 1" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/weight.rs b/packages/yew/src/weight.rs
new file mode 100644
index 0000000..6fa7521
--- /dev/null
+++ b/packages/yew/src/weight.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WeightProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Weight(props: &WeightProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="12" cy="5" r="3" />
+            <path
+                d="M6.5 8a2 2 0 0 0-1.905 1.46L2.1 18.5A2 2 0 0 0 4 21h16a2 2 0 0 0 1.925-2.54L19.4 9.5A2 2 0 0 0 17.48 8Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wheat.rs b/packages/yew/src/wheat.rs
new file mode 100644
index 0000000..d65d56b
--- /dev/null
+++ b/packages/yew/src/wheat.rs
@@ -0,0 +1,63 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WheatProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Wheat(props: &WheatProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M2 22 16 8" />
+            <path
+                d="M3.47 12.53 5 11l1.53 1.53a3.5 3.5 0 0 1 0 4.94L5 19l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"
+            />
+            <path
+                d="M7.47 8.53 9 7l1.53 1.53a3.5 3.5 0 0 1 0 4.94L9 15l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"
+            />
+            <path
+                d="M11.47 4.53 13 3l1.53 1.53a3.5 3.5 0 0 1 0 4.94L13 11l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"
+            />
+            <path d="M20 2h2v2a4 4 0 0 1-4 4h-2V6a4 4 0 0 1 4-4Z" />
+            <path
+                d="M11.47 17.47 13 19l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L5 19l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"
+            />
+            <path
+                d="M15.47 13.47 17 15l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L9 15l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"
+            />
+            <path
+                d="M19.47 9.47 21 11l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L13 11l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wheat_off.rs b/packages/yew/src/wheat_off.rs
new file mode 100644
index 0000000..8a3cfa1
--- /dev/null
+++ b/packages/yew/src/wheat_off.rs
@@ -0,0 +1,57 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WheatOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WheatOff(props: &WheatOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m2 22 10-10" />
+            <path d="m16 8-1.17 1.17" />
+            <path
+                d="M3.47 12.53 5 11l1.53 1.53a3.5 3.5 0 0 1 0 4.94L5 19l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"
+            />
+            <path d="m8 8-.53.53a3.5 3.5 0 0 0 0 4.94L9 15l1.53-1.53c.55-.55.88-1.25.98-1.97" />
+            <path d="M10.91 5.26c.15-.26.34-.51.56-.73L13 3l1.53 1.53a3.5 3.5 0 0 1 .28 4.62" />
+            <path d="M20 2h2v2a4 4 0 0 1-4 4h-2V6a4 4 0 0 1 4-4Z" />
+            <path
+                d="M11.47 17.47 13 19l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L5 19l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"
+            />
+            <path d="m16 16-.53.53a3.5 3.5 0 0 1-4.94 0L9 15l1.53-1.53a3.49 3.49 0 0 1 1.97-.98" />
+            <path d="M18.74 13.09c.26-.15.51-.34.73-.56L21 11l-1.53-1.53a3.5 3.5 0 0 0-4.62-.28" />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/whole_word.rs b/packages/yew/src/whole_word.rs
new file mode 100644
index 0000000..7120c48
--- /dev/null
+++ b/packages/yew/src/whole_word.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WholeWordProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WholeWord(props: &WholeWordProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="7" cy="12" r="3" />
+            <path d="M10 9v6" />
+            <circle cx="17" cy="12" r="3" />
+            <path d="M14 7v8" />
+            <path d="M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wifi.rs b/packages/yew/src/wifi.rs
new file mode 100644
index 0000000..f111c53
--- /dev/null
+++ b/packages/yew/src/wifi.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WifiProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Wifi(props: &WifiProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01" />
+            <path d="M2 8.82a15 15 0 0 1 20 0" />
+            <path d="M5 12.859a10 10 0 0 1 14 0" />
+            <path d="M8.5 16.429a5 5 0 0 1 7 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wifi_high.rs b/packages/yew/src/wifi_high.rs
new file mode 100644
index 0000000..f20ce87
--- /dev/null
+++ b/packages/yew/src/wifi_high.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WifiHighProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WifiHigh(props: &WifiHighProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01" />
+            <path d="M5 12.859a10 10 0 0 1 14 0" />
+            <path d="M8.5 16.429a5 5 0 0 1 7 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wifi_low.rs b/packages/yew/src/wifi_low.rs
new file mode 100644
index 0000000..859b284
--- /dev/null
+++ b/packages/yew/src/wifi_low.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WifiLowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WifiLow(props: &WifiLowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01" />
+            <path d="M8.5 16.429a5 5 0 0 1 7 0" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wifi_off.rs b/packages/yew/src/wifi_off.rs
new file mode 100644
index 0000000..0775b28
--- /dev/null
+++ b/packages/yew/src/wifi_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WifiOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WifiOff(props: &WifiOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01" />
+            <path d="M8.5 16.429a5 5 0 0 1 7 0" />
+            <path d="M5 12.859a10 10 0 0 1 5.17-2.69" />
+            <path d="M19 12.859a10 10 0 0 0-2.007-1.523" />
+            <path d="M2 8.82a15 15 0 0 1 4.177-2.643" />
+            <path d="M22 8.82a15 15 0 0 0-11.288-3.764" />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wifi_zero.rs b/packages/yew/src/wifi_zero.rs
new file mode 100644
index 0000000..2951384
--- /dev/null
+++ b/packages/yew/src/wifi_zero.rs
@@ -0,0 +1,44 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WifiZeroProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WifiZero(props: &WifiZeroProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12 20h.01" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wind.rs b/packages/yew/src/wind.rs
new file mode 100644
index 0000000..ff9232e
--- /dev/null
+++ b/packages/yew/src/wind.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WindProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Wind(props: &WindProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M12.8 19.6A2 2 0 1 0 14 16H2" />
+            <path d="M17.5 8a2.5 2.5 0 1 1 2 4H2" />
+            <path d="M9.8 4.4A2 2 0 1 1 11 8H2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wind_arrow_down.rs b/packages/yew/src/wind_arrow_down.rs
new file mode 100644
index 0000000..383a3e9
--- /dev/null
+++ b/packages/yew/src/wind_arrow_down.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WindArrowDownProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WindArrowDown(props: &WindArrowDownProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10 2v8" />
+            <path d="M12.8 21.6A2 2 0 1 0 14 18H2" />
+            <path d="M17.5 10a2.5 2.5 0 1 1 2 4H2" />
+            <path d="m6 6 4 4 4-4" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wine.rs b/packages/yew/src/wine.rs
new file mode 100644
index 0000000..8516409
--- /dev/null
+++ b/packages/yew/src/wine.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WineProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Wine(props: &WineProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 22h8" />
+            <path d="M7 10h10" />
+            <path d="M12 15v7" />
+            <path d="M12 15a5 5 0 0 0 5-5c0-2-.5-4-2-8H9c-1.5 4-2 6-2 8a5 5 0 0 0 5 5Z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wine_off.rs b/packages/yew/src/wine_off.rs
new file mode 100644
index 0000000..e33cad0
--- /dev/null
+++ b/packages/yew/src/wine_off.rs
@@ -0,0 +1,50 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WineOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WineOff(props: &WineOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M8 22h8" />
+            <path d="M7 10h3m7 0h-1.343" />
+            <path d="M12 15v7" />
+            <path
+                d="M7.307 7.307A12.33 12.33 0 0 0 7 10a5 5 0 0 0 7.391 4.391M8.638 2.981C8.75 2.668 8.872 2.34 9 2h6c1.5 4 2 6 2 8 0 .407-.05.809-.145 1.198"
+            />
+            <line x1="2" x2="22" y1="2" y2="22" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/workflow.rs b/packages/yew/src/workflow.rs
new file mode 100644
index 0000000..bb47e28
--- /dev/null
+++ b/packages/yew/src/workflow.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WorkflowProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Workflow(props: &WorkflowProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <rect width="8" height="8" x="3" y="3" rx="2" />
+            <path d="M7 11v4a2 2 0 0 0 2 2h4" />
+            <rect width="8" height="8" x="13" y="13" rx="2" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/worm.rs b/packages/yew/src/worm.rs
new file mode 100644
index 0000000..edabcd1
--- /dev/null
+++ b/packages/yew/src/worm.rs
@@ -0,0 +1,48 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WormProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Worm(props: &WormProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="m19 12-1.5 3" />
+            <path d="M19.63 18.81 22 20" />
+            <path
+                d="M6.47 8.23a1.68 1.68 0 0 1 2.44 1.93l-.64 2.08a6.76 6.76 0 0 0 10.16 7.67l.42-.27a1 1 0 1 0-2.73-4.21l-.42.27a1.76 1.76 0 0 1-2.63-1.99l.64-2.08A6.66 6.66 0 0 0 3.94 3.9l-.7.4a1 1 0 1 0 2.55 4.34z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wrap_text.rs b/packages/yew/src/wrap_text.rs
new file mode 100644
index 0000000..4c965fa
--- /dev/null
+++ b/packages/yew/src/wrap_text.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WrapTextProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn WrapText(props: &WrapTextProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <line x1="3" x2="21" y1="6" y2="6" />
+            <path d="M3 12h15a3 3 0 1 1 0 6h-4" />
+            <polyline points="16 16 14 18 16 20" />
+            <line x1="3" x2="10" y1="18" y2="18" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/wrench.rs b/packages/yew/src/wrench.rs
new file mode 100644
index 0000000..f16173e
--- /dev/null
+++ b/packages/yew/src/wrench.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct WrenchProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Wrench(props: &WrenchProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/x.rs b/packages/yew/src/x.rs
new file mode 100644
index 0000000..162a0a1
--- /dev/null
+++ b/packages/yew/src/x.rs
@@ -0,0 +1,45 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct XProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn X(props: &XProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M18 6 6 18" />
+            <path d="m6 6 12 12" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/youtube.rs b/packages/yew/src/youtube.rs
new file mode 100644
index 0000000..11f4ede
--- /dev/null
+++ b/packages/yew/src/youtube.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct YoutubeProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Youtube(props: &YoutubeProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M2.5 17a24.12 24.12 0 0 1 0-10 2 2 0 0 1 1.4-1.4 49.56 49.56 0 0 1 16.2 0A2 2 0 0 1 21.5 7a24.12 24.12 0 0 1 0 10 2 2 0 0 1-1.4 1.4 49.55 49.55 0 0 1-16.2 0A2 2 0 0 1 2.5 17"
+            />
+            <path d="m10 15 5-3-5-3z" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/zap.rs b/packages/yew/src/zap.rs
new file mode 100644
index 0000000..f8c45a8
--- /dev/null
+++ b/packages/yew/src/zap.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ZapProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn Zap(props: &ZapProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path
+                d="M4 14a1 1 0 0 1-.78-1.63l9.9-10.2a.5.5 0 0 1 .86.46l-1.92 6.02A1 1 0 0 0 13 10h7a1 1 0 0 1 .78 1.63l-9.9 10.2a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14z"
+            />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/zap_off.rs b/packages/yew/src/zap_off.rs
new file mode 100644
index 0000000..b49362f
--- /dev/null
+++ b/packages/yew/src/zap_off.rs
@@ -0,0 +1,49 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ZapOffProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ZapOff(props: &ZapOffProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <path d="M10.513 4.856 13.12 2.17a.5.5 0 0 1 .86.46l-1.377 4.317" />
+            <path d="M15.656 10H20a1 1 0 0 1 .78 1.63l-1.72 1.773" />
+            <path
+                d="M16.273 16.273 10.88 21.83a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14H4a1 1 0 0 1-.78-1.63l4.507-4.643"
+            />
+            <path d="m2 2 20 20" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/zoom_in.rs b/packages/yew/src/zoom_in.rs
new file mode 100644
index 0000000..77b6a42
--- /dev/null
+++ b/packages/yew/src/zoom_in.rs
@@ -0,0 +1,47 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ZoomInProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ZoomIn(props: &ZoomInProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="11" r="8" />
+            <line x1="21" x2="16.65" y1="21" y2="16.65" />
+            <line x1="11" x2="11" y1="8" y2="14" />
+            <line x1="8" x2="14" y1="11" y2="11" />
+        </svg>
+    }
+}
diff --git a/packages/yew/src/zoom_out.rs b/packages/yew/src/zoom_out.rs
new file mode 100644
index 0000000..c88ad91
--- /dev/null
+++ b/packages/yew/src/zoom_out.rs
@@ -0,0 +1,46 @@
+use yew::prelude::*;
+#[derive(PartialEq, Properties)]
+pub struct ZoomOutProps {
+    #[prop_or(24)]
+    pub size: usize,
+    #[prop_or(AttrValue::from("currentColor"))]
+    pub color: AttrValue,
+    #[prop_or(AttrValue::from("none"))]
+    pub fill: AttrValue,
+    #[prop_or(2)]
+    pub stroke_width: usize,
+    #[prop_or(false)]
+    pub absolute_stroke_width: bool,
+    #[prop_or_default]
+    pub class: Classes,
+    #[prop_or_default]
+    pub node_ref: NodeRef,
+}
+#[function_component]
+pub fn ZoomOut(props: &ZoomOutProps) -> Html {
+    let stroke_width = if props.absolute_stroke_width {
+        props.stroke_width * 24 / props.size
+    } else {
+        props.stroke_width
+    };
+    html! {
+        <svg
+            ref={props.node_ref.clone()}
+            class={classes!("lucide", props.class
+        .clone())}
+            xmlns="http://www.w3.org/2000/svg"
+            width={props.size.to_string()}
+            height={props.size.to_string()}
+            viewBox="0 0 24 24"
+            fill={& props.fill}
+            stroke={& props.color}
+            stroke-width={stroke_width.to_string()}
+            stroke-linecap="round"
+            stroke-linejoin="round"
+        >
+            <circle cx="11" cy="11" r="8" />
+            <line x1="21" x2="16.65" y1="21" y2="16.65" />
+            <line x1="8" x2="14" y1="11" y2="11" />
+        </svg>
+    }
+}