🥮 mooncakes.io
    Sign in

    mizchi/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

    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

    AnimationDirection

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

    animation-direction value.

    AnimationFillMode

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

    animation-fill-mode value.

    AnimationIterationCount

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

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

    AnimationPlayState

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

    animation-play-state value.

    BackgroundImage

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

    Background image (currently only linear-gradient)

    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::right

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

    Get the right edge (x + width)

    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

    Clear

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

    CSS clear property
    impl Show for Clear

    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

    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::is_opaque

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

    Color::is_transparent

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

    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_rgba_string

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

    Convert to CSS rgba() string

    Color::transparent

    source
    fn Color::transparent() -> Color

    Transparent color (alpha = 0)

    Color::white

    source
    fn Color::white() -> Color

    White color

    CssFloat

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

    CSS float property
    impl Show for CssFloat

    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::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::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

    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

    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::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::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

    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

    FlexDirection

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

    Flex direction

    FlexWrap

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

    Flex wrap mode
    impl Show for FlexWrap

    GradientStop

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

    A color stop in a gradient

    GridAutoFlow

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

    Grid auto-flow direction

    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

    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

    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.

    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]

    LinearEasingPoint

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

    One point in a CSS linear() easing function.

    LinearEasingPoint::new

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

    LinearGradient

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

    Linear gradient with angle and color stops

    MathOp

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

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

    MaxTrackSizing

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

    Maximum track sizing function for minmax()

    MinTrackSizing

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

    Minimum track sizing function for minmax()

    Overflow

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

    CSS overflow property
    impl Show for Overflow

    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::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

    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::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::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

    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)

    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::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.

    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

    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