diff --git a/Cargo.toml b/Cargo.toml
index b38bb90c5..0cd7d579c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,7 +25,7 @@ default-members = [
 license = "MIT"
 version = "0.2.0"
 edition = "2024"
-rust-version = "1.87"
+rust-version = "1.90"
 repository = "https://github.com/lapce/floem"
 
 [package]
diff --git a/src/animate.rs b/src/animate.rs
index 65c50fccb..375a955a5 100644
--- a/src/animate.rs
+++ b/src/animate.rs
@@ -222,10 +222,10 @@ impl PropCache {
     }
 
     fn remove_prop(&mut self, prop: StylePropRef, idx: u16) {
-        if let imbl::hashmap::Entry::Occupied(mut oe) = self.prop_map.entry(prop) {
-            if let Ok(pos) = oe.get().binary_search(&PropFrameKind::Normal(idx)) {
-                oe.get_mut().remove(pos);
-            }
+        if let imbl::hashmap::Entry::Occupied(mut oe) = self.prop_map.entry(prop)
+            && let Ok(pos) = oe.get().binary_search(&PropFrameKind::Normal(idx))
+        {
+            oe.get_mut().remove(pos);
         }
     }
 
@@ -510,11 +510,11 @@ impl Animation {
     ) -> Self {
         let frame = key_frame(KeyFrame::new(frame_id));
         let frame_style = frame.style.clone();
-        if let Some(f) = self.key_frames.insert(frame_id, frame) {
-            if let KeyFrameStyle::Style(style) = f.style {
-                for prop in style.style_props() {
-                    self.cache.remove_prop(prop, frame_id);
-                }
+        if let Some(f) = self.key_frames.insert(frame_id, frame)
+            && let KeyFrameStyle::Style(style) = f.style
+        {
+            for prop in style.style_props() {
+                self.cache.remove_prop(prop, frame_id);
             }
         }
         if let KeyFrameStyle::Style(style) = frame_style {
diff --git a/src/app_handle.rs b/src/app_handle.rs
index 0bb313261..9ce160ccc 100644
--- a/src/app_handle.rs
+++ b/src/app_handle.rs
@@ -218,10 +218,10 @@ impl ApplicationHandle {
             .reduce(window_handle.scale, &event)
         {
             Some(WindowEventTranslation::Keyboard(ke)) => {
-                if let WindowEvent::KeyboardInput { is_synthetic, .. } = event {
-                    if !is_synthetic {
-                        window_handle.key_event(ke)
-                    }
+                if let WindowEvent::KeyboardInput { is_synthetic, .. } = event
+                    && !is_synthetic
+                {
+                    window_handle.key_event(ke)
                 }
             }
             Some(WindowEventTranslation::Pointer(pe)) => {
@@ -526,16 +526,16 @@ impl ApplicationHandle {
             return;
         };
         #[cfg(target_os = "macos")]
-        if let Some(mac) = &mac_os_config {
-            if let Some((x, y)) = mac.traffic_lights_offset {
-                use raw_window_handle::HasWindowHandle;
+        if let Some(mac) = &mac_os_config
+            && let Some((x, y)) = mac.traffic_lights_offset
+        {
+            use raw_window_handle::HasWindowHandle;
 
-                if let Ok(wh) = window.window_handle() {
-                    use raw_window_handle::RawWindowHandle;
+            if let Ok(wh) = window.window_handle() {
+                use raw_window_handle::RawWindowHandle;
 
-                    if let RawWindowHandle::AppKit(app_kit) = wh.as_raw() {
-                        let _ = setup_traffic_light_constraints_all_pixels(&app_kit, x, y, 6.);
-                    }
+                if let RawWindowHandle::AppKit(app_kit) = wh.as_raw() {
+                    let _ = setup_traffic_light_constraints_all_pixels(&app_kit, x, y, 6.);
                 }
             }
         }
diff --git a/src/context.rs b/src/context.rs
index cb3f98e9d..edf69900c 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -146,23 +146,23 @@ impl EventCx<'_> {
                 .event_before_children(self, &event)
                 .is_processed()
         {
-            if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { state, .. })) = &event {
-                if view_state.borrow().computed_style.get(Focusable) {
-                    let rect = view_id.get_size().unwrap_or_default().to_rect();
-                    let point = state.logical_point();
-                    let now_focused = rect.contains(point);
-                    if now_focused {
-                        self.window_state.update_focus(view_id, false);
-                    }
+            if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { state, .. })) = &event
+                && view_state.borrow().computed_style.get(Focusable)
+            {
+                let rect = view_id.get_size().unwrap_or_default().to_rect();
+                let point = state.logical_point();
+                let now_focused = rect.contains(point);
+                if now_focused {
+                    self.window_state.update_focus(view_id, false);
                 }
             }
             if let Event::Pointer(PointerEvent::Move(_)) = &event {
                 let view_state = view_state.borrow();
                 let style = view_state.combined_style.builtin();
-                if let Some(cursor) = style.cursor() {
-                    if self.window_state.cursor.is_none() {
-                        self.window_state.cursor = Some(cursor);
-                    }
+                if let Some(cursor) = style.cursor()
+                    && self.window_state.cursor.is_none()
+                {
+                    self.window_state.cursor = Some(cursor);
                 }
             }
             return (EventPropagation::Stop, PointerEventConsumed::Yes);
@@ -303,43 +303,42 @@ impl EventCx<'_> {
                             self.window_state.hovered.insert(view_id);
                             let view_state = view_state.borrow();
                             let style = view_state.combined_style.builtin();
-                            if let Some(cursor) = style.cursor() {
-                                if self.window_state.cursor.is_none() {
-                                    self.window_state.cursor = Some(cursor);
-                                }
+                            if let Some(cursor) = style.cursor()
+                                && self.window_state.cursor.is_none()
+                            {
+                                self.window_state.cursor = Some(cursor);
                             }
                         }
                     }
-                    if view_id.can_drag() {
-                        if let Some((_, drag_start)) = self
+                    if view_id.can_drag()
+                        && let Some((_, drag_start)) = self
                             .window_state
                             .drag_start
                             .as_ref()
                             .filter(|(drag_id, _)| drag_id == &view_id)
+                    {
+                        let offset = current.logical_point() - *drag_start;
+                        if let Some(dragging) = self
+                            .window_state
+                            .dragging
+                            .as_mut()
+                            .filter(|d| d.id == view_id && d.released_at.is_none())
                         {
-                            let offset = current.logical_point() - *drag_start;
-                            if let Some(dragging) = self
-                                .window_state
-                                .dragging
-                                .as_mut()
-                                .filter(|d| d.id == view_id && d.released_at.is_none())
-                            {
-                                // update the mouse position if the view is dragging and not released
-                                dragging.offset = drag_start.to_vec2();
-                                self.window_state.request_paint(view_id);
-                            } else if offset.x.abs() + offset.y.abs() > 1.0 {
-                                // start dragging when moved 1 px
-                                self.window_state.active = None;
-                                self.window_state.dragging = Some(DragState {
-                                    id: view_id,
-                                    offset: drag_start.to_vec2(),
-                                    released_at: None,
-                                    release_location: None,
-                                });
-                                self.update_active(view_id);
-                                self.window_state.request_paint(view_id);
-                                view_id.apply_event(&EventListener::DragStart, &event);
-                            }
+                            // update the mouse position if the view is dragging and not released
+                            dragging.offset = drag_start.to_vec2();
+                            self.window_state.request_paint(view_id);
+                        } else if offset.x.abs() + offset.y.abs() > 1.0 {
+                            // start dragging when moved 1 px
+                            self.window_state.active = None;
+                            self.window_state.dragging = Some(DragState {
+                                id: view_id,
+                                offset: drag_start.to_vec2(),
+                                released_at: None,
+                                release_location: None,
+                            });
+                            self.update_active(view_id);
+                            self.window_state.request_paint(view_id);
+                            view_id.apply_event(&EventListener::DragStart, &event);
                         }
                     }
                     if view_id
@@ -361,26 +360,22 @@ impl EventCx<'_> {
                         let on_view = rect.contains(state.logical_point());
 
                         #[cfg(not(target_os = "macos"))]
-                        if on_view {
-                            if let Some((ep, pec)) = popout_menu() {
-                                return (ep, pec);
-                            };
-                        }
+                        if on_view && let Some((ep, pec)) = popout_menu() {
+                            return (ep, pec);
+                        };
 
                         if !directed {
-                            if on_view {
-                                if let Some(dragging) = self.window_state.dragging.as_mut() {
-                                    let dragging_id = dragging.id;
-                                    if view_id
-                                        .apply_event(&EventListener::Drop, &event)
-                                        .is_some_and(|prop| prop.is_processed())
-                                    {
-                                        // if the drop is processed, we set dragging to none so that the animation
-                                        // for the dragged view back to its original position isn't played.
-                                        self.window_state.dragging = None;
-                                        self.window_state.request_paint(view_id);
-                                        dragging_id.apply_event(&EventListener::DragEnd, &event);
-                                    }
+                            if on_view && let Some(dragging) = self.window_state.dragging.as_mut() {
+                                let dragging_id = dragging.id;
+                                if view_id
+                                    .apply_event(&EventListener::Drop, &event)
+                                    .is_some_and(|prop| prop.is_processed())
+                                {
+                                    // if the drop is processed, we set dragging to none so that the animation
+                                    // for the dragged view back to its original position isn't played.
+                                    self.window_state.dragging = None;
+                                    self.window_state.request_paint(view_id);
+                                    dragging_id.apply_event(&EventListener::DragEnd, &event);
                                 }
                             }
                         } else if let Some(dragging) = self
@@ -415,16 +410,15 @@ impl EventCx<'_> {
                             }
                         }
 
-                        if let Some(handlers) = event_listeners.get(&EventListener::Click) {
-                            if on_view
-                                && self.window_state.is_clicking(&view_id)
-                                && last_pointer_down.is_some()
-                                && handlers.iter().fold(false, |handled, handler| {
-                                    handled | (handler.borrow_mut())(&event).is_processed()
-                                })
-                            {
-                                return (EventPropagation::Stop, PointerEventConsumed::Yes);
-                            }
+                        if let Some(handlers) = event_listeners.get(&EventListener::Click)
+                            && on_view
+                            && self.window_state.is_clicking(&view_id)
+                            && last_pointer_down.is_some()
+                            && handlers.iter().fold(false, |handled, handler| {
+                                handled | (handler.borrow_mut())(&event).is_processed()
+                            })
+                        {
+                            return (EventPropagation::Stop, PointerEventConsumed::Yes);
                         }
 
                         if view_id
@@ -440,15 +434,13 @@ impl EventCx<'_> {
                         let last_pointer_down = view_state.borrow_mut().last_pointer_down.take();
                         let event_listeners = view_state.borrow().event_listeners.clone();
                         if let Some(handlers) = event_listeners.get(&EventListener::SecondaryClick)
+                            && on_view
+                            && last_pointer_down.is_some()
+                            && handlers.iter().fold(false, |handled, handler| {
+                                handled | (handler.borrow_mut())(&event).is_processed()
+                            })
                         {
-                            if on_view
-                                && last_pointer_down.is_some()
-                                && handlers.iter().fold(false, |handled, handler| {
-                                    handled | (handler.borrow_mut())(&event).is_processed()
-                                })
-                            {
-                                return (EventPropagation::Stop, PointerEventConsumed::Yes);
-                            }
+                            return (EventPropagation::Stop, PointerEventConsumed::Yes);
                         }
 
                         let viewport_event_position = {
@@ -492,23 +484,21 @@ impl EventCx<'_> {
             }
         }
 
-        if !disable_default {
-            if let Some(listener) = event.listener() {
-                let event_listeners = view_state.borrow().event_listeners.clone();
-                if let Some(handlers) = event_listeners.get(&listener).cloned() {
-                    let should_run = if let Some(pos) = event.point() {
-                        let rect = view_id.get_size().unwrap_or_default().to_rect();
-                        rect.contains(pos)
-                    } else {
-                        true
-                    };
-                    if should_run
-                        && handlers.iter().fold(false, |handled, handler| {
-                            handled | (handler.borrow_mut())(&event).is_processed()
-                        })
-                    {
-                        return (EventPropagation::Stop, PointerEventConsumed::Yes);
-                    }
+        if !disable_default && let Some(listener) = event.listener() {
+            let event_listeners = view_state.borrow().event_listeners.clone();
+            if let Some(handlers) = event_listeners.get(&listener).cloned() {
+                let should_run = if let Some(pos) = event.point() {
+                    let rect = view_id.get_size().unwrap_or_default().to_rect();
+                    rect.contains(pos)
+                } else {
+                    true
+                };
+                if should_run
+                    && handlers.iter().fold(false, |handled, handler| {
+                        handled | (handler.borrow_mut())(&event).is_processed()
+                    })
+                {
+                    return (EventPropagation::Stop, PointerEventConsumed::Yes);
                 }
             }
         }
@@ -1182,79 +1172,79 @@ impl PaintCx<'_> {
         }
         let mut drag_set_to_none = false;
 
-        if let Some(dragging) = self.window_state.dragging.as_ref() {
-            if dragging.id == id {
-                let transform = if let Some((released_at, release_location)) =
-                    dragging.released_at.zip(dragging.release_location)
-                {
-                    let easing = Linear;
-                    const ANIMATION_DURATION_MS: f64 = 300.0;
-                    let elapsed = released_at.elapsed().as_millis() as f64;
-                    let progress = elapsed / ANIMATION_DURATION_MS;
-
-                    if !(easing.finished(progress)) {
-                        let offset_scale = 1.0 - easing.eval(progress);
-                        let release_offset = release_location.to_vec2() - dragging.offset;
-
-                        // Schedule next animation frame
-                        exec_after(Duration::from_millis(8), move |_| {
-                            id.request_paint();
-                        });
-
-                        Some(self.transform * Affine::translate(release_offset * offset_scale))
-                    } else {
-                        drag_set_to_none = true;
-                        None
-                    }
+        if let Some(dragging) = self.window_state.dragging.as_ref()
+            && dragging.id == id
+        {
+            let transform = if let Some((released_at, release_location)) =
+                dragging.released_at.zip(dragging.release_location)
+            {
+                let easing = Linear;
+                const ANIMATION_DURATION_MS: f64 = 300.0;
+                let elapsed = released_at.elapsed().as_millis() as f64;
+                let progress = elapsed / ANIMATION_DURATION_MS;
+
+                if !(easing.finished(progress)) {
+                    let offset_scale = 1.0 - easing.eval(progress);
+                    let release_offset = release_location.to_vec2() - dragging.offset;
+
+                    // Schedule next animation frame
+                    exec_after(Duration::from_millis(8), move |_| {
+                        id.request_paint();
+                    });
+
+                    Some(self.transform * Affine::translate(release_offset * offset_scale))
                 } else {
-                    // Handle active dragging
-                    let translation =
-                        self.window_state.last_cursor_location.to_vec2() - dragging.offset;
-                    Some(self.transform.with_translation(translation))
-                };
+                    drag_set_to_none = true;
+                    None
+                }
+            } else {
+                // Handle active dragging
+                let translation =
+                    self.window_state.last_cursor_location.to_vec2() - dragging.offset;
+                Some(self.transform.with_translation(translation))
+            };
 
-                if let Some(transform) = transform {
-                    self.save();
-                    self.transform = transform;
-                    self.paint_state
-                        .renderer_mut()
-                        .set_transform(self.transform);
-                    self.set_z_index(1000);
-                    self.clear_clip();
-
-                    // Apply styles
-                    let style = view_state.borrow().combined_style.clone();
-                    let mut view_style_props = view_state.borrow().view_style_props.clone();
-
-                    if let Some(dragging_style) = view_state.borrow().dragging_style.clone() {
-                        let style = style.apply(dragging_style);
-                        let mut _new_frame = false;
-                        view_style_props.read_explicit(
-                            &style,
-                            &style,
-                            &Instant::now(),
-                            &mut _new_frame,
-                        );
-                    }
+            if let Some(transform) = transform {
+                self.save();
+                self.transform = transform;
+                self.paint_state
+                    .renderer_mut()
+                    .set_transform(self.transform);
+                self.set_z_index(1000);
+                self.clear_clip();
+
+                // Apply styles
+                let style = view_state.borrow().combined_style.clone();
+                let mut view_style_props = view_state.borrow().view_style_props.clone();
+
+                if let Some(dragging_style) = view_state.borrow().dragging_style.clone() {
+                    let style = style.apply(dragging_style);
+                    let mut _new_frame = false;
+                    view_style_props.read_explicit(
+                        &style,
+                        &style,
+                        &Instant::now(),
+                        &mut _new_frame,
+                    );
+                }
 
-                    // Paint with drag styling
-                    let layout_props = view_state.borrow().layout_props.clone();
+                // Paint with drag styling
+                let layout_props = view_state.borrow().layout_props.clone();
 
-                    // Important: If any method early exit points are added in this
-                    // code block, they MUST call CURRENT_DRAG_PAINTING_ID.take() before
-                    // returning.
+                // Important: If any method early exit points are added in this
+                // code block, they MUST call CURRENT_DRAG_PAINTING_ID.take() before
+                // returning.
 
-                    CURRENT_DRAG_PAINTING_ID.set(Some(id));
+                CURRENT_DRAG_PAINTING_ID.set(Some(id));
 
-                    paint_bg(self, &view_style_props, size);
-                    view.borrow_mut().paint(self);
-                    paint_border(self, &layout_props, &view_style_props, size);
-                    paint_outline(self, &view_style_props, size);
+                paint_bg(self, &view_style_props, size);
+                view.borrow_mut().paint(self);
+                paint_border(self, &layout_props, &view_style_props, size);
+                paint_outline(self, &view_style_props, size);
 
-                    self.restore();
+                self.restore();
 
-                    CURRENT_DRAG_PAINTING_ID.take();
-                }
+                CURRENT_DRAG_PAINTING_ID.take();
             }
         }
 
diff --git a/src/id.rs b/src/id.rs
index ab41618de..dff2b0784 100644
--- a/src/id.rs
+++ b/src/id.rs
@@ -45,10 +45,10 @@ impl ViewId {
             // Remove the cached root, in the (unlikely) case that this view is
             // re-added to a different window
             s.root.remove(*self);
-            if let Some(Some(parent)) = s.parent.get(*self) {
-                if let Some(children) = s.children.get_mut(*parent) {
-                    children.retain(|c| c != self);
-                }
+            if let Some(Some(parent)) = s.parent.get(*self)
+                && let Some(children) = s.children.get_mut(*parent)
+            {
+                children.retain(|c| c != self);
             }
             s.view_ids.remove(*self);
         });
@@ -207,11 +207,11 @@ impl ViewId {
             // root_view_id() always returns SOMETHING.  If the view is not yet added
             // to a window, it can be itself or its nearest ancestor, which means we
             // will store garbage permanently.
-            if let Some(root) = root_view_id {
-                if is_known_root(&root) {
-                    s.root.insert(*self, root_view_id);
-                    return Some(root);
-                }
+            if let Some(root) = root_view_id
+                && is_known_root(&root)
+            {
+                s.root.insert(*self, root_view_id);
+                return Some(root);
             }
             None
         })
diff --git a/src/inspector/view.rs b/src/inspector/view.rs
index 122021883..025616e26 100644
--- a/src/inspector/view.rs
+++ b/src/inspector/view.rs
@@ -76,11 +76,12 @@ pub fn capture(window_id: WindowId) {
                 stack
                     .style(|s| s.width_full().height_full())
                     .on_event(EventListener::KeyUp, move |e| {
-                        if let Event::Key(e) = e {
-                            if e.key == keyboard::Key::Named(NamedKey::F11) && e.modifiers.shift() {
-                                id.inspect();
-                                return EventPropagation::Stop;
-                            }
+                        if let Event::Key(e) = e
+                            && e.key == keyboard::Key::Named(NamedKey::F11)
+                            && e.modifiers.shift()
+                        {
+                            id.inspect();
+                            return EventPropagation::Stop;
                         }
                         EventPropagation::Continue
                     })
@@ -559,14 +560,14 @@ fn tree_node(
     let scroll_to = capture_signal.scroll_to;
     let expanding_selection = capture_signal.expanding_selection;
     create_effect(move |_| {
-        if let Some((selection, request_focus)) = expanding_selection.get() {
-            if selection == id {
-                // Scroll to the row, then to the name part of the row.
-                scroll_to.set(Some(row_id));
-                scroll_to.set(Some(name_id));
-                if request_focus {
-                    row_id.request_focus();
-                }
+        if let Some((selection, request_focus)) = expanding_selection.get()
+            && selection == id
+        {
+            // Scroll to the row, then to the name part of the row.
+            scroll_to.set(Some(row_id));
+            scroll_to.set(Some(name_id));
+            if request_focus {
+                row_id.request_focus();
             }
         }
     });
diff --git a/src/style.rs b/src/style.rs
index 06069ee34..16c72c65c 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -1546,16 +1546,16 @@ impl<T: StylePropValue> TransitionState<T> {
             if let Some(transition) = &self.transition {
                 let time = now.saturating_duration_since(active.start);
                 let time_percent = time.as_secs_f64() / transition.duration.as_secs_f64();
-                if time < transition.duration || !transition.easing.finished(time_percent) {
-                    if let Some(i) = T::interpolate(
+                if (time < transition.duration || !transition.easing.finished(time_percent))
+                    && let Some(i) = T::interpolate(
                         &active.before,
                         &active.after,
                         transition.easing.eval(time_percent),
-                    ) {
-                        active.current = i;
-                        *request_transition = true;
-                        return true;
-                    }
+                    )
+                {
+                    active.current = i;
+                    *request_transition = true;
+                    return true;
                 }
             }
             // time has past duration, or the value is not interpolatable
@@ -2073,13 +2073,13 @@ fn resolve_nested_maps_internal(
     }
 
     // DarkMode
-    if interact_state.is_dark_mode {
-        if let Some(map) = style.get_nested_map(StyleSelector::DarkMode.to_key()) {
-            classes_applied |= map.any_inherited();
-            style.apply_mut(map);
-            style.remove_nested_map(StyleSelector::DarkMode.to_key());
-            changed = true;
-        }
+    if interact_state.is_dark_mode
+        && let Some(map) = style.get_nested_map(StyleSelector::DarkMode.to_key())
+    {
+        classes_applied |= map.any_inherited();
+        style.apply_mut(map);
+        style.remove_nested_map(StyleSelector::DarkMode.to_key());
+        changed = true;
     }
 
     // Disabled state (takes precedence)
@@ -2094,33 +2094,33 @@ fn resolve_nested_maps_internal(
         // Other states only apply if not disabled
 
         // Selected
-        if interact_state.is_selected || style.get(Selected) {
-            if let Some(map) = style.get_nested_map(StyleSelector::Selected.to_key()) {
-                classes_applied |= map.any_inherited();
-                style.apply_mut(map);
-                style.remove_nested_map(StyleSelector::Selected.to_key());
-                changed = true;
-            }
+        if (interact_state.is_selected || style.get(Selected))
+            && let Some(map) = style.get_nested_map(StyleSelector::Selected.to_key())
+        {
+            classes_applied |= map.any_inherited();
+            style.apply_mut(map);
+            style.remove_nested_map(StyleSelector::Selected.to_key());
+            changed = true;
         }
 
         // Hover
-        if interact_state.is_hovered {
-            if let Some(map) = style.get_nested_map(StyleSelector::Hover.to_key()) {
-                classes_applied |= map.any_inherited();
-                style.apply_mut(map);
-                style.remove_nested_map(StyleSelector::Hover.to_key());
-                changed = true;
-            }
+        if interact_state.is_hovered
+            && let Some(map) = style.get_nested_map(StyleSelector::Hover.to_key())
+        {
+            classes_applied |= map.any_inherited();
+            style.apply_mut(map);
+            style.remove_nested_map(StyleSelector::Hover.to_key());
+            changed = true;
         }
 
         // File Hover
-        if interact_state.is_file_hover {
-            if let Some(map) = style.get_nested_map(StyleSelector::FileHover.to_key()) {
-                classes_applied |= map.any_inherited();
-                style.apply_mut(map);
-                style.remove_nested_map(StyleSelector::FileHover.to_key());
-                changed = true;
-            }
+        if interact_state.is_file_hover
+            && let Some(map) = style.get_nested_map(StyleSelector::FileHover.to_key())
+        {
+            classes_applied |= map.any_inherited();
+            style.apply_mut(map);
+            style.remove_nested_map(StyleSelector::FileHover.to_key());
+            changed = true;
         }
 
         // Focus states
@@ -2140,25 +2140,26 @@ fn resolve_nested_maps_internal(
                     changed = true;
                 }
 
-                if interact_state.is_clicking {
-                    if let Some(map) = style.get_nested_map(StyleSelector::Active.to_key()) {
-                        classes_applied |= map.any_inherited();
-                        style.apply_mut(map);
-                        style.remove_nested_map(StyleSelector::Active.to_key());
-                        changed = true;
-                    }
+                if interact_state.is_clicking
+                    && let Some(map) = style.get_nested_map(StyleSelector::Active.to_key())
+                {
+                    classes_applied |= map.any_inherited();
+                    style.apply_mut(map);
+                    style.remove_nested_map(StyleSelector::Active.to_key());
+                    changed = true;
                 }
             }
         }
 
         // Active (mouse)
-        if interact_state.is_clicking && !interact_state.using_keyboard_navigation {
-            if let Some(map) = style.get_nested_map(StyleSelector::Active.to_key()) {
-                classes_applied |= map.any_inherited();
-                style.apply_mut(map);
-                style.remove_nested_map(StyleSelector::Active.to_key());
-                changed = true;
-            }
+        if interact_state.is_clicking
+            && !interact_state.using_keyboard_navigation
+            && let Some(map) = style.get_nested_map(StyleSelector::Active.to_key())
+        {
+            classes_applied |= map.any_inherited();
+            style.apply_mut(map);
+            style.remove_nested_map(StyleSelector::Active.to_key());
+            changed = true;
         }
     }
 
@@ -2272,11 +2273,11 @@ impl Style {
                 self.apply_context_mappings_mut();
             }
         }
-        if self.get(Selected) {
-            if let Some(map) = self.get_nested_map(StyleSelector::Selected.to_key()) {
-                self.apply_mut(map.apply_selectors(&[StyleSelector::Selected]));
-                self.apply_context_mappings_mut();
-            }
+        if self.get(Selected)
+            && let Some(map) = self.get_nested_map(StyleSelector::Selected.to_key())
+        {
+            self.apply_mut(map.apply_selectors(&[StyleSelector::Selected]));
+            self.apply_context_mappings_mut();
         }
         self
     }
diff --git a/src/theme.rs b/src/theme.rs
index b11420106..f8b154695 100644
--- a/src/theme.rs
+++ b/src/theme.rs
@@ -24,143 +24,188 @@ use smallvec::smallvec;
 
 style_class!(pub HoverTargetClass);
 
+/// A theme builder. Create your own or use provided default [light](DesignSystem::light)
+/// and [dark](DesignSystem::dark) default themes.
 #[derive(Debug, Clone, PartialEq)]
 pub struct DesignSystem {
+    /// The base background color.
     pub bg_base: Color,
+    /// Lightness of the background elevation from 0-1.
+    pub bg_elevate: f32,
+    /// Lightness of the background overlays from 0-1.
+    pub bg_overlay: f32,
+    /// Lightness of the disabled elements (0-1) based on background.
+    pub disabled: f32,
+
+    /// Base text color.
     pub text_base: Color,
+    /// Lightness of the text color (0-1).
     pub text_lightness: f32,
+    /// Lightness of the text color (0-1) when muted.
+    pub text_muted: f32,
+    /// Size of the font.
+    pub font_size: f32,
+
+    /// The primary theme accent color.
     pub primary_base: Color,
+    /// The success theme accent color.
     pub success_base: Color,
+    /// The warning theme accent color.
     pub warning_base: Color,
+    /// The danger theme accent color.
     pub danger_base: Color,
-    pub is_dark: bool,
-    pub padding: f32,
+
+    /// Lightness of the border (0-1) based on background.
+    pub border: f32,
+    /// Theme border radius.
     pub border_radius: f32,
-    pub font_size: f32,
+    /// Default theme padding.
+    pub padding: f32,
+    /// Is the theme a dark variant.
+    pub is_dark: bool,
 }
-// const BORDER_RADIUS: f32 = 5.0;
-// const FONT_SIZE: f32 = 12.0;
 
 impl DesignSystem {
-    /// Create a light mode design system.
+    /// Create a default light mode design system.
     pub fn light() -> Self {
         Self {
-            bg_base: Color::from_rgb8(248, 248, 248),
-            text_base: Color::from_rgb8(0, 0, 0),
+            bg_base: hsl(0., 0., 97.),
+            text_base: hsl(0., 0., 0.),
             text_lightness: 0.05,
-            primary_base: Color::from_rgb8(0x18, 0x96, 0xC2),
-            success_base: Color::from_rgb8(0x2D, 0x9D, 0x67),
-            warning_base: Color::from_rgb8(0xE5, 0xA2, 0x23),
-            danger_base: Color::from_rgb8(0xD7, 0x37, 0x45),
+            primary_base: Color::from_rgb8(24, 150, 194),
+            success_base: Color::from_rgb8(45, 157, 103),
+            warning_base: Color::from_rgb8(229, 162, 35),
+            danger_base: Color::from_rgb8(215, 55, 69),
             padding: 5.,
             border_radius: 5.,
             font_size: 14.,
             is_dark: false,
+            bg_elevate: -0.03,
+            bg_overlay: 0.1,
+            border: -0.15,
+            disabled: -0.1,
+            text_muted: 0.25,
         }
     }
 
-    /// Create a dark mode design system.
+    /// Create a default dark mode design system.
     pub fn dark() -> Self {
         Self {
-            bg_base: Color::from_rgb8(0x24, 0x24, 0x24),
-            text_base: Color::from_rgb8(255, 255, 255),
+            bg_base: hsl(0., 0., 15.),
+            text_base: hsl(0., 0., 100.),
             text_lightness: 0.95,
-            primary_base: Color::from_rgb8(0x3A, 0xAA, 0xD8),
-            success_base: Color::from_rgb8(0x4A, 0xBE, 0x8A),
-            warning_base: Color::from_rgb8(0xF5, 0xB8, 0x4E),
-            danger_base: Color::from_rgb8(0xF0, 0x56, 0x54),
+            primary_base: Color::from_rgb8(58, 170, 216),
+            success_base: Color::from_rgb8(74, 190, 138),
+            warning_base: Color::from_rgb8(245, 184, 78),
+            danger_base: Color::from_rgb8(240, 86, 84),
             padding: 5.,
             border_radius: 5.,
             font_size: 14.,
             is_dark: true,
+            bg_elevate: 0.05,
+            bg_overlay: 0.1,
+            border: 0.15,
+            disabled: -0.05,
+            text_muted: -0.25,
         }
     }
 
     // Background levels
 
-    pub fn bg_base(&self) -> Color {
+    /// The base background theme color.
+    pub const fn bg_base(&self) -> Color {
         self.bg_base
     }
 
+    /// The theme background elevated color.
     pub fn bg_elevated(&self) -> Color {
-        let adjustment = 0.05;
-        self.bg_base.map_lightness(|l| l + adjustment)
+        self.bg_base.map_lightness(|c| c + self.bg_elevate)
     }
 
+    /// The theme background overlay color.
     pub fn bg_overlay(&self) -> Color {
-        let adjustment = 0.10;
-        self.bg_base.map_lightness(|l| l + adjustment)
+        self.bg_base.map_lightness(|c| c + self.bg_overlay)
     }
 
+    /// The theme background overlay color for disabled elements.
     pub fn bg_disabled(&self) -> Color {
-        let adjustment = if self.is_dark { -0.05 } else { -0.1 };
-        self.bg_base.map_lightness(|l| l + adjustment)
+        self.bg_base.map_lightness(|c| c + self.disabled)
     }
 
     // Border
 
+    /// The theme border color.
     pub fn border(&self) -> Color {
-        let adjustment = if self.is_dark { 0.15 } else { -0.15 };
-        self.bg_base.map_lightness(|l| l + adjustment)
+        self.bg_base.map_lightness(|c| c + self.border)
     }
 
+    /// The theme muted border color.
     pub fn border_muted(&self) -> Color {
-        let adjustment = if self.is_dark { 0.15 } else { -0.15 };
         self.border()
-            .map_lightness(|l| l + adjustment)
+            .map_lightness(|c| c + self.border)
             .with_alpha(0.8)
     }
 
     // Text
 
+    /// The theme text color.
     pub fn text(&self) -> Color {
         self.text_base.map_lightness(|_| self.text_lightness)
     }
 
+    /// The theme muted text color.
     pub fn text_muted(&self) -> Color {
-        let adjustment = if self.is_dark { -0.25 } else { 0.25 };
         self.text_base
-            .map_lightness(|l| l + adjustment)
+            .map_lightness(|c| c + self.text_muted)
             .with_alpha(0.5)
     }
 
     // Primary
 
-    pub fn primary(&self) -> Color {
+    /// The primary theme accent color.
+    pub const fn primary(&self) -> Color {
         self.primary_base
     }
 
+    /// The muted primary theme accent color.
     pub fn primary_muted(&self) -> Color {
-        self.primary_base.map_lightness(|l| l - 0.05)
+        self.primary_base.map_lightness(|c| c - 0.05)
     }
 
     // Semantic colors
 
-    pub fn success(&self) -> Color {
+    /// The success theme accent color.
+    pub const fn success(&self) -> Color {
         self.success_base
     }
 
-    pub fn warning(&self) -> Color {
+    /// The warning theme accent color.
+    pub const fn warning(&self) -> Color {
         self.warning_base
     }
 
-    pub fn danger(&self) -> Color {
+    /// The danger theme accent color.
+    pub const fn danger(&self) -> Color {
         self.danger_base
     }
 
-    pub fn info(&self) -> Color {
+    /// The info theme accent color.
+    pub const fn info(&self) -> Color {
         self.primary_base
     }
 
-    pub fn padding(&self) -> f32 {
+    /// The theme default padding.
+    pub const fn padding(&self) -> f32 {
         self.padding
     }
 
-    pub fn border_radius(&self) -> f32 {
+    /// The theme default border radius.
+    pub const fn border_radius(&self) -> f32 {
         self.border_radius
     }
 
-    pub fn font_size(&self) -> f32 {
+    /// The theme default font size.
+    pub const fn font_size(&self) -> f32 {
         self.font_size
     }
 }
@@ -242,8 +287,8 @@ impl StylePropValue for DesignSystem {
             }),
         ))
         .style(|s| {
-            // this view here should be getting set to have a height of just the two children combined
-            // I think this is a bug in taffy
+            // This view here should be getting set to have a height of just the two
+            // children combined, I think this is a bug in taffy.
             s.flex_col()
                 .padding(8.0)
                 .border(1.)
@@ -285,6 +330,11 @@ impl StylePropValue for DesignSystem {
             padding: self.padding * inv_t + other.padding * t,
             border_radius: self.border_radius * inv_t + other.border_radius * t,
             font_size: self.font_size * inv_t + other.font_size * t,
+            bg_elevate: self.bg_elevate * inv_t + other.bg_elevate * t,
+            bg_overlay: self.bg_overlay * inv_t + other.bg_overlay * t,
+            disabled: self.disabled * inv_t + other.disabled * t,
+            text_muted: self.text_muted * inv_t + other.text_muted * t,
+            border: self.border + inv_t + other.border * t,
         })
     }
 }
@@ -688,3 +738,52 @@ pub(crate) fn default_theme(os_theme: winit::window::Theme) -> Style {
             .transition(Background, Transition::linear(100.millis()))
         })
 }
+
+/// Contruct sRGB [Color] from HSL values.
+pub const fn hsl(h: f32, s: f32, l: f32) -> Color {
+    let sat = s * 0.01;
+    let light = l * 0.01;
+    let a = sat * light.min(1.0 - light);
+
+    let hue = transform(0., h, light, a);
+    let sat = transform(8., h, light, a);
+    let lum = transform(4., h, light, a);
+    Color::new([hue, sat, lum, 1.])
+}
+
+const fn transform(n: f32, h: f32, light: f32, a: f32) -> f32 {
+    let x = n + h * (1.0 / 30.0);
+    let k = x - 12.0 * (x * (1.0 / 12.0)).floor();
+    light - a * (k - 3.0).min(9.0 - k).clamp(-1.0, 1.0)
+}
+
+#[test]
+fn rgb_hsl_conversion() {
+    let rgb_bg_base = Color::from_rgb8(242, 242, 242);
+    let hsl_bg_base = hsl(0., 0., 95.);
+    assert_eq!(rgb_bg_base.to_rgba8(), hsl_bg_base.to_rgba8());
+
+    let rgb_text_base = Color::from_rgb8(0, 0, 0);
+    let hsl_text_base = hsl(0., 0., 0.);
+    assert_eq!(rgb_text_base.to_rgba8(), hsl_text_base.to_rgba8());
+
+    let rgb_text_lightness = Color::from_rgb8(0, 0, 0);
+    let hsl_text_lightness = hsl(0., 0., 0.);
+    assert_eq!(rgb_text_lightness.to_rgba8(), hsl_text_lightness.to_rgba8());
+
+    let rgb_primary_base = Color::from_rgb8(24, 146, 191);
+    let hsl_primary_base = hsl(196., 78., 42.);
+    assert_eq!(rgb_primary_base.to_rgba8(), hsl_primary_base.to_rgba8());
+
+    let rgb_success_base = Color::from_rgb8(46, 158, 104);
+    let hsl_success_base = hsl(151., 55., 40.);
+    assert_eq!(rgb_success_base.to_rgba8(), hsl_success_base.to_rgba8());
+
+    let rgb_warning_base = Color::from_rgb8(229, 162, 36);
+    let hsl_warning_base = hsl(39., 79., 52.);
+    assert_eq!(rgb_warning_base.to_rgba8(), hsl_warning_base.to_rgba8());
+
+    let rgb_danger_base = Color::from_rgb8(215, 55, 68);
+    let hsl_danger_base = hsl(355., 67., 53.);
+    assert_eq!(rgb_danger_base.to_rgba8(), hsl_danger_base.to_rgba8());
+}
diff --git a/src/views/decorator.rs b/src/views/decorator.rs
index 4215e0d43..91d6229d7 100644
--- a/src/views/decorator.rs
+++ b/src/views/decorator.rs
@@ -241,11 +241,11 @@ pub trait Decorators: IntoView<V = Self::DV> + Sized {
                 modifiers,
                 ..
             }) = e
+                && *event_key == key
+                && cmp(*modifiers)
             {
-                if *event_key == key && cmp(*modifiers) {
-                    action(e);
-                    return EventPropagation::Stop;
-                }
+                action(e);
+                return EventPropagation::Stop;
             }
             EventPropagation::Continue
         })
@@ -267,11 +267,11 @@ pub trait Decorators: IntoView<V = Self::DV> + Sized {
                 modifiers,
                 ..
             }) = e
+                && *event_key == key
+                && cmp(*modifiers)
             {
-                if *event_key == key && cmp(*modifiers) {
-                    action(e);
-                    return EventPropagation::Stop;
-                }
+                action(e);
+                return EventPropagation::Stop;
             }
             EventPropagation::Continue
         })
diff --git a/src/views/drag_window_area.rs b/src/views/drag_window_area.rs
index df5cea9bb..2a7b30480 100644
--- a/src/views/drag_window_area.rs
+++ b/src/views/drag_window_area.rs
@@ -22,10 +22,10 @@ pub fn drag_window_area<V: IntoView + 'static>(child: V) -> DragWindowArea {
     id.set_children([child]);
     DragWindowArea { id }
         .on_event_stop(EventListener::PointerDown, |e| {
-            if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { button, .. })) = e {
-                if button.is_some_and(|b| b == PointerButton::Primary) {
-                    drag_window();
-                }
+            if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { button, .. })) = e
+                && button.is_some_and(|b| b == PointerButton::Primary)
+            {
+                drag_window();
             }
         })
         .on_double_click_stop(|_| toggle_window_maximized())
diff --git a/src/views/dyn_stack.rs b/src/views/dyn_stack.rs
index fe9c57cdf..3ae107e95 100644
--- a/src/views/dyn_stack.rs
+++ b/src/views/dyn_stack.rs
@@ -227,12 +227,12 @@ pub(crate) fn diff<K: Eq + Hash, V>(from: &FxIndexSet<K>, to: &FxIndexSet<K>) ->
     let mut removed_idx = removed.next().map(|k| from.get_full(k).unwrap().0);
 
     for (idx, k) in to.iter().enumerate() {
-        if let Some(added_idx) = added_idx.as_mut().filter(|r_i| **r_i == idx) {
-            if let Some(next_added) = added.next().map(|k| to.get_full(k).unwrap().0) {
-                *added_idx = next_added;
+        if let Some(added_idx) = added_idx.as_mut().filter(|r_i| **r_i == idx)
+            && let Some(next_added) = added.next().map(|k| to.get_full(k).unwrap().0)
+        {
+            *added_idx = next_added;
 
-                normalized_idx = usize::wrapping_sub(normalized_idx, 1);
-            }
+            normalized_idx = usize::wrapping_sub(normalized_idx, 1);
         }
 
         if let Some(removed_idx) = removed_idx.as_mut().filter(|r_i| **r_i == idx) {
@@ -243,13 +243,13 @@ pub(crate) fn diff<K: Eq + Hash, V>(from: &FxIndexSet<K>, to: &FxIndexSet<K>) ->
             }
         }
 
-        if let Some((from_idx, _)) = from.get_full(k) {
-            if from_idx != normalized_idx || from_idx != idx {
-                move_cmds.push(DiffOpMove {
-                    from: from_idx,
-                    to: idx,
-                });
-            }
+        if let Some((from_idx, _)) = from.get_full(k)
+            && (from_idx != normalized_idx || from_idx != idx)
+        {
+            move_cmds.push(DiffOpMove {
+                from: from_idx,
+                to: idx,
+            });
         }
 
         normalized_idx = normalized_idx.wrapping_add(1);
diff --git a/src/views/editor/actions.rs b/src/views/editor/actions.rs
index df1d23f6f..b2f581244 100644
--- a/src/views/editor/actions.rs
+++ b/src/views/editor/actions.rs
@@ -58,10 +58,8 @@ fn handle_edit_command_default(
     // be more flexible.
     let had_edits = action.do_edit(ed, &mut cursor, cmd, modal, &mut register, smart_tab);
 
-    if had_edits {
-        if let Some(data) = yank_data {
-            register.add_delete(data);
-        }
+    if had_edits && let Some(data) = yank_data {
+        register.add_delete(data);
     }
 
     ed.cursor.set(cursor);
diff --git a/src/views/editor/movement.rs b/src/views/editor/movement.rs
index edc80dc20..7443e25f3 100644
--- a/src/views/editor/movement.rs
+++ b/src/views/editor/movement.rs
@@ -238,15 +238,15 @@ fn move_left(
     let rope_text = ed.rope_text();
     let mut new_offset = rope_text.move_left(offset, mode, count);
 
-    if let Some(soft_tab_width) = atomic_soft_tab_width_for_offset(ed, offset) {
-        if soft_tab_width > 1 {
-            new_offset = snap_to_soft_tab(
-                rope_text.text(),
-                new_offset,
-                SnapDirection::Left,
-                soft_tab_width,
-            );
-        }
+    if let Some(soft_tab_width) = atomic_soft_tab_width_for_offset(ed, offset)
+        && soft_tab_width > 1
+    {
+        new_offset = snap_to_soft_tab(
+            rope_text.text(),
+            new_offset,
+            SnapDirection::Left,
+            soft_tab_width,
+        );
     }
 
     *affinity = CursorAffinity::Forward;
@@ -266,15 +266,15 @@ fn move_right(
     let rope_text = view.rope_text();
     let mut new_offset = rope_text.move_right(offset, mode, count);
 
-    if let Some(soft_tab_width) = atomic_soft_tab_width_for_offset(view, offset) {
-        if soft_tab_width > 1 {
-            new_offset = snap_to_soft_tab(
-                rope_text.text(),
-                new_offset,
-                SnapDirection::Right,
-                soft_tab_width,
-            );
-        }
+    if let Some(soft_tab_width) = atomic_soft_tab_width_for_offset(view, offset)
+        && soft_tab_width > 1
+    {
+        new_offset = snap_to_soft_tab(
+            rope_text.text(),
+            new_offset,
+            SnapDirection::Right,
+            soft_tab_width,
+        );
     }
 
     *affinity = CursorAffinity::Backward;
diff --git a/src/views/editor/text_document.rs b/src/views/editor/text_document.rs
index fef53e6da..1e71b68bb 100644
--- a/src/views/editor/text_document.rs
+++ b/src/views/editor/text_document.rs
@@ -249,19 +249,18 @@ impl DocumentPhantom for TextDocument {
 
         if self.buffer.with_untracked(Buffer::is_empty)
             && self.preedit.preedit.with_untracked(|p| p.is_none())
+            && let Some(placeholder) = self.placeholder(edid)
         {
-            if let Some(placeholder) = self.placeholder(edid) {
-                text.push(PhantomText {
-                    kind: PhantomTextKind::Placeholder,
-                    col: 0,
-                    affinity: None,
-                    text: placeholder,
-                    font_size: None,
-                    fg: Some(styling.placeholder_color()),
-                    bg: None,
-                    under_line: None,
-                });
-            }
+            text.push(PhantomText {
+                kind: PhantomTextKind::Placeholder,
+                col: 0,
+                affinity: None,
+                text: placeholder,
+                font_size: None,
+                fg: Some(styling.placeholder_color()),
+                bg: None,
+                under_line: None,
+            });
         }
 
         if let Some(preedit) = self.preedit_phantom(Some(styling.preedit_underline_color()), line) {
diff --git a/src/views/editor/view.rs b/src/views/editor/view.rs
index d56e85e9e..2c4ccf41b 100644
--- a/src/views/editor/view.rs
+++ b/src/views/editor/view.rs
@@ -1280,10 +1280,10 @@ fn editor_content(
                 #[cfg(target_os = "macos")]
                 mods.set(Modifiers::ALT, false);
 
-                if mods.is_empty() {
-                    if let Key::Character(c) = &key_event.key {
-                        editor.get_untracked().receive_char(c);
-                    }
+                if mods.is_empty()
+                    && let Key::Character(c) = &key_event.key
+                {
+                    editor.get_untracked().receive_char(c);
                 }
             })
             .style(|s| s.min_size_full())
diff --git a/src/views/editor/visual_line.rs b/src/views/editor/visual_line.rs
index 76fc27d86..2f9c51fac 100644
--- a/src/views/editor/visual_line.rs
+++ b/src/views/editor/visual_line.rs
@@ -1039,16 +1039,16 @@ fn find_vline_of_offset(
             .map(|line_index| (VLine(vline.get() + line_index), line_index))?;
 
     // If the most recent line break was due to a soft line break,
-    if line_index > 0 {
-        if let CursorAffinity::Backward = affinity {
-            // TODO: This can definitely be smarter. We're doing a vline search, and then this is
-            // practically doing another!
-            let line_end = lines.offset_of_vline(text_prov, vline);
-            // then if we're right at that soft line break, a backwards affinity
-            // means that we are on the previous visual line.
-            if line_end == offset && vline.get() != 0 {
-                return Some((VLine(vline.get() - 1), line_index - 1));
-            }
+    if line_index > 0
+        && let CursorAffinity::Backward = affinity
+    {
+        // TODO: This can definitely be smarter. We're doing a vline search, and then this is
+        // practically doing another!
+        let line_end = lines.offset_of_vline(text_prov, vline);
+        // then if we're right at that soft line break, a backwards affinity
+        // means that we are on the previous visual line.
+        if line_end == offset && vline.get() != 0 {
+            return Some((VLine(vline.get() - 1), line_index - 1));
         }
     }
 
@@ -1080,23 +1080,23 @@ fn find_rvline_of_offset(
         .map(|line_index| RVLine::new(buffer_line, line_index))?;
 
     // If the most recent line break was due to a soft line break,
-    if rv.line_index > 0 {
-        if let CursorAffinity::Backward = affinity {
-            let line_end = lines.offset_of_rvline(text_prov, rv);
-            // then if we're right at that soft line break, a backwards affinity
-            // means that we are on the previous visual line.
-            if line_end == offset {
-                if rv.line_index > 0 {
-                    return Some(RVLine::new(rv.line, rv.line_index - 1));
-                } else if rv.line == 0 {
-                    // There is no previous line, we do nothing.
-                } else {
-                    // We have to get rvline info for that rvline, so we can get the last line index
-                    // This should always have at least one rvline in it.
-                    let font_sizes = lines.font_sizes.borrow();
-                    let (prev, _) = prev_rvline(&layouts, text_prov, &**font_sizes, rv)?;
-                    return Some(prev);
-                }
+    if rv.line_index > 0
+        && let CursorAffinity::Backward = affinity
+    {
+        let line_end = lines.offset_of_rvline(text_prov, rv);
+        // then if we're right at that soft line break, a backwards affinity
+        // means that we are on the previous visual line.
+        if line_end == offset {
+            if rv.line_index > 0 {
+                return Some(RVLine::new(rv.line, rv.line_index - 1));
+            } else if rv.line == 0 {
+                // There is no previous line, we do nothing.
+            } else {
+                // We have to get rvline info for that rvline, so we can get the last line index
+                // This should always have at least one rvline in it.
+                let font_sizes = lines.font_sizes.borrow();
+                let (prev, _) = prev_rvline(&layouts, text_prov, &**font_sizes, rv)?;
+                return Some(prev);
             }
         }
     }
diff --git a/src/views/label.rs b/src/views/label.rs
index 16f05e3aa..89e3c8b08 100644
--- a/src/views/label.rs
+++ b/src/views/label.rs
@@ -232,15 +232,15 @@ impl Label {
     fn handle_modifier_cmd(&mut self, command: &TextCommand) -> bool {
         match command {
             TextCommand::Copy => {
-                if let Some((start_c, end_c)) = &self.selection_range {
-                    if let Some(ref text_layout) = self.text_layout {
-                        let start_line_idx = text_layout.lines_range()[start_c.line].start;
-                        let end_line_idx = text_layout.lines_range()[end_c.line].start;
-                        let start_idx = start_line_idx + start_c.index;
-                        let end_idx = end_line_idx + end_c.index;
-                        let selection_txt = self.label[start_idx..end_idx].into();
-                        let _ = Clipboard::set_contents(selection_txt);
-                    }
+                if let Some((start_c, end_c)) = &self.selection_range
+                    && let Some(ref text_layout) = self.text_layout
+                {
+                    let start_line_idx = text_layout.lines_range()[start_c.line].start;
+                    let end_line_idx = text_layout.lines_range()[end_c.line].start;
+                    let start_idx = start_line_idx + start_c.index;
+                    let end_idx = end_line_idx + end_c.index;
+                    let selection_txt = self.label[start_idx..end_idx].into();
+                    let _ = Clipboard::set_contents(selection_txt);
                 }
                 true
             }
@@ -399,10 +399,10 @@ impl View for Label {
                 let width = size.width.ceil() as f32;
                 let mut height = size.height as f32;
 
-                if self.style.text_overflow() == TextOverflow::Wrap {
-                    if let Some(t) = self.available_text_layout.as_ref() {
-                        height = height.max(t.size().height as f32);
-                    }
+                if self.style.text_overflow() == TextOverflow::Wrap
+                    && let Some(t) = self.available_text_layout.as_ref()
+                {
+                    height = height.max(t.size().height as f32);
                 }
 
                 (width, height)
diff --git a/src/views/scroll.rs b/src/views/scroll.rs
index 5dcc224aa..94d726bd6 100644
--- a/src/views/scroll.rs
+++ b/src/views/scroll.rs
@@ -573,10 +573,10 @@ impl Scroll {
             let rect = (bounds - scroll_offset).inset(-edge_width / 2.0);
             let rect = rect.to_rounded_rect(radius(style, rect, true));
             cx.fill(&rect, &style.color().unwrap_or(HANDLE_COLOR), 0.0);
-            if edge_width > 0.0 {
-                if let Some(color) = style.border_color().right {
-                    cx.stroke(&rect, &color, &Stroke::new(edge_width));
-                }
+            if edge_width > 0.0
+                && let Some(color) = style.border_color().right
+            {
+                cx.stroke(&rect, &color, &Stroke::new(edge_width));
             }
         }
 
@@ -600,10 +600,10 @@ impl Scroll {
             let rect = (bounds - scroll_offset).inset(-edge_width / 2.0);
             let rect = rect.to_rounded_rect(radius(style, rect, false));
             cx.fill(&rect, &style.color().unwrap_or(HANDLE_COLOR), 0.0);
-            if edge_width > 0.0 {
-                if let Some(color) = style.border_color().right {
-                    cx.stroke(&rect, &color, &Stroke::new(edge_width));
-                }
+            if edge_width > 0.0
+                && let Some(color) = style.border_color().right
+            {
+                cx.stroke(&rect, &color, &Stroke::new(edge_width));
             }
         }
     }
@@ -1031,14 +1031,13 @@ impl View for Scroll {
         event: &Event,
     ) -> EventPropagation {
         if let Event::Pointer(PointerEvent::Scroll(PointerScrollEvent { state, .. })) = &event {
-            if let Some(listener) = event.listener() {
-                if self
+            if let Some(listener) = event.listener()
+                && self
                     .id
                     .apply_event(&listener, event)
                     .is_some_and(|prop| prop.is_processed())
-                {
-                    return EventPropagation::Stop;
-                }
+            {
+                return EventPropagation::Stop;
             }
             if let Some(delta) = event.pixel_scroll_delta_vec2() {
                 let delta = -if self.scroll_style.vertical_scroll_as_horizontal()
diff --git a/src/views/svg.rs b/src/views/svg.rs
index 3581916e6..42ccdfa20 100644
--- a/src/views/svg.rs
+++ b/src/views/svg.rs
@@ -145,11 +145,11 @@ impl View for Svg {
                 self.id.request_style();
             }
         }
-        if let Some(prop_reader) = &mut self.css_prop {
-            if prop_reader.read_custom(cx) {
-                self.id
-                    .update_state(SvgOrStyle::Style(prop_reader.css_string()));
-            }
+        if let Some(prop_reader) = &mut self.css_prop
+            && prop_reader.read_custom(cx)
+        {
+            self.id
+                .update_state(SvgOrStyle::Style(prop_reader.css_string()));
         }
     }
 
diff --git a/src/views/tab.rs b/src/views/tab.rs
index 8df38e08e..717a100c0 100644
--- a/src/views/tab.rs
+++ b/src/views/tab.rs
@@ -292,14 +292,13 @@ impl<T> View for Tab<T> {
     }
 
     fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        if let Some(active_tab) = self.active {
-            if let Some(Some((active, _))) = self
+        if let Some(active_tab) = self.active
+            && let Some(Some((active, _))) = self
                 .children
                 .get(active_tab)
                 .or_else(|| self.children.first())
-            {
-                cx.paint_view(*active);
-            }
+        {
+            cx.paint_view(*active);
         }
     }
 }
diff --git a/src/views/text_input.rs b/src/views/text_input.rs
index 614a6aacd..7293143b6 100644
--- a/src/views/text_input.rs
+++ b/src/views/text_input.rs
@@ -1107,10 +1107,10 @@ fn get_dbl_click_selection(glyph_idx: usize, buffer: &str) -> Range<usize> {
     }
 
     // left-over non-alphanumeric char sequence at the end of the buffer(after the last word)
-    if let Some(last) = selectable_ranges.last() {
-        if last.end != buffer.len() {
-            selectable_ranges.push(last.end..buffer.len());
-        }
+    if let Some(last) = selectable_ranges.last()
+        && last.end != buffer.len()
+    {
+        selectable_ranges.push(last.end..buffer.len());
     }
 
     for range in selectable_ranges {
diff --git a/src/views/toggle_button.rs b/src/views/toggle_button.rs
index 5217e98e2..ffcc898d5 100644
--- a/src/views/toggle_button.rs
+++ b/src/views/toggle_button.rs
@@ -218,10 +218,10 @@ impl View for ToggleButton {
                 key,
                 ..
             }) => {
-                if *key == Key::Named(NamedKey::Enter) {
-                    if let Some(ontoggle) = &self.ontoggle {
-                        ontoggle(!self.state);
-                    }
+                if *key == Key::Named(NamedKey::Enter)
+                    && let Some(ontoggle) = &self.ontoggle
+                {
+                    ontoggle(!self.state);
                 }
             }
             _ => {}
diff --git a/src/views/tooltip.rs b/src/views/tooltip.rs
index 3127c1495..a874f1d74 100644
--- a/src/views/tooltip.rs
+++ b/src/views/tooltip.rs
@@ -87,23 +87,22 @@ impl View for Tooltip {
     }
 
     fn update(&mut self, _cx: &mut UpdateCx, state: Box<dyn std::any::Any>) {
-        if let Ok(token) = state.downcast::<TimerToken>() {
-            if let Some(window_origin) = self.window_origin {
-                if self.hover.map(|(_, t)| t) == Some(*token) {
-                    let tip = self.tip.clone();
-
-                    let tip_style = self.tip_style.clone();
-                    let point = window_origin
-                        + self.hover.unwrap().0.to_vec2()
-                        + (10. / self.scale, 10. / self.scale);
-                    let overlay_id = add_overlay(
-                        ToolTipOverlay::new(tip().style(move |_| tip_style.clone()))
-                            .style(move |s| s.inset_left(point.x).inset_top(point.y)),
-                    );
-                    // overlay_id.request_all();
-                    *self.overlay.borrow_mut() = Some(overlay_id);
-                }
-            }
+        if let Ok(token) = state.downcast::<TimerToken>()
+            && let Some(window_origin) = self.window_origin
+            && self.hover.map(|(_, t)| t) == Some(*token)
+        {
+            let tip = self.tip.clone();
+
+            let tip_style = self.tip_style.clone();
+            let point = window_origin
+                + self.hover.unwrap().0.to_vec2()
+                + (10. / self.scale, 10. / self.scale);
+            let overlay_id = add_overlay(
+                ToolTipOverlay::new(tip().style(move |_| tip_style.clone()))
+                    .style(move |s| s.inset_left(point.x).inset_top(point.y)),
+            );
+            // overlay_id.request_all();
+            *self.overlay.borrow_mut() = Some(overlay_id);
         }
     }
 
diff --git a/src/views/value_container.rs b/src/views/value_container.rs
index d0b2da8dd..02d2d9a6f 100644
--- a/src/views/value_container.rs
+++ b/src/views/value_container.rs
@@ -76,10 +76,10 @@ impl<T: 'static> View for ValueContainer<T> {
     }
 
     fn update(&mut self, _cx: &mut UpdateCx, state: Box<dyn Any>) {
-        if let Ok(state) = state.downcast::<T>() {
-            if let Some(on_update) = self.on_update.as_ref() {
-                on_update(*state);
-            }
+        if let Ok(state) = state.downcast::<T>()
+            && let Some(on_update) = self.on_update.as_ref()
+        {
+            on_update(*state);
         }
     }
 }
diff --git a/src/views/virtual_stack.rs b/src/views/virtual_stack.rs
index e99f22bef..bc2bc4710 100644
--- a/src/views/virtual_stack.rs
+++ b/src/views/virtual_stack.rs
@@ -403,13 +403,13 @@ impl<T> View for VirtualStack<T> {
                 );
                 self.id.request_all();
             }
-        } else if state.is::<usize>() {
-            if let Ok(idx) = state.downcast::<usize>() {
-                self.id.request_style_recursive();
-                self.scroll_to_idx(*idx);
-                self.selected_idx.clear();
-                self.selected_idx.insert(*idx);
-            }
+        } else if state.is::<usize>()
+            && let Ok(idx) = state.downcast::<usize>()
+        {
+            self.id.request_style_recursive();
+            self.scroll_to_idx(*idx);
+            self.selected_idx.clear();
+            self.selected_idx.insert(*idx);
         }
     }
 
diff --git a/src/window_handle.rs b/src/window_handle.rs
index 79cbc130b..d1c59b238 100644
--- a/src/window_handle.rs
+++ b/src/window_handle.rs
@@ -301,13 +301,11 @@ impl WindowHandle {
                         .is_processed();
                 }
 
-                if !processed {
-                    if let Some(listener) = event.listener() {
-                        processed |= self
-                            .main_view
-                            .apply_event(&listener, &event)
-                            .is_some_and(|prop| prop.is_processed());
-                    }
+                if !processed && let Some(listener) = event.listener() {
+                    processed |= self
+                        .main_view
+                        .apply_event(&listener, &event)
+                        .is_some_and(|prop| prop.is_processed());
                 }
 
                 if !processed {
@@ -324,16 +322,15 @@ impl WindowHandle {
                             let backwards = modifiers.contains(Modifiers::SHIFT);
                             view_tab_navigation(self.id, cx.window_state, backwards);
                             // view_debug_tree(&self.view);
-                        } else if *modifiers == Modifiers::ALT {
-                            if let Key::Named(
+                        } else if *modifiers == Modifiers::ALT
+                            && let Key::Named(
                                 name @ (NamedKey::ArrowUp
                                 | NamedKey::ArrowDown
                                 | NamedKey::ArrowLeft
                                 | NamedKey::ArrowRight),
                             ) = key
-                            {
-                                view_arrow_navigation(*name, cx.window_state, self.id);
-                            }
+                        {
+                            view_arrow_navigation(*name, cx.window_state, self.id);
                         }
                     }
 
@@ -346,15 +343,13 @@ impl WindowHandle {
                                 ..
                             })
                         );
-                    if keyboard_trigger_end {
-                        if let Some(id) = cx.window_state.active {
-                            // To remove the styles applied by the Active selector
-                            if cx.window_state.has_style_for_sel(id, StyleSelector::Active) {
-                                id.request_style_recursive();
-                            }
-
-                            cx.window_state.active = None;
+                    if keyboard_trigger_end && let Some(id) = cx.window_state.active {
+                        // To remove the styles applied by the Active selector
+                        if cx.window_state.has_style_for_sel(id, StyleSelector::Active) {
+                            id.request_style_recursive();
                         }
+
+                        cx.window_state.active = None;
                     }
                 }
             }
@@ -1234,15 +1229,15 @@ impl WindowHandle {
     pub(crate) fn set_menu_theme_for_windows(&self, theme: winit::window::Theme) {
         use raw_window_handle::{HasWindowHandle, RawWindowHandle};
 
-        if let RawWindowHandle::Win32(handle) = self.window.window_handle().unwrap().as_raw() {
-            if let Some(menu) = &self.window_menu {
-                unsafe {
-                    let menu_theme = match theme {
-                        winit::window::Theme::Light => muda::MenuTheme::Light,
-                        winit::window::Theme::Dark => muda::MenuTheme::Dark,
-                    };
-                    let _ = menu.set_theme_for_hwnd(handle.hwnd.into(), menu_theme);
-                }
+        if let RawWindowHandle::Win32(handle) = self.window.window_handle().unwrap().as_raw()
+            && let Some(menu) = &self.window_menu
+        {
+            unsafe {
+                let menu_theme = match theme {
+                    winit::window::Theme::Light => muda::MenuTheme::Light,
+                    winit::window::Theme::Dark => muda::MenuTheme::Dark,
+                };
+                let _ = menu.set_theme_for_hwnd(handle.hwnd.into(), menu_theme);
             }
         }
     }
@@ -1505,10 +1500,10 @@ fn context_menu_view(
                             move |menu| view_fn(menu, context_menu, on_child_submenu),
                         )
                         .on_event_stop(EventListener::KeyDown, move |event| {
-                            if let Event::Key(KeyboardEvent { key, .. }) = event {
-                                if *key == Key::Named(NamedKey::Escape) {
-                                    context_menu.set(None);
-                                }
+                            if let Event::Key(KeyboardEvent { key, .. }) = event
+                                && *key == Key::Named(NamedKey::Escape)
+                            {
+                                context_menu.set(None);
                             }
                         })
                         .on_event_stop(EventListener::PointerEnter, move |_| {
@@ -1586,10 +1581,10 @@ fn context_menu_view(
     })
     .on_event_stop(EventListener::PointerMove, move |_| {})
     .on_event_stop(EventListener::KeyDown, move |event| {
-        if let Event::Key(KeyboardEvent { key, .. }) = event {
-            if *key == Key::Named(NamedKey::Escape) {
-                context_menu.set(None);
-            }
+        if let Event::Key(KeyboardEvent { key, .. }) = event
+            && *key == Key::Named(NamedKey::Escape)
+        {
+            context_menu.set(None);
         }
     })
     .style(move |s| {