zed/test.rs

#![feature(prelude_import)]
#![allow(dead_code, unused_variables)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use color::black;
use components::button;
use element::Element;
use frame::frame;
use gpui::{
    geometry::{rect::RectF, vector::vec2f},
    platform::WindowOptions,
};
use log::LevelFilter;
use simplelog::SimpleLogger;
use themes::{rose_pine, ThemeColors};
use view::view;
mod adapter {
    use crate::element::AnyElement;
    use crate::element::{LayoutContext, PaintContext};
    use gpui::{geometry::rect::RectF, LayoutEngine};
    use util::ResultExt;
    pub struct Adapter<V>(pub(crate) AnyElement<V>);
    impl<V: 'static> gpui::Element<V> for Adapter<V> {
        type LayoutState = Option<LayoutEngine>;
        type PaintState = ();
        fn layout(
            &mut self,
            constraint: gpui::SizeConstraint,
            view: &mut V,
            cx: &mut LayoutContext<V>,
        ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
            cx.push_layout_engine(LayoutEngine::new());
            let node = self.0.layout(view, cx).log_err();
            if let Some(node) = node {
                let layout_engine = cx.layout_engine().unwrap();
                layout_engine.compute_layout(node, constraint.max).log_err();
            }
            let layout_engine = cx.pop_layout_engine();
            if true {
                if !layout_engine.is_some() {
                    ::core::panicking::panic("assertion failed: layout_engine.is_some()")
                }
            }
            (constraint.max, layout_engine)
        }
        fn paint(
            &mut self,
            scene: &mut gpui::SceneBuilder,
            bounds: RectF,
            visible_bounds: RectF,
            layout_engine: &mut Option<LayoutEngine>,
            view: &mut V,
            legacy_cx: &mut gpui::PaintContext<V>,
        ) -> Self::PaintState {
            legacy_cx.push_layout_engine(layout_engine.take().unwrap());
            let mut cx = PaintContext::new(legacy_cx, scene);
            self.0.paint(view, &mut cx).log_err();
            *layout_engine = legacy_cx.pop_layout_engine();
            if true {
                if !layout_engine.is_some() {
                    ::core::panicking::panic("assertion failed: layout_engine.is_some()")
                }
            }
        }
        fn rect_for_text_range(
            &self,
            range_utf16: std::ops::Range<usize>,
            bounds: RectF,
            visible_bounds: RectF,
            layout: &Self::LayoutState,
            paint: &Self::PaintState,
            view: &V,
            cx: &gpui::ViewContext<V>,
        ) -> Option<RectF> {
            ::core::panicking::panic("not yet implemented")
        }
        fn debug(
            &self,
            bounds: RectF,
            layout: &Self::LayoutState,
            paint: &Self::PaintState,
            view: &V,
            cx: &gpui::ViewContext<V>,
        ) -> gpui::serde_json::Value {
            ::core::panicking::panic("not yet implemented")
        }
    }
}
mod color {
    #![allow(dead_code)]
    use smallvec::SmallVec;
    use std::{num::ParseIntError, ops::Range};
    pub fn rgb<C: From<Rgba>>(hex: u32) -> C {
        let r = ((hex >> 16) & 0xFF) as f32 / 255.0;
        let g = ((hex >> 8) & 0xFF) as f32 / 255.0;
        let b = (hex & 0xFF) as f32 / 255.0;
        Rgba { r, g, b, a: 1.0 }.into()
    }
    pub struct Rgba {
        pub r: f32,
        pub g: f32,
        pub b: f32,
        pub a: f32,
    }
    #[automatically_derived]
    impl ::core::clone::Clone for Rgba {
        #[inline]
        fn clone(&self) -> Rgba {
            let _: ::core::clone::AssertParamIsClone<f32>;
            *self
        }
    }
    #[automatically_derived]
    impl ::core::marker::Copy for Rgba {}
    #[automatically_derived]
    impl ::core::default::Default for Rgba {
        #[inline]
        fn default() -> Rgba {
            Rgba {
                r: ::core::default::Default::default(),
                g: ::core::default::Default::default(),
                b: ::core::default::Default::default(),
                a: ::core::default::Default::default(),
            }
        }
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for Rgba {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field4_finish(
                f, "Rgba", "r", &self.r, "g", &self.g, "b", &self.b, "a", &&self.a,
            )
        }
    }
    pub trait Lerp {
        fn lerp(&self, level: f32) -> Hsla;
    }
    impl Lerp for Range<Hsla> {
        fn lerp(&self, level: f32) -> Hsla {
            let level = level.clamp(0., 1.);
            Hsla {
                h: self.start.h + (level * (self.end.h - self.start.h)),
                s: self.start.s + (level * (self.end.s - self.start.s)),
                l: self.start.l + (level * (self.end.l - self.start.l)),
                a: self.start.a + (level * (self.end.a - self.start.a)),
            }
        }
    }
    impl From<gpui::color::Color> for Rgba {
        fn from(value: gpui::color::Color) -> Self {
            Self {
                r: value.0.r as f32 / 255.0,
                g: value.0.g as f32 / 255.0,
                b: value.0.b as f32 / 255.0,
                a: value.0.a as f32 / 255.0,
            }
        }
    }
    impl From<Hsla> for Rgba {
        fn from(color: Hsla) -> Self {
            let h = color.h;
            let s = color.s;
            let l = color.l;
            let c = (1.0 - (2.0 * l - 1.0).abs()) * s;
            let x = c * (1.0 - ((h * 6.0) % 2.0 - 1.0).abs());
            let m = l - c / 2.0;
            let cm = c + m;
            let xm = x + m;
            let (r, g, b) = match (h * 6.0).floor() as i32 {
                0 | 6 => (cm, xm, m),
                1 => (xm, cm, m),
                2 => (m, cm, xm),
                3 => (m, xm, cm),
                4 => (xm, m, cm),
                _ => (cm, m, xm),
            };
            Rgba {
                r,
                g,
                b,
                a: color.a,
            }
        }
    }
    impl TryFrom<&'_ str> for Rgba {
        type Error = ParseIntError;
        fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
            let r = u8::from_str_radix(&value[1..3], 16)? as f32 / 255.0;
            let g = u8::from_str_radix(&value[3..5], 16)? as f32 / 255.0;
            let b = u8::from_str_radix(&value[5..7], 16)? as f32 / 255.0;
            let a = if value.len() > 7 {
                u8::from_str_radix(&value[7..9], 16)? as f32 / 255.0
            } else {
                1.0
            };
            Ok(Rgba { r, g, b, a })
        }
    }
    impl Into<gpui::color::Color> for Rgba {
        fn into(self) -> gpui::color::Color {
            gpui::color::rgba(self.r, self.g, self.b, self.a)
        }
    }
    pub struct Hsla {
        pub h: f32,
        pub s: f32,
        pub l: f32,
        pub a: f32,
    }
    #[automatically_derived]
    impl ::core::default::Default for Hsla {
        #[inline]
        fn default() -> Hsla {
            Hsla {
                h: ::core::default::Default::default(),
                s: ::core::default::Default::default(),
                l: ::core::default::Default::default(),
                a: ::core::default::Default::default(),
            }
        }
    }
    #[automatically_derived]
    impl ::core::marker::Copy for Hsla {}
    #[automatically_derived]
    impl ::core::clone::Clone for Hsla {
        #[inline]
        fn clone(&self) -> Hsla {
            let _: ::core::clone::AssertParamIsClone<f32>;
            *self
        }
    }
    #[automatically_derived]
    impl ::core::fmt::Debug for Hsla {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            ::core::fmt::Formatter::debug_struct_field4_finish(
                f, "Hsla", "h", &self.h, "s", &self.s, "l", &self.l, "a", &&self.a,
            )
        }
    }
    #[automatically_derived]
    impl ::core::marker::StructuralPartialEq for Hsla {}
    #[automatically_derived]
    impl ::core::cmp::PartialEq for Hsla {
        #[inline]
        fn eq(&self, other: &Hsla) -> bool {
            self.h == other.h && self.s == other.s && self.l == other.l && self.a == other.a
        }
    }
    pub fn hsla(h: f32, s: f32, l: f32, a: f32) -> Hsla {
        Hsla {
            h: h.clamp(0., 1.),
            s: s.clamp(0., 1.),
            l: l.clamp(0., 1.),
            a: a.clamp(0., 1.),
        }
    }
    pub fn black() -> Hsla {
        Hsla {
            h: 0.,
            s: 0.,
            l: 0.,
            a: 1.,
        }
    }
    impl From<Rgba> for Hsla {
        fn from(color: Rgba) -> Self {
            let r = color.r;
            let g = color.g;
            let b = color.b;
            let max = r.max(g.max(b));
            let min = r.min(g.min(b));
            let delta = max - min;
            let l = (max + min) / 2.0;
            let s = if l == 0.0 || l == 1.0 {
                0.0
            } else if l < 0.5 {
                delta / (2.0 * l)
            } else {
                delta / (2.0 - 2.0 * l)
            };
            let h = if delta == 0.0 {
                0.0
            } else if max == r {
                ((g - b) / delta).rem_euclid(6.0) / 6.0
            } else if max == g {
                ((b - r) / delta + 2.0) / 6.0
            } else {
                ((r - g) / delta + 4.0) / 6.0
            };
            Hsla {
                h,
                s,
                l,
                a: color.a,
            }
        }
    }
    impl Hsla {
        /// Scales the saturation and lightness by the given values, clamping at 1.0.
        pub fn scale_sl(mut self, s: f32, l: f32) -> Self {
            self.s = (self.s * s).clamp(0., 1.);
            self.l = (self.l * l).clamp(0., 1.);
            self
        }
        /// Increases the saturation of the color by a certain amount, with a max
        /// value of 1.0.
        pub fn saturate(mut self, amount: f32) -> Self {
            self.s += amount;
            self.s = self.s.clamp(0.0, 1.0);
            self
        }
        /// Decreases the saturation of the color by a certain amount, with a min
        /// value of 0.0.
        pub fn desaturate(mut self, amount: f32) -> Self {
            self.s -= amount;
            self.s = self.s.max(0.0);
            if self.s < 0.0 {
                self.s = 0.0;
            }
            self
        }
        /// Brightens the color by increasing the lightness by a certain amount,
        /// with a max value of 1.0.
        pub fn brighten(mut self, amount: f32) -> Self {
            self.l += amount;
            self.l = self.l.clamp(0.0, 1.0);
            self
        }
        /// Darkens the color by decreasing the lightness by a certain amount,
        /// with a max value of 0.0.
        pub fn darken(mut self, amount: f32) -> Self {
            self.l -= amount;
            self.l = self.l.clamp(0.0, 1.0);
            self
        }
    }
    impl From<gpui::color::Color> for Hsla {
        fn from(value: gpui::color::Color) -> Self {
            Rgba::from(value).into()
        }
    }
    impl Into<gpui::color::Color> for Hsla {
        fn into(self) -> gpui::color::Color {
            Rgba::from(self).into()
        }
    }
    pub struct ColorScale {
        colors: SmallVec<[Hsla; 2]>,
        positions: SmallVec<[f32; 2]>,
    }
    pub fn scale<I, C>(colors: I) -> ColorScale
    where
        I: IntoIterator<Item = C>,
        C: Into<Hsla>,
    {
        let mut scale = ColorScale {
            colors: colors.into_iter().map(Into::into).collect(),
            positions: SmallVec::new(),
        };
        let num_colors: f32 = scale.colors.len() as f32 - 1.0;
        scale.positions = (0..scale.colors.len())
            .map(|i| i as f32 / num_colors)
            .collect();
        scale
    }
    impl ColorScale {
        fn at(&self, t: f32) -> Hsla {
            if true {
                if !(0.0 <= t && t <= 1.0) {
                    {
                        ::core::panicking::panic_fmt(format_args!(
                            "t value {0} is out of range. Expected value in range 0.0 to 1.0",
                            t,
                        ));
                    }
                }
            }
            let position = match self
                .positions
                .binary_search_by(|a| a.partial_cmp(&t).unwrap())
            {
                Ok(index) | Err(index) => index,
            };
            let lower_bound = position.saturating_sub(1);
            let upper_bound = position.min(self.colors.len() - 1);
            let lower_color = &self.colors[lower_bound];
            let upper_color = &self.colors[upper_bound];
            match upper_bound.checked_sub(lower_bound) {
                Some(0) | None => *lower_color,
                Some(_) => {
                    let interval_t = (t - self.positions[lower_bound])
                        / (self.positions[upper_bound] - self.positions[lower_bound]);
                    let h = lower_color.h + interval_t * (upper_color.h - lower_color.h);
                    let s = lower_color.s + interval_t * (upper_color.s - lower_color.s);
                    let l = lower_color.l + interval_t * (upper_color.l - lower_color.l);
                    let a = lower_color.a + interval_t * (upper_color.a - lower_color.a);
                    Hsla { h, s, l, a }
                }
            }
        }
    }
}
mod components {
    use crate::{
        element::{Element, ElementMetadata},
        frame,
        text::ArcCow,
        themes::rose_pine,
    };
    use gpui::{platform::MouseButton, ViewContext};
    use gpui2_macros::Element;
    use std::{marker::PhantomData, rc::Rc};
    struct ButtonHandlers<V, D> {
        click: Option<Rc<dyn Fn(&mut V, &D, &mut ViewContext<V>)>>,
    }
    impl<V, D> Default for ButtonHandlers<V, D> {
        fn default() -> Self {
            Self { click: None }
        }
    }
    #[element_crate = "crate"]
    pub struct Button<V: 'static, D: 'static> {
        metadata: ElementMetadata<V>,
        handlers: ButtonHandlers<V, D>,
        label: Option<ArcCow<'static, str>>,
        icon: Option<ArcCow<'static, str>>,
        data: Rc<D>,
        view_type: PhantomData<V>,
    }
    impl<V: 'static, D: 'static> crate::element::Element<V> for Button<V, D> {
        type Layout = crate::element::AnyElement<V>;
        fn declared_style(&mut self) -> &mut crate::style::OptionalStyle {
            &mut self.metadata.style
        }
        fn handlers_mut(&mut self) -> &mut Vec<crate::element::EventHandler<V>> {
            &mut self.metadata.handlers
        }
        fn layout(
            &mut self,
            view: &mut V,
            cx: &mut crate::element::LayoutContext<V>,
        ) -> anyhow::Result<(taffy::tree::NodeId, Self::Layout)> {
            let mut element = self.render(view, cx).into_any();
            let node_id = element.layout(view, cx)?;
            Ok((node_id, element))
        }
        fn paint<'a>(
            &mut self,
            layout: crate::element::Layout<'a, Self::Layout>,
            view: &mut V,
            cx: &mut crate::element::PaintContext<V>,
        ) -> anyhow::Result<()> {
            layout.from_element.paint(view, cx)?;
            Ok(())
        }
    }
    impl<V: 'static, D: 'static> crate::element::IntoElement<V> for Button<V, D> {
        type Element = Self;
        fn into_element(self) -> Self {
            self
        }
    }
    impl<V: 'static> Button<V, ()> {
        fn new() -> Self {
            Self {
                metadata: Default::default(),
                handlers: ButtonHandlers::default(),
                label: None,
                icon: None,
                data: Rc::new(()),
                view_type: PhantomData,
            }
        }
        pub fn data<D: 'static>(self, data: D) -> Button<V, D> {
            Button {
                metadata: Default::default(),
                handlers: ButtonHandlers::default(),
                label: self.label,
                icon: self.icon,
                data: Rc::new(data),
                view_type: PhantomData,
            }
        }
    }
    impl<V: 'static, D: 'static> Button<V, D> {
        pub fn label(mut self, label: impl Into<ArcCow<'static, str>>) -> Self {
            self.label = Some(label.into());
            self
        }
        pub fn icon(mut self, icon: impl Into<ArcCow<'static, str>>) -> Self {
            self.icon = Some(icon.into());
            self
        }
        pub fn click(self, handler: impl Fn(&mut V, &D, &mut ViewContext<V>) + 'static) -> Self {
            let data = self.data.clone();
            Element::click(self, MouseButton::Left, move |view, _, cx| {
                handler(view, data.as_ref(), cx);
            })
        }
    }
    pub fn button<V>() -> Button<V, ()> {
        Button::new()
    }
    impl<V: 'static, D: 'static> Button<V, D> {
        fn render(&mut self, view: &mut V, cx: &mut ViewContext<V>) -> impl Element<V> {
            let button = frame()
                .fill(rose_pine::dawn().error(0.5))
                .h_4()
                .children(self.label.clone());
            if let Some(handler) = self.handlers.click.clone() {
                let data = self.data.clone();
                button.mouse_down(MouseButton::Left, move |view, event, cx| {
                    handler(view, data.as_ref(), cx)
                })
            } else {
                button
            }
        }
    }
}
mod element {
    pub use crate::paint_context::PaintContext;
    use crate::{
        adapter::Adapter,
        color::Hsla,
        hoverable::Hoverable,
        style::{Display, Fill, OptionalStyle, Overflow, Position},
    };
    use anyhow::Result;
    pub use gpui::LayoutContext;
    use gpui::{
        geometry::{DefinedLength, Length, OptionalPoint},
        platform::{MouseButton, MouseButtonEvent},
        EngineLayout, EventContext, RenderContext, ViewContext,
    };
    use gpui2_macros::tailwind_lengths;
    use std::{
        any::{Any, TypeId},
        cell::Cell,
        rc::Rc,
    };
    pub use taffy::tree::NodeId;
    pub struct Layout<'a, E: ?Sized> {
        pub from_engine: EngineLayout,
        pub from_element: &'a mut E,
    }
    pub struct ElementMetadata<V> {
        pub style: OptionalStyle,
        pub handlers: Vec<EventHandler<V>>,
    }
    pub struct EventHandler<V> {
        handler: Rc<dyn Fn(&mut V, &dyn Any, &mut EventContext<V>)>,
        event_type: TypeId,
        outside_bounds: bool,
    }
    impl<V> Clone for EventHandler<V> {
        fn clone(&self) -> Self {
            Self {
                handler: self.handler.clone(),
                event_type: self.event_type,
                outside_bounds: self.outside_bounds,
            }
        }
    }
    impl<V> Default for ElementMetadata<V> {
        fn default() -> Self {
            Self {
                style: OptionalStyle::default(),
                handlers: Vec::new(),
            }
        }
    }
    pub trait Element<V: 'static>: 'static {
        type Layout: 'static;
        fn declared_style(&mut self) -> &mut OptionalStyle;
        fn computed_style(&mut self) -> &OptionalStyle {
            self.declared_style()
        }
        fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>>;
        fn layout(
            &mut self,
            view: &mut V,
            cx: &mut LayoutContext<V>,
        ) -> Result<(NodeId, Self::Layout)>;
        fn paint<'a>(
            &mut self,
            layout: Layout<Self::Layout>,
            view: &mut V,
            cx: &mut PaintContext<V>,
        ) -> Result<()>;
        /// Convert to a dynamically-typed element suitable for layout and paint.
        fn into_any(self) -> AnyElement<V>
        where
            Self: 'static + Sized,
        {
            AnyElement {
                element: Box::new(self) as Box<dyn ElementObject<V>>,
                layout: None,
            }
        }
        fn adapt(self) -> Adapter<V>
        where
            Self: Sized,
            Self: Element<V>,
        {
            Adapter(self.into_any())
        }
        fn click(
            self,
            button: MouseButton,
            handler: impl Fn(&mut V, &MouseButtonEvent, &mut ViewContext<V>) + 'static,
        ) -> Self
        where
            Self: Sized,
        {
            let pressed: Rc<Cell<bool>> = Default::default();
            self.mouse_down(button, {
                let pressed = pressed.clone();
                move |_, _, _| {
                    pressed.set(true);
                }
            })
            .mouse_up_outside(button, {
                let pressed = pressed.clone();
                move |_, _, _| {
                    pressed.set(false);
                }
            })
            .mouse_up(button, move |view, event, event_cx| {
                if pressed.get() {
                    pressed.set(false);
                    handler(view, event, event_cx);
                }
            })
        }
        fn mouse_down(
            mut self,
            button: MouseButton,
            handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
        ) -> Self
        where
            Self: Sized,
        {
            self.handlers_mut().push(EventHandler {
                handler: Rc::new(move |view, event, event_cx| {
                    let event = event.downcast_ref::<MouseButtonEvent>().unwrap();
                    if event.button == button && event.is_down {
                        handler(view, event, event_cx);
                    }
                }),
                event_type: TypeId::of::<MouseButtonEvent>(),
                outside_bounds: false,
            });
            self
        }
        fn mouse_down_outside(
            mut self,
            button: MouseButton,
            handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
        ) -> Self
        where
            Self: Sized,
        {
            self.handlers_mut().push(EventHandler {
                handler: Rc::new(move |view, event, event_cx| {
                    let event = event.downcast_ref::<MouseButtonEvent>().unwrap();
                    if event.button == button && event.is_down {
                        handler(view, event, event_cx);
                    }
                }),
                event_type: TypeId::of::<MouseButtonEvent>(),
                outside_bounds: true,
            });
            self
        }
        fn mouse_up(
            mut self,
            button: MouseButton,
            handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
        ) -> Self
        where
            Self: Sized,
        {
            self.handlers_mut().push(EventHandler {
                handler: Rc::new(move |view, event, event_cx| {
                    let event = event.downcast_ref::<MouseButtonEvent>().unwrap();
                    if event.button == button && !event.is_down {
                        handler(view, event, event_cx);
                    }
                }),
                event_type: TypeId::of::<MouseButtonEvent>(),
                outside_bounds: false,
            });
            self
        }
        fn mouse_up_outside(
            mut self,
            button: MouseButton,
            handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
        ) -> Self
        where
            Self: Sized,
        {
            self.handlers_mut().push(EventHandler {
                handler: Rc::new(move |view, event, event_cx| {
                    let event = event.downcast_ref::<MouseButtonEvent>().unwrap();
                    if event.button == button && !event.is_down {
                        handler(view, event, event_cx);
                    }
                }),
                event_type: TypeId::of::<MouseButtonEvent>(),
                outside_bounds: true,
            });
            self
        }
        fn block(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().display = Some(Display::Block);
            self
        }
        fn flex(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().display = Some(Display::Flex);
            self
        }
        fn grid(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().display = Some(Display::Grid);
            self
        }
        fn overflow_visible(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow = OptionalPoint {
                x: Some(Overflow::Visible),
                y: Some(Overflow::Visible),
            };
            self
        }
        fn overflow_hidden(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow = OptionalPoint {
                x: Some(Overflow::Hidden),
                y: Some(Overflow::Hidden),
            };
            self
        }
        fn overflow_scroll(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow = OptionalPoint {
                x: Some(Overflow::Scroll),
                y: Some(Overflow::Scroll),
            };
            self
        }
        fn overflow_x_visible(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow.x = Some(Overflow::Visible);
            self
        }
        fn overflow_x_hidden(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow.x = Some(Overflow::Hidden);
            self
        }
        fn overflow_x_scroll(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow.x = Some(Overflow::Scroll);
            self
        }
        fn overflow_y_visible(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow.y = Some(Overflow::Visible);
            self
        }
        fn overflow_y_hidden(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow.y = Some(Overflow::Hidden);
            self
        }
        fn overflow_y_scroll(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().overflow.y = Some(Overflow::Scroll);
            self
        }
        fn relative(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().position = Some(Position::Relative);
            self
        }
        fn absolute(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().position = Some(Position::Absolute);
            self
        }
        fn inset_0(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Pixels(0.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_px(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Pixels(1.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_0_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.125).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_1(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.25).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_1_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.375).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_2(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.5).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_2_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.625).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_3(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.75).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_3_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.875).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_4(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.25).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_6(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.5).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_7(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.75).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_8(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_9(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.25).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_10(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.5).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_11(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.75).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_12(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(3.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_14(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(3.5).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_16(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(4.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_20(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(5.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_24(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(6.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_28(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(7.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_32(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(8.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_36(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(9.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_40(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(10.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_44(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(11.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_48(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(12.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_52(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(13.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_56(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(14.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_60(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(15.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_64(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(16.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_72(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(18.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_80(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(20.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_96(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(24.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_half(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_1_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_2_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_1_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(25.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_2_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_3_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(75.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_1_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(20.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_2_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(40.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_3_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(60.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_4_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(80.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_1_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(16.666667).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_2_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_3_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_4_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_5_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(83.333333).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_1_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(8.333333).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_2_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(16.666667).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_3_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(25.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_4_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_5_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(41.666667).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_6_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_7_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(58.333333).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_8_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_9_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(75.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_10_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(83.333333).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_11_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(91.666667).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn inset_full(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(100.).into();
            {
                let inset = self
                    .computed_style()
                    .inset
                    .get_or_insert_with(Default::default);
                inset.top = length;
                inset.right = length;
                inset.bottom = length;
                inset.left = length;
                self
            }
        }
        fn w(mut self, width: impl Into<Length>) -> Self
        where
            Self: Sized,
        {
            self.declared_style().size.width = Some(width.into());
            self
        }
        fn w_auto(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().size.width = Some(Length::Auto);
            self
        }
        fn w_0(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Pixels(0.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_px(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Pixels(1.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_0_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.125).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_1(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.25).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_1_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.375).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_2(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.5).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_2_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.625).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_3(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.75).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_3_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.875).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_4(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.25).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_6(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.5).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_7(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.75).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_8(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_9(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.25).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_10(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.5).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_11(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.75).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_12(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(3.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_14(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(3.5).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_16(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(4.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_20(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(5.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_24(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(6.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_28(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(7.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_32(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(8.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_36(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(9.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_40(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(10.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_44(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(11.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_48(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(12.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_52(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(13.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_56(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(14.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_60(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(15.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_64(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(16.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_72(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(18.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_80(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(20.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_96(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(24.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_half(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_1_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_2_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_1_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(25.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_2_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_3_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(75.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_1_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(20.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_2_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(40.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_3_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(60.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_4_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(80.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_1_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(16.666667).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_2_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_3_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_4_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_5_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(83.333333).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_1_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(8.333333).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_2_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(16.666667).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_3_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(25.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_4_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_5_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(41.666667).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_6_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_7_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(58.333333).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_8_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_9_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(75.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_10_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(83.333333).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_11_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(91.666667).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn w_full(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(100.).into();
            {
                self.declared_style().size.width = Some(length);
                self
            }
        }
        fn min_w_0(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Pixels(0.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_px(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Pixels(1.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_0_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.125).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_1(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.25).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_1_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.375).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_2(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.5).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_2_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.625).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_3(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.75).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_3_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.875).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_4(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.25).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_6(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.5).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_7(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.75).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_8(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_9(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.25).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_10(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.5).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_11(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.75).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_12(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(3.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_14(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(3.5).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_16(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(4.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_20(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(5.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_24(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(6.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_28(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(7.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_32(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(8.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_36(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(9.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_40(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(10.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_44(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(11.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_48(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(12.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_52(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(13.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_56(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(14.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_60(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(15.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_64(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(16.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_72(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(18.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_80(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(20.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_96(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(24.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_half(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_1_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_2_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_1_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(25.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_2_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_3_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(75.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_1_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(20.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_2_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(40.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_3_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(60.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_4_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(80.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_1_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(16.666667).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_2_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_3_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_4_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_5_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(83.333333).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_1_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(8.333333).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_2_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(16.666667).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_3_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(25.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_4_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_5_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(41.666667).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_6_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_7_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(58.333333).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_8_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_9_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(75.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_10_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(83.333333).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_11_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(91.666667).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn min_w_full(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(100.).into();
            {
                self.declared_style().min_size.width = Some(length);
                self
            }
        }
        fn h(mut self, height: impl Into<Length>) -> Self
        where
            Self: Sized,
        {
            self.declared_style().size.height = Some(height.into());
            self
        }
        fn h_auto(mut self) -> Self
        where
            Self: Sized,
        {
            self.declared_style().size.height = Some(Length::Auto);
            self
        }
        fn h_0(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Pixels(0.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_px(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Pixels(1.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_0_5(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(0.125).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_1(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(0.25).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_1_5(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(0.375).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_2(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(0.5).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_2_5(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(0.625).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_3(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(0.75).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_3_5(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(0.875).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_4(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(1.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_5(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(1.25).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_6(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(1.5).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_7(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(1.75).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_8(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(2.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_9(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(2.25).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_10(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(2.5).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_11(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(2.75).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_12(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(3.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_14(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(3.5).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_16(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(4.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_20(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(5.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_24(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(6.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_28(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(7.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_32(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(8.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_36(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(9.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_40(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(10.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_44(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(11.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_48(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(12.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_52(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(13.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_56(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(14.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_60(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(15.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_64(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(16.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_72(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(18.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_80(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(20.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_96(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Rems(24.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_half(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(50.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_1_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_2_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_1_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(25.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_2_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(50.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_3_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(75.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_1_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(20.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_2_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(40.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_3_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(60.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_4_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(80.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_1_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(16.666667).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_2_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_3_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(50.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_4_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_5_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(83.333333).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_1_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(8.333333).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_2_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(16.666667).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_3_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(25.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_4_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_5_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(41.666667).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_6_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(50.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_7_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(58.333333).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_8_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_9_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(75.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_10_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(83.333333).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_11_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(91.666667).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn h_full(mut self) -> Self
        where
            Self: Sized,
        {
            let height = DefinedLength::Percent(100.).into();
            {
                self.declared_style().size.height = Some(height);
                self
            }
        }
        fn min_h_0(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Pixels(0.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_px(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Pixels(1.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_0_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.125).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_1(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.25).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_1_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.375).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_2(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.5).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_2_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.625).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_3(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.75).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_3_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(0.875).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_4(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_5(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.25).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_6(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.5).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_7(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(1.75).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_8(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_9(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.25).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_10(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.5).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_11(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(2.75).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_12(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(3.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_14(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(3.5).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_16(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(4.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_20(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(5.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_24(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(6.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_28(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(7.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_32(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(8.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_36(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(9.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_40(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(10.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_44(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(11.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_48(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(12.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_52(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(13.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_56(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(14.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_60(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(15.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_64(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(16.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_72(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(18.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_80(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(20.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_96(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Rems(24.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_half(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_1_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_2_3rd(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_1_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(25.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_2_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_3_4th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(75.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_1_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(20.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_2_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(40.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_3_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(60.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_4_5th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(80.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_1_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(16.666667).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_2_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_3_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_4_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_5_6th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(83.333333).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_1_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(8.333333).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_2_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(16.666667).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_3_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(25.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_4_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(33.333333).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_5_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(41.666667).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_6_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(50.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_7_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(58.333333).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_8_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(66.666667).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_9_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(75.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_10_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(83.333333).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_11_12th(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(91.666667).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn min_h_full(mut self) -> Self
        where
            Self: Sized,
        {
            let length = DefinedLength::Percent(100.).into();
            {
                self.declared_style().min_size.height = Some(length);
                self
            }
        }
        fn hoverable(self) -> Hoverable<V, Self>
        where
            Self: Sized,
        {
            Hoverable::new(self)
        }
        fn fill(mut self, fill: impl Into<Fill>) -> Self
        where
            Self: Sized,
        {
            self.declared_style().fill = Some(Some(fill.into()));
            self
        }
        fn text_color(mut self, color: impl Into<Hsla>) -> Self
        where
            Self: Sized,
        {
            self.declared_style().text_color = Some(Some(color.into()));
            self
        }
    }
    trait ElementObject<V> {
        fn style(&mut self) -> &mut OptionalStyle;
        fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>>;
        fn layout(
            &mut self,
            view: &mut V,
            cx: &mut LayoutContext<V>,
        ) -> Result<(NodeId, Box<dyn Any>)>;
        fn paint(
            &mut self,
            layout: Layout<dyn Any>,
            view: &mut V,
            cx: &mut PaintContext<V>,
        ) -> Result<()>;
    }
    impl<V: 'static, E: Element<V>> ElementObject<V> for E {
        fn style(&mut self) -> &mut OptionalStyle {
            Element::declared_style(self)
        }
        fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>> {
            Element::handlers_mut(self)
        }
        fn layout(
            &mut self,
            view: &mut V,
            cx: &mut LayoutContext<V>,
        ) -> Result<(NodeId, Box<dyn Any>)> {
            let (node_id, layout) = self.layout(view, cx)?;
            let layout = Box::new(layout) as Box<dyn Any>;
            Ok((node_id, layout))
        }
        fn paint(
            &mut self,
            layout: Layout<dyn Any>,
            view: &mut V,
            cx: &mut PaintContext<V>,
        ) -> Result<()> {
            let layout = Layout {
                from_engine: layout.from_engine,
                from_element: layout.from_element.downcast_mut::<E::Layout>().unwrap(),
            };
            self.paint(layout, view, cx)
        }
    }
    /// A dynamically typed element.
    pub struct AnyElement<V> {
        element: Box<dyn ElementObject<V>>,
        layout: Option<(NodeId, Box<dyn Any>)>,
    }
    impl<V: 'static> AnyElement<V> {
        pub fn layout(&mut self, view: &mut V, cx: &mut LayoutContext<V>) -> Result<NodeId> {
            let pushed_text_style = self.push_text_style(cx);
            let (node_id, layout) = self.element.layout(view, cx)?;
            self.layout = Some((node_id, layout));
            if pushed_text_style {
                cx.pop_text_style();
            }
            Ok(node_id)
        }
        pub fn push_text_style(&mut self, cx: &mut impl RenderContext) -> bool {
            let text_style = self.element.style().text_style();
            if let Some(text_style) = text_style {
                let mut current_text_style = cx.text_style();
                text_style.apply(&mut current_text_style);
                cx.push_text_style(current_text_style);
                true
            } else {
                false
            }
        }
        pub fn paint(&mut self, view: &mut V, cx: &mut PaintContext<V>) -> Result<()> {
            let pushed_text_style = self.push_text_style(cx);
            let (layout_node_id, element_layout) =
                self.layout.as_mut().expect("paint called before layout");
            let layout = Layout {
                from_engine: cx
                    .layout_engine()
                    .unwrap()
                    .computed_layout(*layout_node_id)
                    .expect("make sure you're using this within a gpui2 adapter element"),
                from_element: element_layout.as_mut(),
            };
            let style = self.element.style();
            let fill_color = style.fill.flatten().and_then(|fill| fill.color());
            if let Some(fill_color) = fill_color {
                cx.scene.push_quad(gpui::scene::Quad {
                    bounds: layout.from_engine.bounds,
                    background: Some(fill_color.into()),
                    border: Default::default(),
                    corner_radii: Default::default(),
                });
            }
            for event_handler in self.element.handlers_mut().iter().cloned() {
                let EngineLayout { order, bounds } = layout.from_engine;
                let view_id = cx.view_id();
                let view_event_handler = event_handler.handler.clone();
                cx.scene
                    .interactive_regions
                    .push(gpui::scene::InteractiveRegion {
                        order,
                        bounds,
                        outside_bounds: event_handler.outside_bounds,
                        event_handler: Rc::new(move |view, event, window_cx, view_id| {
                            let mut view_context = ViewContext::mutable(window_cx, view_id);
                            let mut event_context = EventContext::new(&mut view_context);
                            view_event_handler(
                                view.downcast_mut().unwrap(),
                                event,
                                &mut event_context,
                            );
                        }),
                        event_type: event_handler.event_type,
                        view_id,
                    });
            }
            self.element.paint(layout, view, cx)?;
            if pushed_text_style {
                cx.pop_text_style();
            }
            Ok(())
        }
    }
    impl<V: 'static> Element<V> for AnyElement<V> {
        type Layout = ();
        fn declared_style(&mut self) -> &mut OptionalStyle {
            self.element.style()
        }
        fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>> {
            self.element.handlers_mut()
        }
        fn layout(
            &mut self,
            view: &mut V,
            cx: &mut LayoutContext<V>,
        ) -> Result<(NodeId, Self::Layout)> {
            Ok((self.layout(view, cx)?, ()))
        }
        fn paint(
            &mut self,
            layout: Layout<()>,
            view: &mut V,
            cx: &mut PaintContext<V>,
        ) -> Result<()> {
            self.paint(view, cx)
        }
    }
    pub trait IntoElement<V: 'static> {
        type Element: Element<V>;
        fn into_element(self) -> Self::Element;
        fn into_any_element(self) -> AnyElement<V>
        where
            Self: Sized,
        {
            self.into_element().into_any()
        }
    }
}
mod frame {
    use crate::{
        element::{
            AnyElement, Element, EventHandler, IntoElement, Layout, LayoutContext, NodeId,
            PaintContext,
        },
        style::{OptionalStyle, Style},
    };
    use anyhow::{anyhow, Result};
    use gpui::LayoutNodeId;
    use gpui2_macros::IntoElement;
    #[element_crate = "crate"]
    pub struct Frame<V: 'static> {
        style: OptionalStyle,
        handlers: Vec<EventHandler<V>>,
        children: Vec<AnyElement<V>>,
    }
    impl<V: 'static> crate::element::IntoElement<V> for Frame<V> {
        type Element = Self;
        fn into_element(self) -> Self {
            self
        }
    }
    pub fn frame<V>() -> Frame<V> {
        Frame {
            style: OptionalStyle::default(),
            handlers: Vec::new(),
            children: Vec::new(),
        }
    }
    impl<V: 'static> Element<V> for Frame<V> {
        type Layout = ();
        fn declared_style(&mut self) -> &mut OptionalStyle {
            &mut self.style
        }
        fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>> {
            &mut self.handlers
        }
        fn layout(
            &mut self,
            view: &mut V,
            cx: &mut LayoutContext<V>,
        ) -> Result<(NodeId, Self::Layout)> {
            let child_layout_node_ids = self
                .children
                .iter_mut()
                .map(|child| child.layout(view, cx))
                .collect::<Result<Vec<LayoutNodeId>>>()?;
            let rem_size = cx.rem_pixels();
            let style: Style = self.style.into();
            let node_id = cx
                .layout_engine()
                .ok_or_else(|| {
                    ::anyhow::__private::must_use({
                        let error =
                            ::anyhow::__private::format_err(format_args!("no layout engine"));
                        error
                    })
                })?
                .add_node(style.to_taffy(rem_size), child_layout_node_ids)?;
            Ok((node_id, ()))
        }
        fn paint(
            &mut self,
            layout: Layout<()>,
            view: &mut V,
            cx: &mut PaintContext<V>,
        ) -> Result<()> {
            for child in &mut self.children {
                child.paint(view, cx)?;
            }
            Ok(())
        }
    }
    impl<V: 'static> Frame<V> {
        pub fn child(mut self, child: impl IntoElement<V>) -> Self {
            self.children.push(child.into_any_element());
            self
        }
        pub fn children<I, E>(mut self, children: I) -> Self
        where
            I: IntoIterator<Item = E>,
            E: IntoElement<V>,
        {
            self.children
                .extend(children.into_iter().map(|e| e.into_any_element()));
            self
        }
    }
}
mod hoverable {
    use crate::{
        element::Element,
        style::{OptionalStyle, Style},
    };
    use gpui::{
        geometry::{rect::RectF, vector::Vector2F},
        scene::MouseMove,
        EngineLayout,
    };
    use std::{cell::Cell, marker::PhantomData, rc::Rc};
    pub struct Hoverable<V, E> {
        hover_style: OptionalStyle,
        computed_style: Option<Style>,
        view_type: PhantomData<V>,
        child: E,
    }
    impl<V, E> Hoverable<V, E> {
        pub fn new(child: E) -> Self {
            Self {
                hover_style: OptionalStyle::default(),
                computed_style: None,
                view_type: PhantomData,
                child,
            }
        }
    }
    impl<V: 'static, E: Element<V>> Element<V> for Hoverable<V, E> {
        type Layout = E::Layout;
        fn declared_style(&mut self) -> &mut OptionalStyle {
            &mut self.hover_style
        }
        fn computed_style(&mut self) -> &OptionalStyle {
            ::core::panicking::panic("not yet implemented")
        }
        fn handlers_mut(&mut self) -> &mut Vec<crate::element::EventHandler<V>> {
            self.child.handlers_mut()
        }
        fn layout(
            &mut self,
            view: &mut V,
            cx: &mut gpui::LayoutContext<V>,
        ) -> anyhow::Result<(taffy::tree::NodeId, Self::Layout)> {
            self.child.layout(view, cx)
        }
        fn paint<'a>(
            &mut self,
            layout: crate::element::Layout<Self::Layout>,
            view: &mut V,
            cx: &mut crate::element::PaintContext<V>,
        ) -> anyhow::Result<()> {
            let EngineLayout { bounds, order } = layout.from_engine;
            let window_bounds = RectF::new(Vector2F::zero(), cx.window_size());
            let was_hovered = Rc::new(Cell::new(false));
            self.child.paint(layout, view, cx)?;
            cx.draw_interactive_region(
                order,
                window_bounds,
                false,
                move |view, event: &MouseMove, cx| {
                    let is_hovered = bounds.contains_point(cx.mouse_position());
                    if is_hovered != was_hovered.get() {
                        was_hovered.set(is_hovered);
                        cx.repaint();
                    }
                },
            );
            Ok(())
        }
    }
}
mod paint_context {
    use derive_more::{Deref, DerefMut};
    use gpui::{geometry::rect::RectF, EventContext, RenderContext, ViewContext};
    pub use gpui::{LayoutContext, PaintContext as LegacyPaintContext};
    use std::{any::TypeId, rc::Rc};
    pub use taffy::tree::NodeId;
    pub struct PaintContext<'a, 'b, 'c, 'd, V> {
        #[deref]
        #[deref_mut]
        pub(crate) legacy_cx: &'d mut LegacyPaintContext<'a, 'b, 'c, V>,
        pub(crate) scene: &'d mut gpui::SceneBuilder,
    }
    impl<'a, 'b, 'c, 'd, V> ::core::ops::Deref for PaintContext<'a, 'b, 'c, 'd, V> {
        type Target = &'d mut LegacyPaintContext<'a, 'b, 'c, V>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.legacy_cx
        }
    }
    impl<'a, 'b, 'c, 'd, V> ::core::ops::DerefMut for PaintContext<'a, 'b, 'c, 'd, V> {
        #[inline]
        fn deref_mut(&mut self) -> &mut Self::Target {
            &mut self.legacy_cx
        }
    }
    impl<V> RenderContext for PaintContext<'_, '_, '_, '_, V> {
        fn text_style(&self) -> gpui::fonts::TextStyle {
            self.legacy_cx.text_style()
        }
        fn push_text_style(&mut self, style: gpui::fonts::TextStyle) {
            self.legacy_cx.push_text_style(style)
        }
        fn pop_text_style(&mut self) {
            self.legacy_cx.pop_text_style()
        }
    }
    impl<'a, 'b, 'c, 'd, V: 'static> PaintContext<'a, 'b, 'c, 'd, V> {
        pub fn new(
            legacy_cx: &'d mut LegacyPaintContext<'a, 'b, 'c, V>,
            scene: &'d mut gpui::SceneBuilder,
        ) -> Self {
            Self { legacy_cx, scene }
        }
        pub fn draw_interactive_region<E: 'static>(
            &mut self,
            order: u32,
            bounds: RectF,
            outside_bounds: bool,
            event_handler: impl Fn(&mut V, &E, &mut EventContext<V>) + 'static,
        ) {
            self.scene
                .interactive_regions
                .push(gpui::scene::InteractiveRegion {
                    order,
                    bounds,
                    outside_bounds,
                    event_handler: Rc::new(move |view, event, window_cx, view_id| {
                        let mut view_context = ViewContext::mutable(window_cx, view_id);
                        let mut event_context = EventContext::new(&mut view_context);
                        event_handler(
                            view.downcast_mut().unwrap(),
                            event.downcast_ref().unwrap(),
                            &mut event_context,
                        );
                    }),
                    event_type: TypeId::of::<E>(),
                    view_id: self.view_id(),
                });
        }
    }
}
mod style {
    use crate::color::Hsla;
    use gpui::geometry::{
        DefinedLength, Edges, Length, OptionalEdges, OptionalPoint, OptionalSize, Point, Size,
    };
    use optional::Optional;
    pub use taffy::style::{
        AlignContent, AlignItems, AlignSelf, Display, FlexDirection, FlexWrap, JustifyContent,
        Overflow, Position,
    };
    pub struct Style {
        /// What layout strategy should be used?
        pub display: Display,
        /// How children overflowing their container should affect layout
        #[optional]
        pub overflow: Point<Overflow>,
        /// How much space (in points) should be reserved for the scrollbars of `Overflow::Scroll` and `Overflow::Auto` nodes.
        pub scrollbar_width: f32,
        /// What should the `position` value of this struct use as a base offset?
        pub position: Position,
        /// How should the position of this element be tweaked relative to the layout defined?
        pub inset: Edges<Length>,
        /// Sets the initial size of the item
        #[optional]
        pub size: Size<Length>,
        /// Controls the minimum size of the item
        #[optional]
        pub min_size: Size<Length>,
        /// Controls the maximum size of the item
        #[optional]
        pub max_size: Size<Length>,
        /// Sets the preferred aspect ratio for the item. The ratio is calculated as width divided by height.
        pub aspect_ratio: Option<f32>,
        /// How large should the margin be on each side?
        #[optional]
        pub margin: Edges<Length>,
        /// How large should the padding be on each side?
        pub padding: Edges<DefinedLength>,
        /// How large should the border be on each side?
        pub border: Edges<DefinedLength>,
        /// How this node's children aligned in the cross/block axis?
        pub align_items: Option<AlignItems>,
        /// How this node should be aligned in the cross/block axis. Falls back to the parents [`AlignItems`] if not set
        pub align_self: Option<AlignSelf>,
        /// How should content contained within this item be aligned in the cross/block axis
        pub align_content: Option<AlignContent>,
        /// How should contained within this item be aligned in the main/inline axis
        pub justify_content: Option<JustifyContent>,
        /// How large should the gaps between items in a flex container be?
        pub gap: Size<DefinedLength>,
        /// Which direction does the main axis flow in?
        pub flex_direction: FlexDirection,
        /// Should elements wrap, or stay in a single line?
        pub flex_wrap: FlexWrap,
        /// Sets the initial main axis size of the item
        pub flex_basis: Length,
        /// The relative rate at which this item grows when it is expanding to fill space, 0.0 is the default value, and this value must be positive.
        pub flex_grow: f32,
        /// The relative rate at which this item shrinks when it is contracting to fit into space, 1.0 is the default value, and this value must be positive.
        pub flex_shrink: f32,
        /// The fill color of this element
        pub fill: Option<Fill>,
        /// The color of text within this element. Cascades to children unless overridden.
        pub text_color: Option<Hsla>,
    }
    #[automatically_derived]
    impl ::core::clone::Clone for Style {
        #[inline]
        fn clone(&self) -> Style {
            Style {
                display: ::core::clone::Clone::clone(&self.display),
                overflow: ::core::clone::Clone::clone(&self.overflow),
                scrollbar_width: ::core::clone::Clone::clone(&self.scrollbar_width),
                position: ::core::clone::Clone::clone(&self.position),
                inset: ::core::clone::Clone::clone(&self.inset),
                size: ::core::clone::Clone::clone(&self.size),
                min_size: ::core::clone::Clone::clone(&self.min_size),
                max_size: ::core::clone::Clone::clone(&self.max_size),
                aspect_ratio: ::core::clone::Clone::clone(&self.aspect_ratio),
                margin: ::core::clone::Clone::clone(&self.margin),
                padding: ::core::clone::Clone::clone(&self.padding),
                border: ::core::clone::Clone::clone(&self.border),
                align_items: ::core::clone::Clone::clone(&self.align_items),
                align_self: ::core::clone::Clone::clone(&self.align_self),
                align_content: ::core::clone::Clone::clone(&self.align_content),
                justify_content: ::core::clone::Clone::clone(&self.justify_content),
                gap: ::core::clone::Clone::clone(&self.gap),
                flex_direction: ::core::clone::Clone::clone(&self.flex_direction),
                flex_wrap: ::core::clone::Clone::clone(&self.flex_wrap),
                flex_basis: ::core::clone::Clone::clone(&self.flex_basis),
                flex_grow: ::core::clone::Clone::clone(&self.flex_grow),
                flex_shrink: ::core::clone::Clone::clone(&self.flex_shrink),
                fill: ::core::clone::Clone::clone(&self.fill),
                text_color: ::core::clone::Clone::clone(&self.text_color),
            }
        }
    }
    pub struct OptionalStyle {
        pub display: Option<Display>,
        pub overflow: OptionalPoint<Overflow>,
        pub scrollbar_width: Option<f32>,
        pub position: Option<Position>,
        pub inset: Option<Edges<Length>>,
        pub size: OptionalSize<Length>,
        pub min_size: OptionalSize<Length>,
        pub max_size: OptionalSize<Length>,
        pub aspect_ratio: Option<Option<f32>>,
        pub margin: OptionalEdges<Length>,
        pub padding: Option<Edges<DefinedLength>>,
        pub border: Option<Edges<DefinedLength>>,
        pub align_items: Option<Option<AlignItems>>,
        pub align_self: Option<Option<AlignSelf>>,
        pub align_content: Option<Option<AlignContent>>,
        pub justify_content: Option<Option<JustifyContent>>,
        pub gap: Option<Size<DefinedLength>>,
        pub flex_direction: Option<FlexDirection>,
        pub flex_wrap: Option<FlexWrap>,
        pub flex_basis: Option<Length>,
        pub flex_grow: Option<f32>,
        pub flex_shrink: Option<f32>,
        pub fill: Option<Option<Fill>>,
        pub text_color: Option<Option<Hsla>>,
    }
    #[automatically_derived]
    impl ::core::default::Default for OptionalStyle {
        #[inline]
        fn default() -> OptionalStyle {
            OptionalStyle {
                display: ::core::default::Default::default(),
                overflow: ::core::default::Default::default(),
                scrollbar_width: ::core::default::Default::default(),
                position: ::core::default::Default::default(),
                inset: ::core::default::Default::default(),
                size: ::core::default::Default::default(),
                min_size: ::core::default::Default::default(),
                max_size: ::core::default::Default::default(),
                aspect_ratio: ::core::default::Default::default(),
                margin: ::core::default::Default::default(),
                padding: ::core::default::Default::default(),
                border: ::core::default::Default::default(),
                align_items: ::core::default::Default::default(),
                align_self: ::core::default::Default::default(),
                align_content: ::core::default::Default::default(),
                justify_content: ::core::default::Default::default(),
                gap: ::core::default::Default::default(),
                flex_direction: ::core::default::Default::default(),
                flex_wrap: ::core::default::Default::default(),
                flex_basis: ::core::default::Default::default(),
                flex_grow: ::core::default::Default::default(),
                flex_shrink: ::core::default::Default::default(),
                fill: ::core::default::Default::default(),
                text_color: ::core::default::Default::default(),
            }
        }
    }
    #[automatically_derived]
    impl ::core::clone::Clone for OptionalStyle {
        #[inline]
        fn clone(&self) -> OptionalStyle {
            OptionalStyle {
                display: ::core::clone::Clone::clone(&self.display),
                overflow: ::core::clone::Clone::clone(&self.overflow),
                scrollbar_width: ::core::clone::Clone::clone(&self.scrollbar_width),
                position: ::core::clone::Clone::clone(&self.position),
                inset: ::core::clone::Clone::clone(&self.inset),
                size: ::core::clone::Clone::clone(&self.size),
                min_size: ::core::clone::Clone::clone(&self.min_size),
                max_size: ::core::clone::Clone::clone(&self.max_size),
                aspect_ratio: ::core::clone::Clone::clone(&self.aspect_ratio),
                margin: ::core::clone::Clone::clone(&self.margin),
                padding: ::core::clone::Clone::clone(&self.padding),
                border: ::core::clone::Clone::clone(&self.border),
                align_items: ::core::clone::Clone::clone(&self.align_items),
                align_self: ::core::clone::Clone::clone(&self.align_self),
                align_content: ::core::clone::Clone::clone(&self.align_content),
                justify_content: ::core::clone::Clone::clone(&self.justify_content),
                gap: ::core::clone::Clone::clone(&self.gap),
                flex_direction: ::core::clone::Clone::clone(&self.flex_direction),
                flex_wrap: ::core::clone::Clone::clone(&self.flex_wrap),
                flex_basis: ::core::clone::Clone::clone(&self.flex_basis),
                flex_grow: ::core::clone::Clone::clone(&self.flex_grow),
                flex_shrink: ::core::clone::Clone::clone(&self.flex_shrink),
                fill: ::core::clone::Clone::clone(&self.fill),
                text_color: ::core::clone::Clone::clone(&self.text_color),
            }
        }
    }
    impl Optional for OptionalStyle {
        type Base = Style;
        fn assign(&self, base: &mut Self::Base) {
            if let Some(value) = self.display.clone() {
                base.display = value;
            }
            if let Some(value) = self.overflow.clone() {
                base.overflow = value;
            }
            if let Some(value) = self.scrollbar_width.clone() {
                base.scrollbar_width = value;
            }
            if let Some(value) = self.position.clone() {
                base.position = value;
            }
            if let Some(value) = self.inset.clone() {
                base.inset = value;
            }
            if let Some(value) = self.size.clone() {
                base.size = value;
            }
            if let Some(value) = self.min_size.clone() {
                base.min_size = value;
            }
            if let Some(value) = self.max_size.clone() {
                base.max_size = value;
            }
            if let Some(value) = self.aspect_ratio.clone() {
                base.aspect_ratio = value;
            }
            if let Some(value) = self.margin.clone() {
                base.margin = value;
            }
            if let Some(value) = self.padding.clone() {
                base.padding = value;
            }
            if let Some(value) = self.border.clone() {
                base.border = value;
            }
            if let Some(value) = self.align_items.clone() {
                base.align_items = value;
            }
            if let Some(value) = self.align_self.clone() {
                base.align_self = value;
            }
            if let Some(value) = self.align_content.clone() {
                base.align_content = value;
            }
            if let Some(value) = self.justify_content.clone() {
                base.justify_content = value;
            }
            if let Some(value) = self.gap.clone() {
                base.gap = value;
            }
            if let Some(value) = self.flex_direction.clone() {
                base.flex_direction = value;
            }
            if let Some(value) = self.flex_wrap.clone() {
                base.flex_wrap = value;
            }
            if let Some(value) = self.flex_basis.clone() {
                base.flex_basis = value;
            }
            if let Some(value) = self.flex_grow.clone() {
                base.flex_grow = value;
            }
            if let Some(value) = self.flex_shrink.clone() {
                base.flex_shrink = value;
            }
            if let Some(value) = self.fill.clone() {
                base.fill = value;
            }
            if let Some(value) = self.text_color.clone() {
                base.text_color = value;
            }
        }
    }
    impl From<OptionalStyle> for Style
    where
        Style: Default,
    {
        fn from(wrapper: OptionalStyle) -> Self {
            let mut base = Self::default();
            wrapper.assign(&mut base);
            base
        }
    }
    impl Style {
        pub const DEFAULT: Style = Style {
            display: Display::DEFAULT,
            overflow: Point {
                x: Overflow::Visible,
                y: Overflow::Visible,
            },
            scrollbar_width: 0.0,
            position: Position::Relative,
            inset: Edges::auto(),
            margin: Edges::<Length>::zero(),
            padding: Edges::<DefinedLength>::zero(),
            border: Edges::<DefinedLength>::zero(),
            size: Size::auto(),
            min_size: Size::auto(),
            max_size: Size::auto(),
            aspect_ratio: None,
            gap: Size::zero(),
            align_items: None,
            align_self: None,
            align_content: None,
            justify_content: None,
            flex_direction: FlexDirection::Row,
            flex_wrap: FlexWrap::NoWrap,
            flex_grow: 0.0,
            flex_shrink: 1.0,
            flex_basis: Length::Auto,
            fill: None,
            text_color: None,
        };
        pub fn new() -> Self {
            Self::DEFAULT.clone()
        }
        pub fn to_taffy(&self, rem_size: f32) -> taffy::style::Style {
            taffy::style::Style {
                display: self.display,
                overflow: self.overflow.clone().into(),
                scrollbar_width: self.scrollbar_width,
                position: self.position,
                inset: self.inset.to_taffy(rem_size),
                size: self.size.to_taffy(rem_size),
                min_size: self.min_size.to_taffy(rem_size),
                max_size: self.max_size.to_taffy(rem_size),
                aspect_ratio: self.aspect_ratio,
                margin: self.margin.to_taffy(rem_size),
                padding: self.padding.to_taffy(rem_size),
                border: self.border.to_taffy(rem_size),
                align_items: self.align_items,
                align_self: self.align_self,
                align_content: self.align_content,
                justify_content: self.justify_content,
                gap: self.gap.to_taffy(rem_size),
                flex_direction: self.flex_direction,
                flex_wrap: self.flex_wrap,
                flex_basis: self.flex_basis.to_taffy(rem_size).into(),
                flex_grow: self.flex_grow,
                flex_shrink: self.flex_shrink,
                ..Default::default()
            }
        }
    }
    impl Default for Style {
        fn default() -> Self {
            Self::DEFAULT.clone()
        }
    }
    impl OptionalStyle {
        pub fn text_style(&self) -> Option<OptionalTextStyle> {
            self.text_color.map(|color| OptionalTextStyle { color })
        }
    }
    pub struct OptionalTextStyle {
        color: Option<Hsla>,
    }
    impl OptionalTextStyle {
        pub fn apply(&self, style: &mut gpui::fonts::TextStyle) {
            if let Some(color) = self.color {
                style.color = color.into();
            }
        }
    }
    pub enum Fill {
        Color(Hsla),
    }
    #[automatically_derived]
    impl ::core::clone::Clone for Fill {
        #[inline]
        fn clone(&self) -> Fill {
            match self {
                Fill::Color(__self_0) => Fill::Color(::core::clone::Clone::clone(__self_0)),
            }
        }
    }
    impl Fill {
        pub fn color(&self) -> Option<Hsla> {
            match self {
                Fill::Color(color) => Some(*color),
            }
        }
    }
    impl Default for Fill {
        fn default() -> Self {
            Self::Color(Hsla::default())
        }
    }
    impl From<Hsla> for Fill {
        fn from(color: Hsla) -> Self {
            Self::Color(color)
        }
    }
}
mod text {
    use crate::{
        element::{Element, ElementMetadata, EventHandler, IntoElement},
        style::Style,
    };
    use gpui::{geometry::Size, text_layout::LineLayout, RenderContext};
    use parking_lot::Mutex;
    use std::sync::Arc;
    impl<V: 'static, S: Into<ArcCow<'static, str>>> IntoElement<V> for S {
        type Element = Text<V>;
        fn into_element(self) -> Self::Element {
            Text {
                text: self.into(),
                metadata: Default::default(),
            }
        }
    }
    pub struct Text<V> {
        text: ArcCow<'static, str>,
        metadata: ElementMetadata<V>,
    }
    impl<V: 'static> Element<V> for Text<V> {
        type Layout = Arc<Mutex<Option<TextLayout>>>;
        fn declared_style(&mut self) -> &mut crate::style::OptionalStyle {
            &mut self.metadata.style
        }
        fn layout(
            &mut self,
            view: &mut V,
            cx: &mut gpui::LayoutContext<V>,
        ) -> anyhow::Result<(taffy::tree::NodeId, Self::Layout)> {
            let rem_size = cx.rem_pixels();
            let fonts = cx.platform().fonts();
            let text_style = cx.text_style();
            let line_height = cx.font_cache().line_height(text_style.font_size);
            let layout_engine = cx.layout_engine().expect("no layout engine present");
            let text = self.text.clone();
            let layout = Arc::new(Mutex::new(None));
            let style: Style = self.metadata.style.into();
            let node_id = layout_engine.add_measured_node(style.to_taffy(rem_size), {
                let layout = layout.clone();
                move |params| {
                    let line_layout = fonts.layout_line(
                        text.as_ref(),
                        text_style.font_size,
                        &[(text.len(), text_style.to_run())],
                    );
                    let size = Size {
                        width: line_layout.width,
                        height: line_height,
                    };
                    layout.lock().replace(TextLayout {
                        line_layout: Arc::new(line_layout),
                        line_height,
                    });
                    size
                }
            })?;
            Ok((node_id, layout))
        }
        fn paint<'a>(
            &mut self,
            layout: crate::element::Layout<Arc<Mutex<Option<TextLayout>>>>,
            view: &mut V,
            cx: &mut crate::element::PaintContext<V>,
        ) -> anyhow::Result<()> {
            let element_layout_lock = layout.from_element.lock();
            let element_layout = element_layout_lock
                .as_ref()
                .expect("layout has not been performed");
            let line_layout = element_layout.line_layout.clone();
            let line_height = element_layout.line_height;
            drop(element_layout_lock);
            let text_style = cx.text_style();
            let line = gpui::text_layout::Line::new(
                line_layout,
                &[(self.text.len(), text_style.to_run())],
            );
            line.paint(
                cx.scene,
                layout.from_engine.bounds.origin(),
                layout.from_engine.bounds,
                line_height,
                cx.legacy_cx,
            );
            Ok(())
        }
        fn handlers_mut(&mut self) -> &mut Vec<EventHandler<V>> {
            &mut self.metadata.handlers
        }
    }
    pub struct TextLayout {
        line_layout: Arc<LineLayout>,
        line_height: f32,
    }
    pub enum ArcCow<'a, T: ?Sized> {
        Borrowed(&'a T),
        Owned(Arc<T>),
    }
    impl<'a, T: ?Sized> Clone for ArcCow<'a, T> {
        fn clone(&self) -> Self {
            match self {
                Self::Borrowed(borrowed) => Self::Borrowed(borrowed),
                Self::Owned(owned) => Self::Owned(owned.clone()),
            }
        }
    }
    impl<'a, T: ?Sized> From<&'a T> for ArcCow<'a, T> {
        fn from(s: &'a T) -> Self {
            Self::Borrowed(s)
        }
    }
    impl<T> From<Arc<T>> for ArcCow<'_, T> {
        fn from(s: Arc<T>) -> Self {
            Self::Owned(s)
        }
    }
    impl From<String> for ArcCow<'_, str> {
        fn from(value: String) -> Self {
            Self::Owned(value.into())
        }
    }
    impl<T: ?Sized> std::ops::Deref for ArcCow<'_, T> {
        type Target = T;
        fn deref(&self) -> &Self::Target {
            match self {
                ArcCow::Borrowed(s) => s,
                ArcCow::Owned(s) => s.as_ref(),
            }
        }
    }
    impl<T: ?Sized> AsRef<T> for ArcCow<'_, T> {
        fn as_ref(&self) -> &T {
            match self {
                ArcCow::Borrowed(borrowed) => borrowed,
                ArcCow::Owned(owned) => owned.as_ref(),
            }
        }
    }
}
mod themes {
    use crate::color::{Hsla, Lerp};
    use std::ops::Range;
    pub mod rose_pine {
        use crate::{
            color::{hsla, rgb, Hsla},
            ThemeColors,
        };
        use std::ops::Range;
        pub struct RosePineThemes {
            pub default: RosePinePalette,
            pub dawn: RosePinePalette,
            pub moon: RosePinePalette,
        }
        pub struct RosePinePalette {
            pub base: Hsla,
            pub surface: Hsla,
            pub overlay: Hsla,
            pub muted: Hsla,
            pub subtle: Hsla,
            pub text: Hsla,
            pub love: Hsla,
            pub gold: Hsla,
            pub rose: Hsla,
            pub pine: Hsla,
            pub foam: Hsla,
            pub iris: Hsla,
            pub highlight_low: Hsla,
            pub highlight_med: Hsla,
            pub highlight_high: Hsla,
        }
        #[automatically_derived]
        impl ::core::clone::Clone for RosePinePalette {
            #[inline]
            fn clone(&self) -> RosePinePalette {
                let _: ::core::clone::AssertParamIsClone<Hsla>;
                *self
            }
        }
        #[automatically_derived]
        impl ::core::marker::Copy for RosePinePalette {}
        #[automatically_derived]
        impl ::core::fmt::Debug for RosePinePalette {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                let names: &'static _ = &[
                    "base",
                    "surface",
                    "overlay",
                    "muted",
                    "subtle",
                    "text",
                    "love",
                    "gold",
                    "rose",
                    "pine",
                    "foam",
                    "iris",
                    "highlight_low",
                    "highlight_med",
                    "highlight_high",
                ];
                let values: &[&dyn::core::fmt::Debug] = &[
                    &self.base,
                    &self.surface,
                    &self.overlay,
                    &self.muted,
                    &self.subtle,
                    &self.text,
                    &self.love,
                    &self.gold,
                    &self.rose,
                    &self.pine,
                    &self.foam,
                    &self.iris,
                    &self.highlight_low,
                    &self.highlight_med,
                    &&self.highlight_high,
                ];
                ::core::fmt::Formatter::debug_struct_fields_finish(
                    f,
                    "RosePinePalette",
                    names,
                    values,
                )
            }
        }
        impl RosePinePalette {
            pub fn default() -> RosePinePalette {
                RosePinePalette {
                    base: rgb(0x191724),
                    surface: rgb(0x1f1d2e),
                    overlay: rgb(0x26233a),
                    muted: rgb(0x6e6a86),
                    subtle: rgb(0x908caa),
                    text: rgb(0xe0def4),
                    love: rgb(0xeb6f92),
                    gold: rgb(0xf6c177),
                    rose: rgb(0xebbcba),
                    pine: rgb(0x31748f),
                    foam: rgb(0x9ccfd8),
                    iris: rgb(0xc4a7e7),
                    highlight_low: rgb(0x21202e),
                    highlight_med: rgb(0x403d52),
                    highlight_high: rgb(0x524f67),
                }
            }
            pub fn moon() -> RosePinePalette {
                RosePinePalette {
                    base: rgb(0x232136),
                    surface: rgb(0x2a273f),
                    overlay: rgb(0x393552),
                    muted: rgb(0x6e6a86),
                    subtle: rgb(0x908caa),
                    text: rgb(0xe0def4),
                    love: rgb(0xeb6f92),
                    gold: rgb(0xf6c177),
                    rose: rgb(0xea9a97),
                    pine: rgb(0x3e8fb0),
                    foam: rgb(0x9ccfd8),
                    iris: rgb(0xc4a7e7),
                    highlight_low: rgb(0x2a283e),
                    highlight_med: rgb(0x44415a),
                    highlight_high: rgb(0x56526e),
                }
            }
            pub fn dawn() -> RosePinePalette {
                RosePinePalette {
                    base: rgb(0xfaf4ed),
                    surface: rgb(0xfffaf3),
                    overlay: rgb(0xf2e9e1),
                    muted: rgb(0x9893a5),
                    subtle: rgb(0x797593),
                    text: rgb(0x575279),
                    love: rgb(0xb4637a),
                    gold: rgb(0xea9d34),
                    rose: rgb(0xd7827e),
                    pine: rgb(0x286983),
                    foam: rgb(0x56949f),
                    iris: rgb(0x907aa9),
                    highlight_low: rgb(0xf4ede8),
                    highlight_med: rgb(0xdfdad9),
                    highlight_high: rgb(0xcecacd),
                }
            }
        }
        pub fn default() -> ThemeColors {
            theme_colors(&RosePinePalette::default())
        }
        pub fn moon() -> ThemeColors {
            theme_colors(&RosePinePalette::moon())
        }
        pub fn dawn() -> ThemeColors {
            theme_colors(&RosePinePalette::dawn())
        }
        fn theme_colors(p: &RosePinePalette) -> ThemeColors {
            ThemeColors {
                base: scale_sl(p.base, (0.8, 0.8), (1.2, 1.2)),
                surface: scale_sl(p.surface, (0.8, 0.8), (1.2, 1.2)),
                overlay: scale_sl(p.overlay, (0.8, 0.8), (1.2, 1.2)),
                muted: scale_sl(p.muted, (0.8, 0.8), (1.2, 1.2)),
                subtle: scale_sl(p.subtle, (0.8, 0.8), (1.2, 1.2)),
                text: scale_sl(p.text, (0.8, 0.8), (1.2, 1.2)),
                highlight_low: scale_sl(p.highlight_low, (0.8, 0.8), (1.2, 1.2)),
                highlight_med: scale_sl(p.highlight_med, (0.8, 0.8), (1.2, 1.2)),
                highlight_high: scale_sl(p.highlight_high, (0.8, 0.8), (1.2, 1.2)),
                success: scale_sl(p.foam, (0.8, 0.8), (1.2, 1.2)),
                warning: scale_sl(p.gold, (0.8, 0.8), (1.2, 1.2)),
                error: scale_sl(p.love, (0.8, 0.8), (1.2, 1.2)),
                inserted: scale_sl(p.foam, (0.8, 0.8), (1.2, 1.2)),
                deleted: scale_sl(p.love, (0.8, 0.8), (1.2, 1.2)),
                modified: scale_sl(p.rose, (0.8, 0.8), (1.2, 1.2)),
            }
        }
        /// Produces a range by multiplying the saturation and lightness of the base color by the given
        /// start and end factors.
        fn scale_sl(
            base: Hsla,
            (start_s, start_l): (f32, f32),
            (end_s, end_l): (f32, f32),
        ) -> Range<Hsla> {
            let start = hsla(base.h, base.s * start_s, base.l * start_l, base.a);
            let end = hsla(base.h, base.s * end_s, base.l * end_l, base.a);
            Range { start, end }
        }
    }
    pub struct ThemeColors {
        pub base: Range<Hsla>,
        pub surface: Range<Hsla>,
        pub overlay: Range<Hsla>,
        pub muted: Range<Hsla>,
        pub subtle: Range<Hsla>,
        pub text: Range<Hsla>,
        pub highlight_low: Range<Hsla>,
        pub highlight_med: Range<Hsla>,
        pub highlight_high: Range<Hsla>,
        pub success: Range<Hsla>,
        pub warning: Range<Hsla>,
        pub error: Range<Hsla>,
        pub inserted: Range<Hsla>,
        pub deleted: Range<Hsla>,
        pub modified: Range<Hsla>,
    }
    impl ThemeColors {
        pub fn base(&self, level: f32) -> Hsla {
            self.base.lerp(level)
        }
        pub fn surface(&self, level: f32) -> Hsla {
            self.surface.lerp(level)
        }
        pub fn overlay(&self, level: f32) -> Hsla {
            self.overlay.lerp(level)
        }
        pub fn muted(&self, level: f32) -> Hsla {
            self.muted.lerp(level)
        }
        pub fn subtle(&self, level: f32) -> Hsla {
            self.subtle.lerp(level)
        }
        pub fn text(&self, level: f32) -> Hsla {
            self.text.lerp(level)
        }
        pub fn highlight_low(&self, level: f32) -> Hsla {
            self.highlight_low.lerp(level)
        }
        pub fn highlight_med(&self, level: f32) -> Hsla {
            self.highlight_med.lerp(level)
        }
        pub fn highlight_high(&self, level: f32) -> Hsla {
            self.highlight_high.lerp(level)
        }
        pub fn success(&self, level: f32) -> Hsla {
            self.success.lerp(level)
        }
        pub fn warning(&self, level: f32) -> Hsla {
            self.warning.lerp(level)
        }
        pub fn error(&self, level: f32) -> Hsla {
            self.error.lerp(level)
        }
        pub fn inserted(&self, level: f32) -> Hsla {
            self.inserted.lerp(level)
        }
        pub fn deleted(&self, level: f32) -> Hsla {
            self.deleted.lerp(level)
        }
        pub fn modified(&self, level: f32) -> Hsla {
            self.modified.lerp(level)
        }
    }
}
mod view {
    use crate::element::{AnyElement, Element};
    use gpui::{Element as _, ViewContext};
    pub fn view<F, E>(mut render: F) -> ViewFn
    where
        F: 'static + FnMut(&mut ViewContext<ViewFn>) -> E,
        E: Element<ViewFn>,
    {
        ViewFn(Box::new(move |cx| (render)(cx).into_any()))
    }
    pub struct ViewFn(Box<dyn FnMut(&mut ViewContext<ViewFn>) -> AnyElement<ViewFn>>);
    impl gpui::Entity for ViewFn {
        type Event = ();
    }
    impl gpui::View for ViewFn {
        fn render(&mut self, cx: &mut ViewContext<Self>) -> gpui::AnyElement<Self> {
            (self.0)(cx).adapt().into_any()
        }
    }
}
fn main() {
    SimpleLogger::init(LevelFilter::Info, Default::default()).expect("could not initialize logger");
    gpui::App::new(()).unwrap().run(|cx| {
        cx.add_window(
            WindowOptions {
                bounds: gpui::platform::WindowBounds::Fixed(RectF::new(
                    vec2f(0., 0.),
                    vec2f(400., 300.),
                )),
                center: true,
                ..Default::default()
            },
            |_| view(|_| storybook(&rose_pine::moon())),
        );
        cx.platform().activate(true);
    });
}
fn storybook<V: 'static>(theme: &ThemeColors) -> impl Element<V> {
    frame()
        .text_color(black())
        .h_full()
        .w_half()
        .fill(theme.success(0.5))
        .child(button().label("Hello").click(|_, _, _| {
            ::std::io::_print(format_args!("click!\n"));
        }))
}