🥮 mooncakes.io

    Milky2018/css/values does not have a README file

    AlignSelf

    source
    pub(all) enum AlignSelf {
      Auto
      Start
      End
      Center
      Stretch
      Baseline
    } derive(Eq, 
    Debug    )

    Align-self value (can override align-items for individual items)
    impl Show for AlignSelf

    AlignSelf::equal

    source
    fn AlignSelf::equal(AlignSelf, AlignSelf) -> Bool

    AlignSelf::not_equal

    source
    fn AlignSelf::not_equal(x : AlignSelf, y : AlignSelf) -> Bool

    AlignSelf::output

    source
    fn AlignSelf::output(self : AlignSelf, logger : &Logger) -> Unit

    AlignSelf::to_repr

    source

    AlignSelf::to_string

    source
    fn AlignSelf::to_string(self : AlignSelf) -> String

    Alignment

    source
    pub(all) enum Alignment {
      Start
      End
      Left
      Right
      FlexStart
      FlexEnd
      Center
      SpaceBetween
      SpaceAround
      SpaceEvenly
      Stretch
      Baseline
    } derive(Eq, 
    Debug    )

    Alignment for justify-content, align-items, etc.
    impl Show for Alignment

    Alignment::equal

    source
    fn Alignment::equal(Alignment, Alignment) -> Bool

    Alignment::not_equal

    source
    fn Alignment::not_equal(x : Alignment, y : Alignment) -> Bool

    Alignment::output

    source
    fn Alignment::output(self : Alignment, logger : &Logger) -> Unit

    Alignment::to_repr

    source

    Alignment::to_string

    source
    fn Alignment::to_string(self : Alignment) -> String

    AnimationDirection

    source
    pub(all) enum AnimationDirection {
      Normal
      Reverse
      Alternate
      AlternateReverse
    } derive(Eq, 
    Debug    )

    animation-direction value.

    AnimationDirection::equal

    source

    AnimationDirection::not_equal

    source

    AnimationDirection::output

    source
    fn AnimationDirection::output(self : AnimationDirection, logger : &Logger) -> Unit

    AnimationDirection::to_repr

    source

    AnimationDirection::to_string

    source
    fn AnimationDirection::to_string(self : AnimationDirection) -> String

    AnimationFillMode

    source
    pub(all) enum AnimationFillMode {
      None
      Forwards
      Backwards
      Both
    } derive(Eq, 
    Debug    )

    animation-fill-mode value.

    AnimationFillMode::equal

    source

    AnimationFillMode::not_equal

    source
    fn AnimationFillMode::not_equal(x : AnimationFillMode, y : AnimationFillMode) -> Bool

    AnimationFillMode::output

    source
    fn AnimationFillMode::output(self : AnimationFillMode, logger : &Logger) -> Unit

    AnimationFillMode::to_repr

    source

    AnimationFillMode::to_string

    source
    fn AnimationFillMode::to_string(self : AnimationFillMode) -> String

    AnimationIterationCount

    source
    pub(all) enum AnimationIterationCount {
      Count(Double)
      Infinite
    } derive(Eq, 
    Debug    )

    animation-iteration-count value (<number> or infinite).

    AnimationIterationCount::equal

    source

    AnimationIterationCount::not_equal

    source

    AnimationIterationCount::output

    source
    fn AnimationIterationCount::output(self : AnimationIterationCount, logger : &Logger) -> Unit

    AnimationIterationCount::to_repr

    source

    AnimationIterationCount::to_string

    source
    fn AnimationIterationCount::to_string(self : AnimationIterationCount) -> String

    AnimationPlayState

    source
    pub(all) enum AnimationPlayState {
      Running
      Paused
    } derive(Eq, 
    Debug    )

    animation-play-state value.

    AnimationPlayState::equal

    source

    AnimationPlayState::not_equal

    source

    AnimationPlayState::output

    source
    fn AnimationPlayState::output(self : AnimationPlayState, logger : &Logger) -> Unit

    AnimationPlayState::to_repr

    source

    AnimationPlayState::to_string

    source
    fn AnimationPlayState::to_string(self : AnimationPlayState) -> String

    BackgroundImage

    source
    pub(all) enum BackgroundImage {
      None
      Gradient(LinearGradient)
    } derive(Eq, 
    Debug    )

    Background image (currently only linear-gradient)

    BackgroundImage::equal

    source

    BackgroundImage::not_equal

    source
    fn BackgroundImage::not_equal(x : BackgroundImage, y : BackgroundImage) -> Bool

    BackgroundImage::output

    source
    fn BackgroundImage::output(self : BackgroundImage, logger : &Logger) -> Unit

    BackgroundImage::to_repr

    source

    BackgroundImage::to_string

    source
    fn BackgroundImage::to_string(self : BackgroundImage) -> String

    BoundingRect

    source
    pub(all) struct BoundingRect {
      x : Double
      y : Double
      width : Double
      height : Double
    }

    BoundingRect - the output of layout computation Matches browser's getBoundingClientRect()

    BoundingRect::area

    source
    fn BoundingRect::area(self : BoundingRect) -> Double

    Calculate the area of the bounding rect

    BoundingRect::bottom

    source
    fn BoundingRect::bottom(self : BoundingRect) -> Double

    Get the bottom edge (y + height)

    BoundingRect::new

    source
    fn BoundingRect::new(x : Double, y : Double, width : Double, height : Double) -> BoundingRect

    BoundingRect::output

    source
    fn BoundingRect::output(self : BoundingRect, logger : &Logger) -> Unit

    BoundingRect::right

    source
    fn BoundingRect::right(self : BoundingRect) -> Double

    Get the right edge (x + width)

    BoundingRect::to_string

    source
    fn BoundingRect::to_string(self : BoundingRect) -> String

    BoundingRect::union

    source
    fn BoundingRect::union(self : BoundingRect, other : BoundingRect) -> BoundingRect

    Calculate union of two bounding rects

    BoundingRect::zero

    source

    BoxSizing

    source
    pub(all) enum BoxSizing {
      ContentBox
      BorderBox
    } derive(Eq, 
    Debug    )

    CSS box-sizing property
    impl Show for BoxSizing

    BoxSizing::equal

    source
    fn BoxSizing::equal(BoxSizing, BoxSizing) -> Bool

    BoxSizing::not_equal

    source
    fn BoxSizing::not_equal(x : BoxSizing, y : BoxSizing) -> Bool

    BoxSizing::output

    source
    fn BoxSizing::output(self : BoxSizing, logger : &Logger) -> Unit

    BoxSizing::to_repr

    source

    BoxSizing::to_string

    source
    fn BoxSizing::to_string(self : BoxSizing) -> String

    Clear

    source
    pub(all) enum Clear {
      None
      Left
      Right
      Both
    } derive(Eq, 
    Debug    )

    CSS clear property
    impl Show for Clear

    Clear::equal

    source
    fn Clear::equal(Clear, Clear) -> Bool

    Clear::not_equal

    source
    fn Clear::not_equal(x : Clear, y : Clear) -> Bool

    Clear::output

    source
    fn Clear::output(self : Clear, logger : &Logger) -> Unit

    Clear::to_repr

    source

    Clear::to_string

    source
    fn Clear::to_string(self : Clear) -> String

    ClipRect

    source
    pub(all) enum ClipRect {
      Auto
      Rect(top~ : Double, right~ : Double, bottom~ : Double, left~ : Double)
    } derive(Eq, 
    Debug    )

    CSS clip property value clip: rect(top, right, bottom, left) or auto Note: This is a deprecated property, but still widely used for accessibility
    impl Show for ClipRect

    ClipRect::default

    source
    fn ClipRect::default() -> ClipRect

    ClipRect::equal

    source
    fn ClipRect::equal(ClipRect, ClipRect) -> Bool

    ClipRect::not_equal

    source
    fn ClipRect::not_equal(x : ClipRect, y : ClipRect) -> Bool

    ClipRect::output

    source
    fn ClipRect::output(self : ClipRect, logger : &Logger) -> Unit

    ClipRect::to_repr

    source

    ClipRect::to_string

    source
    fn ClipRect::to_string(self : ClipRect) -> String

    Color

    source
    pub(all) struct Color {
      r : Int
      g : Int
      b : Int
      a : Double
    } derive(
    Debug    )

    RGBA color with 8-bit channels and alpha
    impl Eq for Color
    impl Show for Color

    Color::black

    source
    fn Color::black() -> Color

    Black color

    Color::equal

    source
    fn Color::equal(self : Color, other : Color) -> Bool

    Color::is_opaque

    source
    fn Color::is_opaque(self : Color) -> Bool

    Color::is_transparent

    source
    fn Color::is_transparent(self : Color) -> Bool

    Color::not_equal

    source
    fn Color::not_equal(x : Color, y : Color) -> Bool

    Color::output

    source
    fn Color::output(self : Color, logger : &Logger) -> Unit

    Color::rgb

    source
    fn Color::rgb(r : Int, g : Int, b : Int) -> Color

    Color::rgba

    source
    fn Color::rgba(r : Int, g : Int, b : Int, a : Double) -> Color

    Color::to_hex

    source
    fn Color::to_hex(self : Color) -> String

    Convert to CSS hex string (#rrggbb or #rrggbbaa)

    Color::to_repr

    source

    Color::to_rgba_string

    source
    fn Color::to_rgba_string(self : Color) -> String

    Convert to CSS rgba() string

    Color::to_string

    source
    fn Color::to_string(self : Color) -> String

    Color::transparent

    source
    fn Color::transparent() -> Color

    Transparent color (alpha = 0)

    Color::white

    source
    fn Color::white() -> Color

    White color

    Dimension

    source
    pub(all) enum Dimension {
      Length(Double)
      Percent(Double)
      Auto
      MinContent
      MaxContent
      FitContent(Double)
      Calc(Double, Double)
      MathFn(MathOp, Array[(Double, Double)])
    } derive(Eq, 
    Debug    )

    CSS dimension value: length, percentage, auto, or intrinsic sizing keywords
    impl Show for Dimension

    Dimension::eq_length

    source
    fn Dimension::eq_length(self : Dimension, value : Double) -> Bool

    Check if dimension equals a specific length value

    Dimension::eq_percent

    source
    fn Dimension::eq_percent(self : Dimension, value : Double) -> Bool

    Check if dimension equals a specific percent value

    Dimension::equal

    source
    fn Dimension::equal(Dimension, Dimension) -> Bool

    Dimension::is_definite

    source
    fn Dimension::is_definite(self : Dimension) -> Bool

    Check if dimension is a definite value (Length or Percent)

    Dimension::is_intrinsic

    source
    fn Dimension::is_intrinsic(self : Dimension) -> Bool

    Check if dimension requires intrinsic sizing

    Dimension::not_equal

    source
    fn Dimension::not_equal(x : Dimension, y : Dimension) -> Bool

    Dimension::output

    source
    fn Dimension::output(self : Dimension, logger : &Logger) -> Unit

    Dimension::resolve

    source
    fn Dimension::resolve(self : Dimension, context : Double) -> Double?

    Resolve dimension to concrete value context: parent size for percentage calculation Note: MinContent, MaxContent, FitContent return None - they need intrinsic size calculation

    Dimension::resolve_or

    source
    fn Dimension::resolve_or(self : Dimension, context : Double, fallback : Double) -> Double

    Resolve with fallback value for Auto

    Matches self directly rather than going through resolve, which returns a Double? and so boxes a Some(..) on every call. This is on the hot layout path (every width/height/padding/margin per element, plus all four sides via resolve_rect), where the intermediate Option allocation dominated.

    Dimension::resolve_or_intrinsic

    source
    fn Dimension::resolve_or_intrinsic(self : Dimension, context : Double, fallback : Double) -> Double

    Resolve dimension to length, treating intrinsic keywords as fallback

    Dimension::to_repr

    source

    Dimension::to_string

    source
    fn Dimension::to_string(self : Dimension) -> String

    Display

    source
    pub(all) enum Display {
      Block
      Inline
      InlineBlock
      Flex
      InlineFlex
      Grid
      InlineGrid
      Table
      InlineTable
      TableRow
      TableCell
      TableCaption
      TableRowGroup
      TableHeaderGroup
      TableFooterGroup
      TableColumn
      TableColumnGroup
      None
      Contents
      FlowRoot
    } derive(Eq, 
    Debug    )

    CSS display property
    impl Show for Display

    Display::equal

    source
    fn Display::equal(Display, Display) -> Bool

    Display::not_equal

    source
    fn Display::not_equal(x : Display, y : Display) -> Bool

    Display::output

    source
    fn Display::output(self : Display, logger : &Logger) -> Unit

    Display::to_repr

    source

    Display::to_string

    source
    fn Display::to_string(self : Display) -> String

    Easing

    source
    pub(all) enum Easing {
      Linear
      Ease
      EaseIn
      EaseOut
      EaseInOut
      EaseInSine
      EaseOutSine
      EaseInOutSine
      EaseInQuad
      EaseOutQuad
      EaseInOutQuad
      EaseInCubic
      EaseOutCubic
      EaseInOutCubic
      EaseInQuart
      EaseOutQuart
      EaseInOutQuart
      EaseInQuint
      EaseOutQuint
      EaseInOutQuint
      EaseInExpo
      EaseOutExpo
      EaseInOutExpo
      EaseInCirc
      EaseOutCirc
      EaseInOutCirc
      EaseInBack
      EaseOutBack
      EaseInOutBack
      EaseInElastic
      EaseOutElastic
      EaseInOutElastic
      EaseInBounce
      EaseOutBounce
      EaseInOutBounce
      LinearFunction(Array[LinearEasingPoint])
      CubicBezier(Double, Double, Double, Double)
      Steps(Int, StepPosition)
    } derive(Eq, 
    Debug    )

    CSS easing/timing-function value without binding it to transitions or animations. Consumers can sample it against normalized progress [0, 1].
    impl Show for Easing

    Easing::apply

    source
    fn Easing::apply(self : Easing, start_value : Double, end_value : Double, progress : Double) -> Double

    Apply the easing to a numeric range at normalized progress.

    Easing::cubic_bezier

    source
    fn Easing::cubic_bezier(x1 : Double, y1 : Double, x2 : Double, y2 : Double) -> Easing

    Easing::equal

    source
    fn Easing::equal(Easing, Easing) -> Bool

    Easing::frame

    source
    fn Easing::frame(self : Easing, start_value : Double, end_value : Double, progress : Double) -> EasingFrame

    Build one frame with the clamped input progress, eased progress and value.

    Easing::frames

    source
    fn Easing::frames(self : Easing, start_value : Double, end_value : Double, count : Int) -> Array[EasingFrame]

    Build evenly spaced frames across the easing range. The sequence includes both endpoints when count >= 2.

    Easing::linear

    source
    fn Easing::linear(points : Array[LinearEasingPoint]) -> Easing?

    Easing::not_equal

    source
    fn Easing::not_equal(x : Easing, y : Easing) -> Bool

    Easing::output

    source
    fn Easing::output(self : Easing, logger : &Logger) -> Unit

    Easing::sample

    source
    fn Easing::sample(self : Easing, progress : Double) -> Double

    Sample the easing at normalized progress. Input progress is clamped to [0, 1]; cubic-bezier output may overshoot if its Y control points do.

    Easing::steps

    source
    fn Easing::steps(count : Int, position : StepPosition) -> Easing

    Easing::to_repr

    source

    Easing::to_string

    source
    fn Easing::to_string(self : Easing) -> String

    EasingFrame

    source
    pub(all) struct EasingFrame {
      progress : Double
      eased_progress : Double
      value : Double
    }

    Eased value at one point in an interpolation sequence.
    impl Show for EasingFrame

    EasingFrame::output

    source
    fn EasingFrame::output(self : EasingFrame, logger : &Logger) -> Unit

    EasingFrame::to_string

    source
    fn EasingFrame::to_string(self : EasingFrame) -> String

    FlexDirection

    source
    pub(all) enum FlexDirection {
      Row
      RowReverse
      Column
      ColumnReverse
    } derive(Eq, 
    Debug    )

    Flex direction

    FlexDirection::equal

    source

    FlexDirection::not_equal

    source
    fn FlexDirection::not_equal(x : FlexDirection, y : FlexDirection) -> Bool

    FlexDirection::output

    source
    fn FlexDirection::output(self : FlexDirection, logger : &Logger) -> Unit

    FlexDirection::to_repr

    source

    FlexDirection::to_string

    source
    fn FlexDirection::to_string(self : FlexDirection) -> String

    FlexWrap

    source
    pub(all) enum FlexWrap {
      NoWrap
      Wrap
      WrapReverse
    } derive(Eq, 
    Debug    )

    Flex wrap mode
    impl Show for FlexWrap

    FlexWrap::equal

    source
    fn FlexWrap::equal(FlexWrap, FlexWrap) -> Bool

    FlexWrap::not_equal

    source
    fn FlexWrap::not_equal(x : FlexWrap, y : FlexWrap) -> Bool

    FlexWrap::output

    source
    fn FlexWrap::output(self : FlexWrap, logger : &Logger) -> Unit

    FlexWrap::to_repr

    source

    FlexWrap::to_string

    source
    fn FlexWrap::to_string(self : FlexWrap) -> String

    Float

    source
    pub(all) enum Float {
      None
      Left
      Right
    } derive(Eq, 
    Debug    )

    CSS float property
    impl Show for Float

    Float::equal

    source
    fn Float::equal(Float, Float) -> Bool

    Float::not_equal

    source
    fn Float::not_equal(x : Float, y : Float) -> Bool

    Float::output

    source
    fn Float::output(self : Float, logger : &Logger) -> Unit

    Float::to_repr

    source

    Float::to_string

    source
    fn Float::to_string(self : Float) -> String

    GradientStop

    source
    pub(all) struct GradientStop {
      color : Color
      position : Double
    } derive(Eq, 
    Debug    )

    A color stop in a gradient

    GradientStop::equal

    source

    GradientStop::not_equal

    source
    fn GradientStop::not_equal(x : GradientStop, y : GradientStop) -> Bool

    GradientStop::output

    source
    fn GradientStop::output(self : GradientStop, logger : &Logger) -> Unit

    GradientStop::to_repr

    source

    GradientStop::to_string

    source
    fn GradientStop::to_string(self : GradientStop) -> String

    GridAutoFlow

    source
    pub(all) enum GridAutoFlow {
      Row
      Column
      RowDense
      ColumnDense
    } derive(Eq, 
    Debug    )

    Grid auto-flow direction

    GridAutoFlow::equal

    source

    GridAutoFlow::not_equal

    source
    fn GridAutoFlow::not_equal(x : GridAutoFlow, y : GridAutoFlow) -> Bool

    GridAutoFlow::output

    source
    fn GridAutoFlow::output(self : GridAutoFlow, logger : &Logger) -> Unit

    GridAutoFlow::to_repr

    source

    GridAutoFlow::to_string

    source
    fn GridAutoFlow::to_string(self : GridAutoFlow) -> String

    GridLine

    source
    pub(all) struct GridLine {
      start : GridPlacement
      end : GridPlacement
    } derive(Eq, 
    Debug    )

    Grid line range (start and end)
    impl Show for GridLine

    GridLine::auto

    source
    fn GridLine::auto() -> GridLine

    GridLine::equal

    source
    fn GridLine::equal(GridLine, GridLine) -> Bool

    GridLine::not_equal

    source
    fn GridLine::not_equal(x : GridLine, y : GridLine) -> Bool

    GridLine::output

    source
    fn GridLine::output(self : GridLine, logger : &Logger) -> Unit

    GridLine::to_repr

    source

    GridLine::to_string

    source
    fn GridLine::to_string(self : GridLine) -> String

    GridPlacement

    source
    pub(all) enum GridPlacement {
      Auto
      Line(Int)
      Span(Int)
      Named(String)
      NamedLine(Int, String)
      SpanNamed(Int, String)
    } derive(Eq, 
    Debug    )

    Grid line placement for grid items

    GridPlacement::equal

    source

    GridPlacement::not_equal

    source
    fn GridPlacement::not_equal(x : GridPlacement, y : GridPlacement) -> Bool

    GridPlacement::output

    source
    fn GridPlacement::output(self : GridPlacement, logger : &Logger) -> Unit

    GridPlacement::to_repr

    source

    GridPlacement::to_string

    source
    fn GridPlacement::to_string(self : GridPlacement) -> String

    GridTemplateKind

    source
    pub(all) enum GridTemplateKind {
      Explicit
      Subgrid
      Masonry
    } derive(Eq, 
    Debug    )

    Kind of a grid template axis (grid-template-columns / -rows). Explicit is the normal <track-list> (or none when the track array is empty); Subgrid / Masonry are the alternative axis values.

    GridTemplateKind::equal

    source

    GridTemplateKind::not_equal

    source
    fn GridTemplateKind::not_equal(x : GridTemplateKind, y : GridTemplateKind) -> Bool

    GridTemplateKind::output

    source
    fn GridTemplateKind::output(self : GridTemplateKind, logger : &Logger) -> Unit

    GridTemplateKind::to_repr

    source

    GridTemplateKind::to_string

    source
    fn GridTemplateKind::to_string(self : GridTemplateKind) -> String

    Line

    source
    pub struct Line[T] {
      start : T
      end : T
    }

    A line segment with start and end points
    impl Show for Line[T]

    Line::new

    source
    fn[T] Line::new(start : T, end : T) -> Line[T]

    Line::output

    source
    fn[T : Show] Line::output(self : Line[T], logger : &Logger) -> Unit

    Line::to_string

    source
    fn[T : Show] Line::to_string(self : Line[T]) -> String

    LinearEasingPoint

    source
    pub(all) struct LinearEasingPoint {
      input : Double
      output : Double
    } derive(Eq, 
    Debug    )

    One point in a CSS linear() easing function.

    LinearEasingPoint::equal

    source

    LinearEasingPoint::new

    source
    fn LinearEasingPoint::new(input : Double, output : Double) -> LinearEasingPoint

    LinearEasingPoint::not_equal

    source
    fn LinearEasingPoint::not_equal(x : LinearEasingPoint, y : LinearEasingPoint) -> Bool

    LinearEasingPoint::output

    source
    fn LinearEasingPoint::output(self : LinearEasingPoint, logger : &Logger) -> Unit

    LinearEasingPoint::to_repr

    source

    LinearEasingPoint::to_string

    source
    fn LinearEasingPoint::to_string(self : LinearEasingPoint) -> String

    LinearGradient

    source
    pub(all) struct LinearGradient {
      angle_deg : Double
      stops : Array[GradientStop]
    } derive(Eq, 
    Debug    )

    Linear gradient with angle and color stops

    LinearGradient::equal

    source

    LinearGradient::not_equal

    source
    fn LinearGradient::not_equal(x : LinearGradient, y : LinearGradient) -> Bool

    LinearGradient::output

    source
    fn LinearGradient::output(self : LinearGradient, logger : &Logger) -> Unit

    LinearGradient::to_repr

    source

    LinearGradient::to_string

    source
    fn LinearGradient::to_string(self : LinearGradient) -> String

    MathOp

    source
    pub(all) enum MathOp {
      Min
      Max
      Clamp
    } derive(Eq, 
    Debug    )

    CSS comparison/math function selector for min() / max() / clamp().

    MathOp::equal

    source
    fn MathOp::equal(MathOp, MathOp) -> Bool

    MathOp::not_equal

    source
    fn MathOp::not_equal(x : MathOp, y : MathOp) -> Bool

    MathOp::to_repr

    source

    MaxTrackSizing

    source
    pub(all) enum MaxTrackSizing {
      Length(Double)
      Percent(Double)
      Fr(Double)
      Auto
      MinContent
      MaxContent
    } derive(Eq, 
    Debug    )

    Maximum track sizing function for minmax()

    MaxTrackSizing::equal

    source

    MaxTrackSizing::not_equal

    source
    fn MaxTrackSizing::not_equal(x : MaxTrackSizing, y : MaxTrackSizing) -> Bool

    MaxTrackSizing::output

    source
    fn MaxTrackSizing::output(self : MaxTrackSizing, logger : &Logger) -> Unit

    MaxTrackSizing::to_repr

    source

    MaxTrackSizing::to_string

    source
    fn MaxTrackSizing::to_string(self : MaxTrackSizing) -> String

    MinTrackSizing

    source
    pub(all) enum MinTrackSizing {
      Length(Double)
      Percent(Double)
      Auto
      MinContent
      MaxContent
    } derive(Eq, 
    Debug    )

    Minimum track sizing function for minmax()

    MinTrackSizing::equal

    source

    MinTrackSizing::not_equal

    source
    fn MinTrackSizing::not_equal(x : MinTrackSizing, y : MinTrackSizing) -> Bool

    MinTrackSizing::output

    source
    fn MinTrackSizing::output(self : MinTrackSizing, logger : &Logger) -> Unit

    MinTrackSizing::to_repr

    source

    MinTrackSizing::to_string

    source
    fn MinTrackSizing::to_string(self : MinTrackSizing) -> String

    Overflow

    source
    pub(all) enum Overflow {
      Visible
      Hidden
      Clip
      Scroll
      Auto
    } derive(Eq, 
    Debug    )

    CSS overflow property
    impl Show for Overflow

    Overflow::equal

    source
    fn Overflow::equal(Overflow, Overflow) -> Bool

    Overflow::not_equal

    source
    fn Overflow::not_equal(x : Overflow, y : Overflow) -> Bool

    Overflow::output

    source
    fn Overflow::output(self : Overflow, logger : &Logger) -> Unit

    Overflow::to_repr

    source

    Overflow::to_string

    source
    fn Overflow::to_string(self : Overflow) -> String

    Point

    source
    pub struct Point[T] {
      x : T
      y : T
    }

    2D point with x and y coordinates
    impl Show for Point[T]

    Point::map

    source
    fn[T, U] Point::map(self : Point[T], f : (T) -> U) -> Point[U]

    Point::new

    source
    fn[T] Point::new(x : T, y : T) -> Point[T]

    Point::output

    source
    fn[T : Show] Point::output(self : Point[T], logger : &Logger) -> Unit

    Point::to_string

    source
    fn[T : Show] Point::to_string(self : Point[T]) -> String

    Point::zero

    source
    fn Point::zero() -> Point[Double]

    Position

    source
    pub(all) enum Position {
      Static
      Relative
      Absolute
      Fixed
    } derive(Eq, 
    Debug    )

    CSS position property
    impl Show for Position

    Position::equal

    source
    fn Position::equal(Position, Position) -> Bool

    Position::not_equal

    source
    fn Position::not_equal(x : Position, y : Position) -> Bool

    Position::output

    source
    fn Position::output(self : Position, logger : &Logger) -> Unit

    Position::to_repr

    source

    Position::to_string

    source
    fn Position::to_string(self : Position) -> String

    Rect

    source
    pub(all) struct Rect[T] {
      left : T
      right : T
      top : T
      bottom : T
    } derive(Eq, 
    Debug    )

    Rectangle with left, right, top, bottom edges Used for margin, padding, border, inset
    impl Show for Rect[T]

    Rect::all

    source
    fn[T] Rect::all(value : T) -> Rect[T]

    Create a rect with all sides set to the same value

    Rect::equal

    source
    fn[T : Eq] Rect::equal(Rect[T], Rect[T]) -> Bool

    Rect::horizontal_sum

    source
    fn Rect::horizontal_sum(self : Rect[Double]) -> Double

    Sum of left and right (horizontal axis)

    Rect::map

    source
    fn[T, U] Rect::map(self : Rect[T], f : (T) -> U) -> Rect[U]

    Rect::new

    source
    fn[T] Rect::new(left : T, right : T, top : T, bottom : T) -> Rect[T]

    Rect::not_equal

    source
    fn[T : Eq] Rect::not_equal(x : Rect[T], y : Rect[T]) -> Bool

    Rect::output

    source
    fn[T : Show] Rect::output(self : Rect[T], logger : &Logger) -> Unit

    Rect::to_repr

    source

    Rect::to_string

    source
    fn[T : Show] Rect::to_string(self : Rect[T]) -> String

    Rect::vertical_sum

    source
    fn Rect::vertical_sum(self : Rect[Double]) -> Double

    Sum of top and bottom (vertical axis)

    Rect::zero

    source
    fn Rect::zero() -> Rect[Double]

    RepeatCount

    source
    pub(all) enum RepeatCount {
      Count(Int)
      AutoFill
      AutoFit
    } derive(Eq, 
    Debug    )

    Repeat count for repeat() function
    impl Show for RepeatCount

    RepeatCount::equal

    source
    fn RepeatCount::equal(RepeatCount, RepeatCount) -> Bool

    RepeatCount::not_equal

    source
    fn RepeatCount::not_equal(x : RepeatCount, y : RepeatCount) -> Bool

    RepeatCount::output

    source
    fn RepeatCount::output(self : RepeatCount, logger : &Logger) -> Unit

    RepeatCount::to_repr

    source

    RepeatCount::to_string

    source
    fn RepeatCount::to_string(self : RepeatCount) -> String

    SingleTrackSizing

    source
    pub(all) enum SingleTrackSizing {
      Length(Double)
      Percent(Double)
      Fr(Double)
      Auto
      MinContent
      MaxContent
      MinMax(MinTrackSizing, MaxTrackSizing)
      FitContentLength(Double)
      FitContentPercent(Double)
    } derive(Eq, 
    Debug    )

    Single track sizing function (non-repeating)

    SingleTrackSizing::equal

    source

    SingleTrackSizing::not_equal

    source
    fn SingleTrackSizing::not_equal(x : SingleTrackSizing, y : SingleTrackSizing) -> Bool

    SingleTrackSizing::output

    source
    fn SingleTrackSizing::output(self : SingleTrackSizing, logger : &Logger) -> Unit

    SingleTrackSizing::to_repr

    source

    SingleTrackSizing::to_string

    source
    fn SingleTrackSizing::to_string(self : SingleTrackSizing) -> String

    Size

    source
    pub struct Size[T] {
      width : T
      height : T
    }

    2D size with width and height
    impl Show for Size[T]

    Size::map

    source
    fn[T, U] Size::map(self : Size[T], f : (T) -> U) -> Size[U]

    Size::new

    source
    fn[T] Size::new(width : T, height : T) -> Size[T]

    Size::output

    source
    fn[T : Show] Size::output(self : Size[T], logger : &Logger) -> Unit

    Size::to_string

    source
    fn[T : Show] Size::to_string(self : Size[T]) -> String

    Size::zero

    source
    fn Size::zero() -> Size[Double]

    StepPosition

    source
    pub(all) enum StepPosition {
      Start
      End
      JumpNone
      JumpBoth
    } derive(Eq, 
    Debug    )

    Step timing function jump position.

    StepPosition::equal

    source

    StepPosition::not_equal

    source
    fn StepPosition::not_equal(x : StepPosition, y : StepPosition) -> Bool

    StepPosition::output

    source
    fn StepPosition::output(self : StepPosition, logger : &Logger) -> Unit

    StepPosition::to_repr

    source

    StepPosition::to_string

    source
    fn StepPosition::to_string(self : StepPosition) -> String

    TrackSizingFunction

    source
    pub(all) enum TrackSizingFunction {
      Length(Double)
      Percent(Double)
      Fr(Double)
      Auto
      MinContent
      MaxContent
      MinMax(MinTrackSizing, MaxTrackSizing)
      Repeat(RepeatCount, Array[SingleTrackSizing], Array[Array[String]])
      FitContentLength(Double)
      FitContentPercent(Double)
    } derive(Eq, 
    Debug    )

    Track sizing function for grid-template-rows/columns

    TrackSizingFunction::equal

    source

    TrackSizingFunction::not_equal

    source

    TrackSizingFunction::output

    source
    fn TrackSizingFunction::output(self : TrackSizingFunction, logger : &Logger) -> Unit

    TrackSizingFunction::to_repr

    source

    TrackSizingFunction::to_string

    source
    fn TrackSizingFunction::to_string(self : TrackSizingFunction) -> String

    apply_aspect_ratio_height

    source
    fn apply_aspect_ratio_height(width : Double, aspect_ratio : Double?) -> Double?

    Apply aspect ratio to calculate height from width. Returns height if aspect_ratio is defined, otherwise returns None.

    apply_aspect_ratio_width

    source
    fn apply_aspect_ratio_width(height : Double, aspect_ratio : Double?) -> Double?

    Apply aspect ratio to calculate width from height. Returns width if aspect_ratio is defined, otherwise returns None.

    apply_math_op

    source
    fn apply_math_op(op : MathOp, vals : Array[Double]) -> Double

    Apply a min()/max()/clamp() reduction over already-resolved scalar values. clamp expects exactly 3 values (lo, val, hi); other lengths fall back to the first value (or 0.0 when empty) so callers never panic on malformed input.

    clamp

    source
    fn clamp(value : Double, min_val : Double, max_val : Double) -> Double

    Clamp a value between min and max CSS spec: min takes precedence over max when they conflict So apply max first (value cannot exceed max), then min (value cannot go below min)

    max

    source
    fn max(a : Double, b : Double) -> Double

    min

    source
    fn min(a : Double, b : Double) -> Double

    parse_easing

    source
    fn parse_easing(value : String) -> Easing?

    Parse a CSS easing keyword or basic timing function.

    resolve_dimensions_with_aspect_ratio

    source
    fn resolve_dimensions_with_aspect_ratio(width : Double?, height : Double?, aspect_ratio : Double?, min_width : Double, max_width : Double, min_height : Double, max_height : Double) -> (Double?, Double?)

    Resolve dimensions with aspect ratio. Given known dimension (width or height), aspect_ratio, and min/max constraints, returns the final (width, height) pair.

    • If width is known, height = width / aspect_ratio
    • If height is known, width = height * aspect_ratio
    • If both are known, aspect_ratio overrides the height
    • Min/max constraints are applied after aspect ratio calculation

    resolve_rect

    source
    fn resolve_rect(rect : Rect[Dimension], parent_width : Double) -> Rect[Double]

    Resolve a Rect[Dimension] (margin/padding/border) to Rect[Double] Uses parent_width for percentage resolution (CSS spec: percentages resolve against width)

    resolve_rect_intrinsic

    source
    fn resolve_rect_intrinsic(rect : Rect[Dimension]) -> Rect[Double]

    Resolve a dimension rect for intrinsic sizing Percentages resolve to 0 in intrinsic sizing contexts

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io