Source file transforms.ml

(** Transform utilities for 2D and 3D transformations. *)

module Css = Cascade.Css

(** Error helpers *)
let err_not_utility = Error (`Msg "Not a transform utility")

module Handler = struct
  open Style

  (* Capture the project Pp before [open Css] shadows it with Css.Pp. *)
  let pp_float = Pp.float

  open Css

  type t =
    | (* 2D Transforms *)
      Rotate of int
    | Rotate_arbitrary of string * Css.angle
    | Rotate_raw of string * string
    | Rotate_none
    | Rotate_3d_arbitrary of string * float * float * float * Css.angle
    | Rotate_bare_var of string
    | Neg_rotate_bare_var of string
    | Neg_rotate_arbitrary of string
    | Translate_x of int
    | Translate_x_full
    | Translate_x_px
    | Translate_x_step of float
    | Translate_x_arbitrary of string * Css.length
    | Translate_x_raw of string * string
    | Translate_y of int
    | Translate_y_full
    | Translate_y_px
    | Translate_y_step of float
    | Translate_y_arbitrary of string * Css.length
    | Translate_y_raw of string * string
    | Scale of int
    | Scale_x of int
    | Scale_x_arbitrary of string * [ `Num of float | `Raw of string ]
    | Scale_y of int
    | Scale_y_arbitrary of string * [ `Num of float | `Raw of string ]
    | Scale_raw_1 of string * float
    | Scale_raw_3 of string * float * float * float
    | Scale_arbitrary_raw of string * string
    | Skew_x of int
    | Skew_x_arbitrary of string * [ `Angle of Css.angle | `Raw of string ]
    | Skew_y of int
    | Skew_y_arbitrary of string * [ `Angle of Css.angle | `Raw of string ]
    | Skew of int
    | Skew_arbitrary of string * [ `Angle of Css.angle | `Raw of string ]
    | Neg_skew_arbitrary of string
    | Neg_skew_x_arbitrary of string
    | Neg_skew_y_arbitrary of string
    | Translate_x_fraction of int * int
    | Translate_y_fraction of int * int
    | (* Combined translate utilities *)
      Translate of int
    | Translate_full
    | Translate_none
    | Translate_px
    | Translate_1_2
    | Translate_fraction of int * int
    | Translate_arbitrary of string * Css.length
    | Translate_raw of string * string
    | (* Negative translate utilities *)
      Neg_translate of int
    | Neg_translate_arbitrary of string
    | Neg_translate_full
    | Neg_translate_px
    | Neg_translate_fraction of int * int
    | Neg_translate_x_arbitrary of string
    | Neg_translate_x_full
    | Neg_translate_x_px
    | Neg_translate_x_1_2
    | Neg_translate_x_fraction of int * int
    | Neg_translate_y_arbitrary of string
    | Neg_translate_y_full
    | Neg_translate_y_px
    | Neg_translate_y_1_2
    | Neg_translate_y_fraction of int * int
    | (* 3D Transforms *)
      Translate_z of int
    | Translate_z_step of float (* translate-z-0.5, a half-step scale value *)
    | Translate_z_px
    | Translate_z_arbitrary of
        string * [ `Length of Css.length | `Raw of string ]
    | Neg_translate_z_arbitrary of string
    | Neg_translate_z_px
    | Translate_3d
    | Rotate_x of int
    | Rotate_x_arbitrary of string * Css.angle
    | Rotate_x_raw of string * string
    | Rotate_x_bare_var of string
    | Neg_rotate_x_bare_var of string
    | Neg_rotate_x_arbitrary of string
    | Rotate_y of int
    | Rotate_y_arbitrary of string * Css.angle
    | Rotate_y_raw of string * string
    | Rotate_y_bare_var of string
    | Neg_rotate_y_bare_var of string
    | Neg_rotate_y_arbitrary of string
    | Rotate_z of int
    | Rotate_z_arbitrary of string * Css.angle
    | Rotate_z_raw of string * string
    | Rotate_z_bare_var of string
    | Neg_rotate_z_bare_var of string
    | Neg_rotate_z_arbitrary of string
    | Scale_z of int
    | Scale_z_arbitrary of string
    | (* The negative bracket forms hold the bracket as written; the style reads
         it, as the negative translate forms do. *)
      Neg_scale_arbitrary of string
    | Neg_scale_x_arbitrary of string
    | Neg_scale_y_arbitrary of string
    | Neg_scale_z_arbitrary of string
    | Scale_3d
    | Scale_none
    | Perspective_none
    | (* depth named by a project [--perspective-*] token *)
      Perspective_theme of string
    | Perspective_dramatic
    | Perspective_near
    | Perspective_normal
    | Perspective_midrange
    | Perspective_distant
    | Perspective_arbitrary of string * Css.length
    | Perspective_raw of string * string
    | (* Perspective origin *)
      Perspective_origin_center
    | Perspective_origin_top
    | Perspective_origin_bottom
    | Perspective_origin_left
    | Perspective_origin_right
    | Perspective_origin_top_left
    | Perspective_origin_top_right
    | Perspective_origin_bottom_left
    | Perspective_origin_bottom_right
    (* The author's bracket text travels with the value it denotes, so the class
       name is spelled exactly as it was written. *)
    | Perspective_origin_arbitrary of string * Css.perspective_origin
    | Perspective_origin_raw of string * string
    | (* Transform style *)
      Transform_style_3d
    | Transform_style_flat
    | (* Transform box *)
      Transform_box_border
    | Transform_box_content
    | Transform_box_fill
    | Transform_box_stroke
    | Transform_box_view
    | (* Backface visibility *)
      Backface_visible
    | Backface_hidden
    | (* Transform control *)
      Transform
    | Transform_cpu
    | Transform_none
    | Transform_gpu
    | Transform_arbitrary of string * Css.transform list
    | Transform_raw of string * string
      (* A bracket no reader took, on any of these families: the class names one
         longhand or one channel, so the value goes there verbatim - Tailwind's
         token-stream contract. *)
    | (* Transform origin *)
      Origin_center
    | Origin_top
    | Origin_bottom
    | Origin_left
    | Origin_right
    | Origin_top_left
    | Origin_top_right
    | Origin_bottom_left
    | Origin_bottom_right
    | Origin_arbitrary of string * Css.transform_origin
    | Origin_raw of string * string

  (** Priority for transform utilities *)
  let name = "transforms"

  (* The transform chain sits before animations. Controls that Tailwind sorts
     through a later property band must not travel with it: origin precedes the
     chain, backface follows selection, perspective follows backface, and
     transform box/style follow text-shadow. *)
  let priority = function
    | Origin_center | Origin_top | Origin_bottom | Origin_left | Origin_right
    | Origin_top_left | Origin_top_right | Origin_bottom_left
    | Origin_bottom_right | Origin_arbitrary _ | Origin_raw _ ->
        8
    | Backface_visible | Backface_hidden -> 38
    | Perspective_none | Perspective_theme _ | Perspective_dramatic
    | Perspective_near | Perspective_normal | Perspective_midrange
    | Perspective_distant | Perspective_arbitrary _ | Perspective_raw _
    | Perspective_origin_center | Perspective_origin_top
    | Perspective_origin_bottom | Perspective_origin_left
    | Perspective_origin_right | Perspective_origin_top_left
    | Perspective_origin_top_right | Perspective_origin_bottom_left
    | Perspective_origin_bottom_right | Perspective_origin_arbitrary _
    | Perspective_origin_raw _ ->
        40
    | Transform_style_3d | Transform_style_flat | Transform_box_border
    | Transform_box_content | Transform_box_fill | Transform_box_stroke
    | Transform_box_view ->
        42
    | _ -> 9

  (* Tailwind v4 uses rotate-x/y/z and skew-x/y variables for the transform
     utility. These variables contain the full transform function values, e.g.:
     --tw-rotate-x: rotateX(45deg) --tw-skew-x: skewX(10deg) *)
  (* Property ordering to match Tailwind v4:
     translate (0-2), scale (3-5), then other properties follow *)

  (* Translate variables - use property_default pattern with initial 0 *)
  (* Translate properties don't appear in @layer properties in standard Tailwind - only used locally *)
  let tw_translate_x_var =
    Var.property_default Css.Length ~initial:Css.Zero ~universal:true
      ~property_order:0 ~family:`Translate "tw-translate-x"

  let tw_translate_y_var =
    Var.property_default Css.Length ~initial:Css.Zero ~universal:true
      ~property_order:1 ~family:`Translate "tw-translate-y"

  let tw_translate_z_var =
    Var.property_default Css.Length ~initial:Css.Zero ~universal:true
      ~property_order:2 ~family:`Translate "tw-translate-z"

  (* Scale variables - property_order (6-8) comes after duration (5) *)
  let tw_scale_x_var =
    Var.property_default Css.Number_percentage ~initial:(Num 1.0)
      ~universal:true ~property_order:6 ~family:`Scale "tw-scale-x"

  let tw_scale_y_var =
    Var.property_default Css.Number_percentage ~initial:(Num 1.0)
      ~universal:true ~property_order:7 ~family:`Scale "tw-scale-y"

  let tw_scale_z_var =
    Var.property_default Css.Number_percentage ~initial:(Num 1.0)
      ~universal:true ~property_order:8 ~family:`Scale "tw-scale-z"

  (* Rotate and skew properties appear FIRST in @layer properties (0-4) *)
  let tw_rotate_x_var =
    Var.channel ~needs_property:true ~property_order:0 ~family:`Rotate
      Css.Transform "tw-rotate-x"

  let tw_rotate_y_var =
    Var.channel ~needs_property:true ~property_order:1 ~family:`Rotate
      Css.Transform "tw-rotate-y"

  let tw_rotate_z_var =
    Var.channel ~needs_property:true ~property_order:2 ~family:`Rotate
      Css.Transform "tw-rotate-z"

  let tw_skew_x_var =
    Var.channel ~needs_property:true ~property_order:3 ~family:`Skew
      Css.Transform "tw-skew-x"

  let tw_skew_y_var =
    Var.channel ~needs_property:true ~property_order:4 ~family:`Skew
      Css.Transform "tw-skew-y"

  (* Perspective theme variables, ordered by value to match Tailwind's theme.
     The family owns slots (8, 10-16), after blur (8, 0-8). *)
  let perspective_dramatic_var =
    Var.theme Css.Length "perspective-dramatic" ~order:(8, 10)

  let perspective_near_var =
    Var.theme Css.Length "perspective-near" ~order:(8, 11)

  let perspective_normal_var =
    Var.theme Css.Length "perspective-normal" ~order:(8, 12)

  let perspective_midrange_var =
    Var.theme Css.Length "perspective-midrange" ~order:(8, 13)

  let perspective_distant_var =
    Var.theme Css.Length "perspective-distant" ~order:(8, 14)

  (* A [--perspective-*] token the project declared names a depth the built-in
     scale has no slot for; they share the slot after the scale. *)
  let perspective_named_cache = Domain_cache.v 8

  let perspective_named_var name =
    Domain_cache.or_add perspective_named_cache name (fun () ->
        Var.theme Css.Length ("perspective-" ^ name) ~order:(8, 16))

  let perspective_none_var =
    Var.theme Css.Length "perspective-none" ~order:(8, 15)

  (* Publish the scale through the theme-token registry, the way rule.ml
     publishes the breakpoints, so [perspective-[theme(--perspective-normal)]]
     resolves and [theme(static)] emits it. [--perspective-none] is not in
     Tailwind's default theme - the utility writes [perspective: none] - so it
     stays out. *)
  let () =
    List.iter
      (fun (var, px) -> Theme.register_default var (Css.Px px : Css.length))
      [
        (perspective_dramatic_var, 100.);
        (perspective_near_var, 300.);
        (perspective_normal_var, 500.);
        (perspective_midrange_var, 800.);
        (perspective_distant_var, 1200.);
      ]

  (** {1 Helpers} *)

  let collect_property_rules vars =
    List.filter_map Var.property_rule vars |> concat

  (* Property rules for rotate/skew transform chain *)
  let rotate_skew_props =
    collect_property_rules
      [
        tw_rotate_x_var;
        tw_rotate_y_var;
        tw_rotate_z_var;
        tw_skew_x_var;
        tw_skew_y_var;
      ]

  (* Helper to create transform with variable chain: Sets one variable and
     outputs transform with all rotate/skew vars *)
  let transform_with_var var transform_val =
    let d = Var.set var transform_val in
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    style ~property_rules:rotate_skew_props
      [
        d;
        transforms
          [
            Var rotate_x_ref;
            Var rotate_y_ref;
            Var rotate_z_ref;
            Var skew_x_ref;
            Var skew_y_ref;
          ];
      ]

  (* Helper to create an angle with calc for negative values *)
  let make_angle deg =
    if deg >= 0 then Deg (float_of_int deg)
    else Calc (Expr (Val (Deg (float_of_int (abs deg))), Mul, Num (-1.)))

  (* Helper to create a percentage with calc for negative values *)
  let make_pct n : Css.number_percentage =
    if n >= 0 then Pct (float_of_int n)
    else Calc (Expr (Val (Pct (float_of_int (abs n))), Mul, Num (-1.)))

  let transform_with_both_skew_angle angle =
    let skew_x_decl = Var.set tw_skew_x_var (Skew_x angle) in
    let skew_y_decl = Var.set tw_skew_y_var (Skew_y angle) in
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    style ~property_rules:rotate_skew_props
      [
        skew_x_decl;
        skew_y_decl;
        transforms
          [
            Var rotate_x_ref;
            Var rotate_y_ref;
            Var rotate_z_ref;
            Var skew_x_ref;
            Var skew_y_ref;
          ];
      ]

  let transform_with_both_skew deg =
    let angle = make_angle deg in
    let skew_x_decl = Var.set tw_skew_x_var (Skew_x angle) in
    let skew_y_decl = Var.set tw_skew_y_var (Skew_y angle) in
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    style ~property_rules:rotate_skew_props
      [
        skew_x_decl;
        skew_y_decl;
        transforms
          [
            Var rotate_x_ref;
            Var rotate_y_ref;
            Var rotate_z_ref;
            Var skew_x_ref;
            Var skew_y_ref;
          ];
      ]

  let neg_class name n =
    let prefix = if n < 0 then "-" else "" in
    prefix ^ name ^ string_of_int (abs n)

  let parse_bracket_length s : (Css.length, _) result =
    if Parse.is_bracket_value s then (
      let inner = Parse.bracket_inner s in
      let slen = String.length inner in
      (* Allow a leading minus so negative arbitrary values
         (translate-x-[-0.5px], translate-y-[-110%]) parse. *)
      let i = ref (if slen > 0 && inner.[0] = '-' then 1 else 0) in
      while
        !i < slen
        && ((inner.[!i] >= '0' && inner.[!i] <= '9') || inner.[!i] = '.')
      do
        incr i
      done;
      if !i = 0 || !i = slen then
        Error (`Msg ("Invalid length value: " ^ inner))
      else
        let num_s = String.sub inner 0 !i in
        let unit_s = String.sub inner !i (slen - !i) in
        match Float.of_string_opt num_s with
        | Option.None -> Error (`Msg ("Invalid length value: " ^ inner))
        | Option.Some n -> (
            match unit_s with
            | "px" -> Ok (Px n : Css.length)
            | "rem" -> Ok (Rem n)
            | "em" -> Ok (Em n)
            | "vw" -> Ok (Vw n)
            | "vh" -> Ok (Vh n)
            | "cm" -> Ok (Cm n)
            | "mm" -> Ok (Mm n)
            | "pt" -> Ok (Pt n)
            | "%" -> Ok (Pct n)
            | _ -> Error (`Msg ("Invalid length unit: " ^ unit_s))))
    else Error (`Msg ("Not a bracket value: " ^ s))

  (* The angle a bracket spells: a signed decimal under one of the four angle
     units. *)
  let angle_of_inner inner : Css.angle option =
    let slen = String.length inner in
    let i = ref 0 in
    while
      !i < slen
      && ((inner.[!i] >= '0' && inner.[!i] <= '9')
         || inner.[!i] = '.'
         || inner.[!i] = '-')
    do
      incr i
    done;
    if !i = 0 || !i = slen then None
    else
      let num_s = String.sub inner 0 !i in
      let unit_s = String.sub inner !i (slen - !i) in
      match (Float.of_string_opt num_s, unit_s) with
      | Some n, "deg" -> Some (Deg n)
      | Some n, "rad" -> Some (Rad n)
      | Some n, "turn" -> Some (Turn n)
      | Some n, "grad" -> Some (Grad n)
      | _ -> None

  (* The bracket names the class, so hand its text back beside the angle. *)
  let parse_bracket_angle s : (string * Css.angle, _) result =
    if Parse.is_bracket_value s then
      let inner = Parse.bracket_inner s in
      match angle_of_inner inner with
      | Some a -> Ok (inner, a)
      | None -> Error (`Msg ("Invalid angle value: " ^ inner))
    else Error (`Msg ("Not a bracket value: " ^ s))

  (* A bracket a negative translate takes: one holding a value, which every
     spelling of one becomes [calc(<value> * -1)]. *)
  let neg_bracket value =
    Parse.is_bracket_value value
    && Option.is_some
         (Parse.arbitrary_declaration_value (Parse.bracket_inner value))

  (* The number a bracket spells, when it is a plain decimal. A spelling only
     OCaml's number reader takes ([0x4]) is not a number under another name. *)
  let number_of_inner v = Parse.decimal_float (Parse.decode_arbitrary_value v)

  (* The bracket beside its reading: a plain decimal is the number it spells,
     and anything else goes to the custom property as written. *)
  let parse_bracket_number s =
    if Parse.is_bracket_value s then
      let inner = Parse.bracket_inner s in
      match number_of_inner inner with
      | Some f -> Ok (inner, `Num f)
      | None -> (
          match Parse.arbitrary_declaration_value inner with
          | Some v -> Ok (inner, `Raw v)
          | None -> Error (`Msg ("Invalid number: " ^ inner)))
    else Error (`Msg ("Not a bracket value: " ^ s))

  (** {1 2D Transform Utilities} *)

  let rotate n = style [ Css.rotate (Angle (Deg (float_of_int n))) ]
  let rotate_arbitrary angle = style [ Css.rotate (Angle angle) ]

  let opaque_style property value =
    match Parse.opaque_declaration property value with
    | Some declaration -> style [ declaration ]
    | None -> style []

  let rotate_3d_arbitrary x y z angle =
    style [ Css.rotate (Axis (x, y, z, angle)) ]

  let rotate_bare_var name =
    (* name is "--var", strip the -- prefix *)
    let bare = String.sub name 2 (String.length name - 2) in
    let ref : Css.angle Css.var = Var.bracket bare in
    style [ Css.rotate (Angle (Var ref)) ]

  let neg_rotate_bare_var name =
    (* name is "--var", strip the -- prefix for Calc.var *)
    let bare = String.sub name 2 (String.length name - 2) in
    let neg_angle : Css.angle =
      Calc (Expr (Var (Var.bracket bare), Mul, Num (-1.)))
    in
    style [ Css.rotate (Angle neg_angle) ]

  let translate_props =
    collect_property_rules
      [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]

  let translate_xy_refs =
    let tx_ref = Var.reference tw_translate_x_var in
    let ty_ref = Var.reference tw_translate_y_var in
    Css.translate (XY (Var tx_ref, Var ty_ref))

  let translate_xyz_refs =
    let tx_ref = Var.reference tw_translate_x_var in
    let ty_ref = Var.reference tw_translate_y_var in
    let tz_ref = Var.reference tw_translate_z_var in
    Css.translate (XYZ (Var tx_ref, Var ty_ref, Var tz_ref))

  (* The spacing step comes from [Theme], as every spacing family's does, so a
     project's [--spacing-N] token and an inline [--spacing] reach a translate
     the way they reach a padding. [calc(var(--spacing) * 0)] is zero whatever
     the spacing is, and Tailwind writes that zero with a unit: the target is a
     [--tw-*] custom property, an opaque token stream where [0] and [0px] are
     not the same token, which is the [0px] [Theme] writes. *)
  let translate_axis ?theme axis_var n =
    let spacing_decl, spacing_value = Theme.spacing_calc ?theme n in
    let axis_decl = Var.set axis_var spacing_value in
    style ~property_rules:translate_props
      (spacing_decl :: axis_decl :: [ translate_xy_refs ])

  let translate_x ?theme n = translate_axis ?theme tw_translate_x_var n
  let translate_y ?theme n = translate_axis ?theme tw_translate_y_var n

  (* A fractional spacing step ([translate-x-0.5]), signed so the negative form
     goes through the same path. *)
  let translate_axis_step ?theme axis_var f =
    let spacing_decl, spacing_value = Theme.spacing_calc_float ?theme f in
    let axis_decl = Var.set axis_var spacing_value in
    style ~property_rules:translate_props
      (spacing_decl :: axis_decl :: [ translate_xy_refs ])

  let translate_x_step ?theme f =
    translate_axis_step ?theme tw_translate_x_var f

  let translate_y_step ?theme f =
    translate_axis_step ?theme tw_translate_y_var f

  (** Helper to create a fraction percentage value: calc(n/d * 100%) *)
  let make_fraction_pct num denom : Css.length = Parse.fraction_length num denom

  (** Helper to create a negated fraction percentage value: calc(calc(n/d *
      100%) * -1) *)
  let make_neg_fraction_pct num denom : Css.length =
    Parse.neg_fraction_length num denom

  let translate_x_fraction num denom =
    let axis_decl = Var.set tw_translate_x_var (make_fraction_pct num denom) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let translate_y_fraction num denom =
    let axis_decl = Var.set tw_translate_y_var (make_fraction_pct num denom) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let translate_x_full =
    let axis_decl = Var.set tw_translate_x_var (Pct 100.0) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let translate_x_px =
    let axis_decl = Var.set tw_translate_x_var (Px 1.0) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let translate_x_arbitrary len =
    let axis_decl = Var.set tw_translate_x_var len in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let translate_y_full =
    let axis_decl = Var.set tw_translate_y_var (Pct 100.0) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let translate_y_px =
    let axis_decl = Var.set tw_translate_y_var (Px 1.0) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let translate_y_arbitrary len =
    let axis_decl = Var.set tw_translate_y_var len in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  (* The bracket [s] negated the way Tailwind writes a negative candidate: the
     value [read] takes, with any data-type hint taken off, comes back [`Typed]
     for the family to negate as its type, and every other value comes back
     [`Raw], the token stream [calc(<value> * -1)] between [before] and [after],
     which is the function call a channel holds. [None] is a bracket that names
     no value, which the reader refused. *)
  let neg_bracket_value ?(before = "") ?(after = "") read s =
    match Option.bind (Parse.value_after_hint s) read with
    | Some v -> Some (`Typed v)
    | None ->
        Option.bind (Parse.arbitrary_declaration_value s) (fun v ->
            Option.map
              (fun raw -> `Raw raw)
              (Parse.wrap_declaration_value ~before:(before ^ "calc(")
                 ~after:(" * -1)" ^ after) v))

  (* [var] set to the bracket [s] negated: a value [read] takes goes through
     [neg], the family's own negation, and a token stream is written as it
     is. *)
  let neg_channel_decl ?before ?after read neg var s =
    match neg_bracket_value ?before ?after read s with
    | Some (`Typed v) -> Some (Var.set var (neg v))
    | Some (`Raw v) ->
        Some (Css.custom_property ~layer:"utilities" (Var.css_name var) v)
    | None -> None

  let neg_length (l : Css.length) : Css.length =
    Calc (Calc.mul (Calc.length l) (Calc.float (-1.)))

  let neg_number f : Css.number_percentage =
    Calc (Calc.mul (Calc.float f) (Calc.float (-1.)))

  let neg_angle (a : Css.angle) : Css.angle =
    Calc (Calc.mul (Val a) (Calc.float (-1.)))

  (* A translate channel: a length is negated as a length. *)
  let neg_arbitrary_decl var s =
    neg_channel_decl Parse.arbitrary_length neg_length var s

  (* A negative bracket translate on [vars], the axes it sets. *)
  let neg_translate_arbitrary_on vars s =
    match List.map (fun var -> neg_arbitrary_decl var s) vars with
    | decls when List.for_all Option.is_some decls ->
        let decls = List.filter_map Fun.id decls in
        let refs =
          if List.memq tw_translate_z_var vars then translate_xyz_refs
          else translate_xy_refs
        in
        style ~property_rules:translate_props
          ~metadata:(List.map Var.metadata vars)
          (decls @ [ refs ])
    | _ -> style []

  let neg_translate_x_arbitrary_style s =
    neg_translate_arbitrary_on [ tw_translate_x_var ] s

  let neg_translate_y_arbitrary_style s =
    neg_translate_arbitrary_on [ tw_translate_y_var ] s

  let neg_translate_x_full =
    let axis_decl = Var.set tw_translate_x_var (Pct (-100.0)) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let neg_translate_y_full =
    let axis_decl = Var.set tw_translate_y_var (Pct (-100.0)) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let scale n =
    let value = make_pct n in
    let dx = Var.set tw_scale_x_var value in
    let dy = Var.set tw_scale_y_var value in
    let dz = Var.set tw_scale_z_var value in
    let props =
      collect_property_rules [ tw_scale_x_var; tw_scale_y_var; tw_scale_z_var ]
    in
    (* Also set the scale property with variable references *)
    let scale_x_ref = Var.reference tw_scale_x_var in
    let scale_y_ref = Var.reference tw_scale_y_var in
    style ~property_rules:props
      (dx :: dy :: dz :: [ Css.scale (XY (Var scale_x_ref, Var scale_y_ref)) ])

  let scale_x n =
    let value = make_pct n in
    let d = Var.set tw_scale_x_var value in
    let props =
      collect_property_rules [ tw_scale_x_var; tw_scale_y_var; tw_scale_z_var ]
    in
    let scale_x_ref = Var.reference tw_scale_x_var in
    let scale_y_ref = Var.reference tw_scale_y_var in
    style ~property_rules:props
      (d :: [ Css.scale (XY (Var scale_x_ref, Var scale_y_ref)) ])

  let scale_y n =
    let value = make_pct n in
    let d = Var.set tw_scale_y_var value in
    let props =
      collect_property_rules [ tw_scale_x_var; tw_scale_y_var; tw_scale_z_var ]
    in
    let scale_x_ref = Var.reference tw_scale_x_var in
    let scale_y_ref = Var.reference tw_scale_y_var in
    style ~property_rules:props
      (d :: [ Css.scale (XY (Var scale_x_ref, Var scale_y_ref)) ])

  (* One axis of the scale, from either the number the bracket denotes or, when
     it denotes none, the author's text: Tailwind hands a bracket to the custom
     property unvalidated, so [scale-x-[0x4]] sets [0x4] and not the [4] an
     OCaml number reader would fold it to. *)
  let scale_axis_arbitrary var v =
    let binding =
      match v with
      | `Num f -> Var.set var (Css.Num f : Css.number_percentage)
      | `Raw value ->
          Css.custom_property ~layer:"utilities" (Var.css_name var) value
    in
    let props =
      collect_property_rules [ tw_scale_x_var; tw_scale_y_var; tw_scale_z_var ]
    in
    let scale_x_ref = Var.reference tw_scale_x_var in
    let scale_y_ref = Var.reference tw_scale_y_var in
    style ~property_rules:props
      [ binding; Css.scale (XY (Var scale_x_ref, Var scale_y_ref)) ]

  let scale_x_arbitrary v = scale_axis_arbitrary tw_scale_x_var v
  let scale_y_arbitrary v = scale_axis_arbitrary tw_scale_y_var v

  let scale_props =
    collect_property_rules [ tw_scale_x_var; tw_scale_y_var; tw_scale_z_var ]

  let scale_xy_refs =
    let x = Var.reference tw_scale_x_var in
    let y = Var.reference tw_scale_y_var in
    Css.scale (XY (Var x, Var y))

  let scale_xyz_refs =
    let x = Var.reference tw_scale_x_var in
    let y = Var.reference tw_scale_y_var in
    let z = Var.reference tw_scale_z_var in
    Css.scale (XYZ (Var x, Var y, Var z))

  (* A negative bracket scale on [var], the axis it sets, beside [refs], the
     composition the positive form writes: a number is negated as a number. *)
  let neg_scale_axis_arbitrary var refs s =
    match neg_channel_decl number_of_inner neg_number var s with
    | Some decl ->
        style ~property_rules:scale_props
          ~metadata:[ Var.metadata var ]
          [ decl; refs ]
    | None -> style []

  let neg_scale_x_arbitrary =
    neg_scale_axis_arbitrary tw_scale_x_var scale_xy_refs

  let neg_scale_y_arbitrary =
    neg_scale_axis_arbitrary tw_scale_y_var scale_xy_refs

  let neg_scale_z_arbitrary =
    neg_scale_axis_arbitrary tw_scale_z_var scale_xyz_refs

  (* The bare form writes [scale] itself, as the positive one does. *)
  let neg_scale_arbitrary s =
    match neg_bracket_value number_of_inner s with
    | Some (`Typed f) -> style [ Css.scale (X (neg_number f)) ]
    | Some (`Raw v) -> opaque_style "scale" v
    | None -> style []

  let skew_x deg = transform_with_var tw_skew_x_var (Skew_x (make_angle deg))
  let skew_y deg = transform_with_var tw_skew_y_var (Skew_y (make_angle deg))
  let skew_x_arbitrary angle = transform_with_var tw_skew_x_var (Skew_x angle)
  let skew_y_arbitrary angle = transform_with_var tw_skew_y_var (Skew_y angle)

  (* The transform every rotate and skew channel utility writes, reading the
     five channels with an empty fallback each. *)
  let rotate_skew_chain =
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    transforms
      [
        Var rotate_x_ref;
        Var rotate_y_ref;
        Var rotate_z_ref;
        Var skew_x_ref;
        Var skew_y_ref;
      ]

  (* A negative bracket on [axes], each a rotate or skew channel with the
     function it holds and the transform that function is: the channel takes the
     function around the bracket negated, an angle as an angle and a token
     stream as [calc(<value> * -1)], beside the chain. *)
  let neg_chain_arbitrary_on axes s =
    let decl (var, fn, transform) =
      neg_channel_decl ~before:(fn ^ "(") ~after:")" angle_of_inner
        (fun a -> transform (neg_angle a))
        var s
    in
    match List.map decl axes with
    | decls when List.for_all Option.is_some decls ->
        style ~property_rules:rotate_skew_props
          ~metadata:(List.map (fun (var, _, _) -> Var.metadata var) axes)
          (List.filter_map Fun.id decls @ [ rotate_skew_chain ])
    | _ -> style []

  let skew_x_axis = (tw_skew_x_var, "skewX", fun a : Css.transform -> Skew_x a)
  let skew_y_axis = (tw_skew_y_var, "skewY", fun a : Css.transform -> Skew_y a)
  let neg_skew_x_arbitrary = neg_chain_arbitrary_on [ skew_x_axis ]
  let neg_skew_y_arbitrary = neg_chain_arbitrary_on [ skew_y_axis ]
  let neg_skew_arbitrary = neg_chain_arbitrary_on [ skew_x_axis; skew_y_axis ]

  let rotate_x_axis =
    (tw_rotate_x_var, "rotateX", fun a : Css.transform -> Rotate_x a)

  let rotate_y_axis =
    (tw_rotate_y_var, "rotateY", fun a : Css.transform -> Rotate_y a)

  let rotate_z_axis =
    (tw_rotate_z_var, "rotateZ", fun a : Css.transform -> Rotate_z a)

  let neg_rotate_x_arbitrary = neg_chain_arbitrary_on [ rotate_x_axis ]
  let neg_rotate_y_arbitrary = neg_chain_arbitrary_on [ rotate_y_axis ]
  let neg_rotate_z_arbitrary = neg_chain_arbitrary_on [ rotate_z_axis ]

  (* The bare form writes [rotate] itself, as the positive one does. *)
  let neg_rotate_arbitrary s =
    match neg_bracket_value angle_of_inner s with
    | Some (`Typed a) -> style [ Css.rotate (Angle (neg_angle a)) ]
    | Some (`Raw v) -> opaque_style "rotate" v
    | None -> style []

  let raw_skew_style axes value =
    let raw var fn =
      Parse.wrap_declaration_value ~before:(fn ^ "(") ~after:")" value
      |> Option.map (Css.custom_property ~layer:"utilities" (Var.css_name var))
    in
    let bindings, metadata =
      match axes with
      | `X ->
          ( Option.to_list (raw tw_skew_x_var "skewX"),
            [ Var.metadata tw_skew_x_var ] )
      | `Y ->
          ( Option.to_list (raw tw_skew_y_var "skewY"),
            [ Var.metadata tw_skew_y_var ] )
      | `Both ->
          ( List.filter_map Fun.id
              [ raw tw_skew_x_var "skewX"; raw tw_skew_y_var "skewY" ],
            [ Var.metadata tw_skew_x_var; Var.metadata tw_skew_y_var ] )
    in
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    style ~property_rules:rotate_skew_props ~metadata
      (bindings
      @ [
          transforms
            [
              Var rotate_x_ref;
              Var rotate_y_ref;
              Var rotate_z_ref;
              Var skew_x_ref;
              Var skew_y_ref;
            ];
        ])

  (* A bracket no reader took, written into the channel the class names and into
     the transform chain that reads it. [raw_skew_style] above is the same shape
     for the skew channels; this is the rotate one. *)
  let raw_rotate_style var fn value =
    let binding =
      Parse.wrap_declaration_value ~before:(fn ^ "(") ~after:")" value
      |> Option.map (Css.custom_property ~layer:"utilities" (Var.css_name var))
    in
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    style ~property_rules:rotate_skew_props
      ~metadata:[ Var.metadata var ]
      (Option.to_list binding
      @ [
          transforms
            [
              Var rotate_x_ref;
              Var rotate_y_ref;
              Var rotate_z_ref;
              Var skew_x_ref;
              Var skew_y_ref;
            ];
        ])

  (* The translate channels take the value itself rather than a function call,
     so the raw form writes the text straight into the channel. *)
  let raw_translate_style vars value =
    let binding var =
      Css.custom_property ~layer:"utilities" (Var.css_name var) value
    in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props
      ~metadata:(List.map Var.metadata vars)
      (List.map binding vars @ [ translate_xy_refs ])

  (* Combined translate utilities *)
  let translate_full =
    let dx = Var.set tw_translate_x_var (Pct 100.0) in
    let dy = Var.set tw_translate_y_var (Pct 100.0) in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props (dx :: dy :: [ translate_xy_refs ])

  (* Combined spacing translate (translate-N / -translate-N): both axes bound to
     calc(var(--spacing) * n); a negative n renders the "* -n" multiplier. *)
  let translate_spacing ?theme n =
    let spacing_decl, spacing_value =
      Theme.spacing_product ?theme (float_of_int n)
    in
    let dx = Var.set tw_translate_x_var spacing_value in
    let dy = Var.set tw_translate_y_var spacing_value in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props
      (spacing_decl :: dx :: dy :: [ translate_xy_refs ])

  let translate_1_2 =
    (* Tailwind outputs calc(1 / 2 * 100%) rather than 50% *)
    let half_pct : Css.length =
      Css.Calc
        (Css.Calc.mul
           (Css.Calc.div (Css.Calc.float 1.) (Css.Calc.float 2.))
           (Css.Calc.length (Css.Pct 100.)))
    in
    let dx = Var.set tw_translate_x_var half_pct in
    let dy = Var.set tw_translate_y_var half_pct in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props (dx :: dy :: [ translate_xy_refs ])

  let translate_arbitrary len =
    let dx = Var.set tw_translate_x_var len in
    let dy = Var.set tw_translate_y_var len in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props (dx :: dy :: [ translate_xy_refs ])

  let translate_px =
    let dx = Var.set tw_translate_x_var (Px 1.0) in
    let dy = Var.set tw_translate_y_var (Px 1.0) in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props (dx :: dy :: [ translate_xy_refs ])

  let neg_translate_px =
    let dx = Var.set tw_translate_x_var (Px (-1.0)) in
    let dy = Var.set tw_translate_y_var (Px (-1.0)) in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props (dx :: dy :: [ translate_xy_refs ])

  let neg_translate_x_px =
    let axis_decl = Var.set tw_translate_x_var (Px (-1.0)) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let neg_translate_y_px =
    let axis_decl = Var.set tw_translate_y_var (Px (-1.0)) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let neg_translate_arbitrary_style s =
    neg_translate_arbitrary_on [ tw_translate_x_var; tw_translate_y_var ] s

  let neg_translate_full =
    let dx = Var.set tw_translate_x_var (Pct (-100.0)) in
    let dy = Var.set tw_translate_y_var (Pct (-100.0)) in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props (dx :: dy :: [ translate_xy_refs ])

  let translate_fraction num denom =
    let frac_pct = make_fraction_pct num denom in
    let dx = Var.set tw_translate_x_var frac_pct in
    let dy = Var.set tw_translate_y_var frac_pct in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props (dx :: dy :: [ translate_xy_refs ])

  let neg_translate_fraction num denom =
    let neg_frac_pct = make_neg_fraction_pct num denom in
    let dx = Var.set tw_translate_x_var neg_frac_pct in
    let dy = Var.set tw_translate_y_var neg_frac_pct in
    let props =
      collect_property_rules
        [ tw_translate_x_var; tw_translate_y_var; tw_translate_z_var ]
    in
    style ~property_rules:props (dx :: dy :: [ translate_xy_refs ])

  let neg_translate_x_fraction num denom =
    let axis_decl =
      Var.set tw_translate_x_var (make_neg_fraction_pct num denom)
    in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  let neg_translate_y_fraction num denom =
    let axis_decl =
      Var.set tw_translate_y_var (make_neg_fraction_pct num denom)
    in
    style ~property_rules:translate_props (axis_decl :: [ translate_xy_refs ])

  (* Legacy negative translate utilities for centering - kept for backward
     compat *)
  let neg_translate_x_1_2 = neg_translate_x_fraction 1 2
  let neg_translate_y_1_2 = neg_translate_y_fraction 1 2

  (** {1 3D Transform Utilities} *)

  let rotate_x n = transform_with_var tw_rotate_x_var (Rotate_x (make_angle n))

  let rotate_x_arbitrary angle =
    transform_with_var tw_rotate_x_var (Rotate_x angle)

  let rotate_x_bare_var name =
    let bare = String.sub name 2 (String.length name - 2) in
    let ref : Css.angle Css.var = Var.bracket bare in
    transform_with_var tw_rotate_x_var (Rotate_x (Var ref))

  let neg_rotate_x_bare_var name =
    let bare = String.sub name 2 (String.length name - 2) in
    let neg : Css.angle =
      Calc (Expr (Var (Var.bracket bare), Mul, Num (-1.)))
    in
    transform_with_var tw_rotate_x_var (Rotate_x neg)

  let rotate_y n = transform_with_var tw_rotate_y_var (Rotate_y (make_angle n))

  let rotate_y_arbitrary angle =
    transform_with_var tw_rotate_y_var (Rotate_y angle)

  let rotate_y_bare_var name =
    let bare = String.sub name 2 (String.length name - 2) in
    let ref : Css.angle Css.var = Var.bracket bare in
    transform_with_var tw_rotate_y_var (Rotate_y (Var ref))

  let neg_rotate_y_bare_var name =
    let bare = String.sub name 2 (String.length name - 2) in
    let neg : Css.angle =
      Calc (Expr (Var (Var.bracket bare), Mul, Num (-1.)))
    in
    transform_with_var tw_rotate_y_var (Rotate_y neg)

  let rotate_z n = transform_with_var tw_rotate_z_var (Rotate_z (make_angle n))

  let rotate_z_arbitrary angle =
    transform_with_var tw_rotate_z_var (Rotate_z angle)

  let rotate_z_bare_var name =
    let bare = String.sub name 2 (String.length name - 2) in
    let ref : Css.angle Css.var = Var.bracket bare in
    transform_with_var tw_rotate_z_var (Rotate_z (Var ref))

  let neg_rotate_z_bare_var name =
    let bare = String.sub name 2 (String.length name - 2) in
    let neg : Css.angle =
      Calc (Expr (Var (Var.bracket bare), Mul, Num (-1.)))
    in
    transform_with_var tw_rotate_z_var (Rotate_z neg)

  let translate_z ?theme n =
    let spacing_decl, spacing_value =
      Theme.spacing_product ?theme (float_of_int n)
    in
    let axis_decl = Var.set tw_translate_z_var spacing_value in
    style ~property_rules:translate_props
      (spacing_decl :: axis_decl :: [ translate_xyz_refs ])

  (* A fractional spacing step ([translate-z-0.5]), mirroring
     [translate_axis_step] for the X/Y axes. *)
  let translate_z_step ?theme f =
    let spacing_decl, spacing_value = Theme.spacing_product ?theme f in
    let axis_decl = Var.set tw_translate_z_var spacing_value in
    style ~property_rules:translate_props
      (spacing_decl :: axis_decl :: [ translate_xyz_refs ])

  let translate_z_px =
    let axis_decl = Var.set tw_translate_z_var (Px 1.0) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xyz_refs ])

  let translate_z_arbitrary = function
    | `Length length ->
        let axis_decl = Var.set tw_translate_z_var length in
        style ~property_rules:translate_props
          (axis_decl :: [ translate_xyz_refs ])
    | `Raw value ->
        style ~property_rules:translate_props
          ~metadata:[ Var.metadata tw_translate_z_var ]
          [
            Css.custom_property ~layer:"utilities"
              (Var.css_name tw_translate_z_var)
              value;
            translate_xyz_refs;
          ]

  let neg_translate_z_arbitrary_style s =
    neg_translate_arbitrary_on [ tw_translate_z_var ] s

  let neg_translate_z_px =
    let axis_decl = Var.set tw_translate_z_var (Px (-1.0)) in
    style ~property_rules:translate_props (axis_decl :: [ translate_xyz_refs ])

  let translate_3d =
    style ~property_rules:translate_props [ translate_xyz_refs ]

  let scale_z n =
    let value = make_pct n in
    let d = Var.set tw_scale_z_var value in
    let props =
      collect_property_rules [ tw_scale_x_var; tw_scale_y_var; tw_scale_z_var ]
    in
    let scale_x_ref = Var.reference tw_scale_x_var in
    let scale_y_ref = Var.reference tw_scale_y_var in
    let scale_z_ref = Var.reference tw_scale_z_var in
    style ~property_rules:props
      (d
      :: [ Css.scale (XYZ (Var scale_x_ref, Var scale_y_ref, Var scale_z_ref)) ]
      )

  let scale_z_arbitrary s =
    (* Arbitrary values pass through verbatim into [--tw-scale-z], whose
       [@property] uses [syntax: "*"]. *)
    let d =
      Css.custom_property ~layer:"utilities" "--tw-scale-z"
        (Parse.decode_arbitrary_value s)
    in
    let props =
      collect_property_rules [ tw_scale_x_var; tw_scale_y_var; tw_scale_z_var ]
    in
    let scale_x_ref = Var.reference tw_scale_x_var in
    let scale_y_ref = Var.reference tw_scale_y_var in
    let scale_z_ref = Var.reference tw_scale_z_var in
    style ~property_rules:props
      [ d; Css.scale (XYZ (Var scale_x_ref, Var scale_y_ref, Var scale_z_ref)) ]

  let scale_3d =
    let props =
      collect_property_rules [ tw_scale_x_var; tw_scale_y_var; tw_scale_z_var ]
    in
    let scale_x_ref = Var.reference tw_scale_x_var in
    let scale_y_ref = Var.reference tw_scale_y_var in
    let scale_z_ref = Var.reference tw_scale_z_var in
    style ~property_rules:props
      [ Css.scale (XYZ (Var scale_x_ref, Var scale_y_ref, Var scale_z_ref)) ]

  (* A project that declares [--perspective-none] chooses the length the utility
     resolves to, so read its value with the CSS length grammar rather than a
     px-only test whose failure arm was a fabricated zero. A value the grammar
     cannot read falls back to the utility's own meaning and still reaches the
     sheet unaltered, since the theme layer restores the project's own text over
     the bound value. *)
  let perspective_none ?theme () =
    match Scheme.theme_value theme "perspective-none" with
    | Some value ->
        let len =
          Option.value
            (Css.parse_length (String.trim value))
            ~default:(None : Css.length)
        in
        let decl, r = Var.binding perspective_none_var len in
        style (decl :: [ Css.perspective (Var r) ])
    | None -> style [ Css.perspective None ]

  let is_theme_perspective theme n =
    Scheme.theme_value (Some theme) ("perspective-" ^ n) <> None

  let perspective_theme theme name =
    match Scheme.theme_value (Some theme) ("perspective-" ^ name) with
    | None -> style []
    | Some raw -> (
        match Css.parse_length raw with
        | None -> style []
        | Some len ->
            let decl, r = Var.binding (perspective_named_var name) len in
            style (decl :: [ Css.perspective (Var r) ]))

  let perspective_dramatic =
    let decl, r = Var.binding perspective_dramatic_var (Px 100.0) in
    style (decl :: [ Css.perspective (Var r) ])

  let perspective_near =
    let decl, r = Var.binding perspective_near_var (Px 300.0) in
    style (decl :: [ Css.perspective (Var r) ])

  let perspective_normal =
    let decl, r = Var.binding perspective_normal_var (Px 500.0) in
    style (decl :: [ Css.perspective (Var r) ])

  let perspective_midrange =
    let decl, r = Var.binding perspective_midrange_var (Px 800.0) in
    style (decl :: [ Css.perspective (Var r) ])

  let perspective_distant =
    let decl, r = Var.binding perspective_distant_var (Px 1200.0) in
    style (decl :: [ Css.perspective (Var r) ])

  let perspective_arbitrary len = style [ Css.perspective len ]

  let po_with_ref ?theme name (default : Css.perspective_origin) default_css ()
      =
    match Scheme.theme_value theme name with
    | Some value_str ->
        let decl = Css.custom_property ~layer:"theme" ("--" ^ name) value_str in
        let ref : Css.perspective_origin =
          Var (Var.theme_ref name ~default ~default_css)
        in
        let perspective_ref : Css.length =
          Css.Var
            (Var.theme_ref name ~default:(Css.Zero : Css.length) ~default_css)
        in
        style [ decl; perspective_origin ref; Css.perspective perspective_ref ]
    (* Without a theme override Tailwind writes the keyword, not a reference to
       a token nothing declares. *)
    | None -> style [ perspective_origin default ]

  let perspective_origin_center ?theme () =
    po_with_ref ?theme "perspective-origin-center" Center "center" ()

  let perspective_origin_top ?theme () =
    po_with_ref ?theme "perspective-origin-top" Top "top" ()

  let perspective_origin_bottom ?theme () =
    po_with_ref ?theme "perspective-origin-bottom" Bottom "bottom" ()

  let perspective_origin_left ?theme () =
    po_with_ref ?theme "perspective-origin-left" (Single Zero) "0" ()

  let perspective_origin_right ?theme () =
    po_with_ref ?theme "perspective-origin-right" (Single (Pct 100.)) "100%" ()

  let perspective_origin_top_left ?theme () =
    po_with_ref ?theme "perspective-origin-top-left" (XY (Zero, Zero)) "0 0" ()

  let perspective_origin_top_right ?theme () =
    po_with_ref ?theme "perspective-origin-top-right"
      (XY (Pct 100., Zero))
      "100% 0" ()

  let perspective_origin_bottom_left ?theme () =
    po_with_ref ?theme "perspective-origin-bottom-left"
      (XY (Zero, Pct 100.))
      "0 100%" ()

  let perspective_origin_bottom_right ?theme () =
    po_with_ref ?theme "perspective-origin-bottom-right"
      (XY (Pct 100., Pct 100.))
      "100% 100%" ()

  let perspective_origin_arbitrary po = style [ perspective_origin po ]
  let transform_style_3d = style [ transform_style Preserve_3d ]
  let transform_style_flat = style [ transform_style Flat ]
  let transform_box_border = style [ Css.transform_box Border_box ]
  let transform_box_content = style [ Css.transform_box Content_box ]
  let transform_box_fill = style [ Css.transform_box Fill_box ]
  let transform_box_stroke = style [ Css.transform_box Stroke_box ]
  let transform_box_view = style [ Css.transform_box View_box ]
  let backface_visible = style [ backface_visibility Visible ]
  let backface_hidden = style [ backface_visibility Hidden ]

  (** {1 Transform Origin Utilities}

      Tailwind v4 uses theme variable references for origin utilities when theme
      variables are defined. *)

  let origin_with_ref ?theme name (default : Css.transform_origin) default_css
      () =
    match Scheme.theme_value theme name with
    | Some value_str ->
        let decl = Css.custom_property ~layer:"theme" ("--" ^ name) value_str in
        let ref : Css.transform_origin Css.var =
          Var.theme_ref name ~default ~default_css
        in
        style [ decl; transform_origin (Var ref) ]
    | None -> style [ transform_origin default ]

  let origin_center ?theme () =
    origin_with_ref ?theme "transform-origin-center" Center "center" ()

  let origin_top ?theme () =
    origin_with_ref ?theme "transform-origin-top" Top "top" ()

  let origin_bottom ?theme () =
    origin_with_ref ?theme "transform-origin-bottom" Bottom "bottom" ()

  let origin_left ?theme () =
    origin_with_ref ?theme "transform-origin-left" (X Zero) "0" ()

  let origin_right ?theme () =
    origin_with_ref ?theme "transform-origin-right" (X (Pct 100.)) "100%" ()

  let origin_top_left ?theme () =
    origin_with_ref ?theme "transform-origin-top-left"
      (XY (Zero, Zero))
      "0 0" ()

  let origin_top_right ?theme () =
    origin_with_ref ?theme "transform-origin-top-right"
      (XY (Pct 100., Zero))
      "100% 0" ()

  let origin_bottom_left ?theme () =
    origin_with_ref ?theme "transform-origin-bottom-left"
      (XY (Zero, Pct 100.))
      "0 100%" ()

  let origin_bottom_right ?theme () =
    origin_with_ref ?theme "transform-origin-bottom-right"
      (XY (Pct 100., Pct 100.))
      "100% 100%" ()

  let origin_arbitrary t = style [ transform_origin t ]

  (** {1 Transform Control Utilities} *)

  (* Tailwind v4 transform utility uses individual rotate-x/y/z and skew-x/y
     variables with empty fallbacks. The output is: transform:
     var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,)
     var(--tw-skew-x,) var(--tw-skew-y,); When a variable is set (e.g.,
     --tw-rotate-x: rotateX(45deg)), it becomes part of the transform. *)
  let transform =
    (* Create var references with Empty fallbacks for optional transform
       components *)
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    (* Collect @property rules for these variables *)
    let property_rules =
      collect_property_rules
        [
          tw_rotate_x_var;
          tw_rotate_y_var;
          tw_rotate_z_var;
          tw_skew_x_var;
          tw_skew_y_var;
        ]
    in
    style ~property_rules
      [
        transforms
          [
            Var rotate_x_ref;
            Var rotate_y_ref;
            Var rotate_z_ref;
            Var skew_x_ref;
            Var skew_y_ref;
          ];
      ]

  let transform_none = style [ Css.transform None ]

  (* [transform-cpu] writes what [transform] writes. The [@property] block for
     the five channels belongs to [transform] alone, though: Tailwind declares
     them there and neither of the two below carries them, so asking for the
     rules here put a whole [@layer properties] in a sheet whose only transform
     utility was this one. *)
  let transform_cpu =
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    style
      [
        transforms
          [
            Var rotate_x_ref;
            Var rotate_y_ref;
            Var rotate_z_ref;
            Var skew_x_ref;
            Var skew_y_ref;
          ];
      ]

  (* transform-gpu adds translateZ(0) for GPU acceleration plus all var refs. No
     [@property] block here either; see [transform_cpu]. *)
  let transform_gpu =
    let rotate_x_ref = Var.reference_with_empty_fallback tw_rotate_x_var in
    let rotate_y_ref = Var.reference_with_empty_fallback tw_rotate_y_var in
    let rotate_z_ref = Var.reference_with_empty_fallback tw_rotate_z_var in
    let skew_x_ref = Var.reference_with_empty_fallback tw_skew_x_var in
    let skew_y_ref = Var.reference_with_empty_fallback tw_skew_y_var in
    style
      [
        transforms
          [
            Translate_z Zero;
            Var rotate_x_ref;
            Var rotate_y_ref;
            Var rotate_z_ref;
            Var skew_x_ref;
            Var skew_y_ref;
          ];
      ]

  (** {1 Parsing Functions} *)

  let ( >|= ) = Parse.( >|= )

  (** {1 Utility Conversion Functions} *)

  let to_style theme =
    let perspective_none () = perspective_none ~theme () in
    let perspective_origin_center () = perspective_origin_center ~theme () in
    let perspective_origin_top () = perspective_origin_top ~theme () in
    let perspective_origin_bottom () = perspective_origin_bottom ~theme () in
    let perspective_origin_left () = perspective_origin_left ~theme () in
    let perspective_origin_right () = perspective_origin_right ~theme () in
    let perspective_origin_top_left () =
      perspective_origin_top_left ~theme ()
    in
    let perspective_origin_top_right () =
      perspective_origin_top_right ~theme ()
    in
    let perspective_origin_bottom_left () =
      perspective_origin_bottom_left ~theme ()
    in
    let perspective_origin_bottom_right () =
      perspective_origin_bottom_right ~theme ()
    in
    let origin_center () = origin_center ~theme () in
    let origin_top () = origin_top ~theme () in
    let origin_bottom () = origin_bottom ~theme () in
    let origin_left () = origin_left ~theme () in
    let origin_right () = origin_right ~theme () in
    let origin_top_left () = origin_top_left ~theme () in
    let origin_top_right () = origin_top_right ~theme () in
    let origin_bottom_left () = origin_bottom_left ~theme () in
    let origin_bottom_right () = origin_bottom_right ~theme () in
    function
    | Rotate n -> rotate n
    | Rotate_arbitrary (_, a) -> rotate_arbitrary a
    | Rotate_raw (_, value) -> opaque_style "rotate" value
    | Rotate_none -> style [ Css.rotate None ]
    | Rotate_3d_arbitrary (_, x, y, z, a) -> rotate_3d_arbitrary x y z a
    | Rotate_bare_var name -> rotate_bare_var name
    | Neg_rotate_bare_var name -> neg_rotate_bare_var name
    | Neg_rotate_arbitrary s -> neg_rotate_arbitrary s
    | Translate_x n -> translate_x ~theme n
    | Translate_x_full -> translate_x_full
    | Translate_x_px -> translate_x_px
    | Translate_x_step f -> translate_x_step ~theme f
    | Translate_x_arbitrary (_, len) -> translate_x_arbitrary len
    | Translate_x_raw (_, v) -> raw_translate_style [ tw_translate_x_var ] v
    | Translate_y_raw (_, v) -> raw_translate_style [ tw_translate_y_var ] v
    | Translate_raw (_, v) ->
        raw_translate_style [ tw_translate_x_var; tw_translate_y_var ] v
    | Rotate_x_raw (_, v) -> raw_rotate_style tw_rotate_x_var "rotateX" v
    | Rotate_y_raw (_, v) -> raw_rotate_style tw_rotate_y_var "rotateY" v
    | Rotate_z_raw (_, v) -> raw_rotate_style tw_rotate_z_var "rotateZ" v
    | Perspective_raw (_, v) ->
        style (Option.to_list (Parse.opaque_declaration "perspective" v))
    | Perspective_origin_raw (_, v) ->
        style (Option.to_list (Parse.opaque_declaration "perspective-origin" v))
    | Origin_raw (_, v) ->
        style (Option.to_list (Parse.opaque_declaration "transform-origin" v))
    | Transform_raw (_, v) ->
        style (Option.to_list (Parse.opaque_declaration "transform" v))
    | Translate_x_fraction (num, denom) -> translate_x_fraction num denom
    | Translate_y n -> translate_y ~theme n
    | Translate_y_full -> translate_y_full
    | Translate_y_px -> translate_y_px
    | Translate_y_step f -> translate_y_step ~theme f
    | Translate_y_arbitrary (_, len) -> translate_y_arbitrary len
    | Translate_y_fraction (num, denom) -> translate_y_fraction num denom
    | Translate n -> translate_spacing ~theme n
    | Neg_translate n -> translate_spacing ~theme (-n)
    | Translate_full -> translate_full
    | Translate_none -> style [ Css.translate None ]
    | Translate_px -> translate_px
    | Translate_1_2 -> translate_1_2
    | Translate_fraction (num, denom) -> translate_fraction num denom
    | Translate_arbitrary (_, len) -> translate_arbitrary len
    | Neg_translate_arbitrary s -> neg_translate_arbitrary_style s
    | Neg_translate_full -> neg_translate_full
    | Neg_translate_px -> neg_translate_px
    | Neg_translate_x_px -> neg_translate_x_px
    | Neg_translate_y_px -> neg_translate_y_px
    | Neg_translate_fraction (num, denom) -> neg_translate_fraction num denom
    | Neg_translate_x_arbitrary s -> neg_translate_x_arbitrary_style s
    | Neg_translate_x_full -> neg_translate_x_full
    | Neg_translate_x_1_2 -> neg_translate_x_1_2
    | Neg_translate_x_fraction (num, denom) ->
        neg_translate_x_fraction num denom
    | Neg_translate_y_arbitrary s -> neg_translate_y_arbitrary_style s
    | Neg_translate_y_full -> neg_translate_y_full
    | Neg_translate_y_1_2 -> neg_translate_y_1_2
    | Neg_translate_y_fraction (num, denom) ->
        neg_translate_y_fraction num denom
    | Translate_z n -> translate_z ~theme n
    | Translate_z_step f -> translate_z_step ~theme f
    | Translate_z_px -> translate_z_px
    | Translate_z_arbitrary (_, value) -> translate_z_arbitrary value
    | Neg_translate_z_arbitrary s -> neg_translate_z_arbitrary_style s
    | Neg_translate_z_px -> neg_translate_z_px
    | Translate_3d -> translate_3d
    | Scale n -> scale n
    | Scale_x n -> scale_x n
    | Scale_x_arbitrary (_, v) -> scale_x_arbitrary v
    | Scale_y n -> scale_y n
    | Scale_y_arbitrary (_, v) -> scale_y_arbitrary v
    | Scale_raw_1 (_, f) -> style [ Css.scale (X (Num f)) ]
    | Scale_raw_3 (_, x, y, z) ->
        style [ Css.scale (XYZ (Num x, Num y, Num z)) ]
    | Scale_arbitrary_raw (_, value) -> opaque_style "scale" value
    | Scale_z n -> scale_z n
    | Scale_z_arbitrary s -> scale_z_arbitrary s
    | Neg_scale_arbitrary s -> neg_scale_arbitrary s
    | Neg_scale_x_arbitrary s -> neg_scale_x_arbitrary s
    | Neg_scale_y_arbitrary s -> neg_scale_y_arbitrary s
    | Neg_scale_z_arbitrary s -> neg_scale_z_arbitrary s
    | Scale_3d -> scale_3d
    | Scale_none -> style [ Css.scale None ]
    | Skew_x n -> skew_x n
    | Skew_x_arbitrary (_, `Angle a) -> skew_x_arbitrary a
    | Skew_x_arbitrary (_, `Raw value) -> raw_skew_style `X value
    | Skew_y n -> skew_y n
    | Skew_y_arbitrary (_, `Angle a) -> skew_y_arbitrary a
    | Skew_y_arbitrary (_, `Raw value) -> raw_skew_style `Y value
    | Skew n -> transform_with_both_skew n
    | Skew_arbitrary (_, `Angle a) -> transform_with_both_skew_angle a
    | Skew_arbitrary (_, `Raw value) -> raw_skew_style `Both value
    | Neg_skew_arbitrary s -> neg_skew_arbitrary s
    | Neg_skew_x_arbitrary s -> neg_skew_x_arbitrary s
    | Neg_skew_y_arbitrary s -> neg_skew_y_arbitrary s
    | Rotate_x n -> rotate_x n
    | Rotate_x_arbitrary (_, a) -> rotate_x_arbitrary a
    | Rotate_x_bare_var name -> rotate_x_bare_var name
    | Neg_rotate_x_bare_var name -> neg_rotate_x_bare_var name
    | Neg_rotate_x_arbitrary s -> neg_rotate_x_arbitrary s
    | Rotate_y n -> rotate_y n
    | Rotate_y_arbitrary (_, a) -> rotate_y_arbitrary a
    | Rotate_y_bare_var name -> rotate_y_bare_var name
    | Neg_rotate_y_bare_var name -> neg_rotate_y_bare_var name
    | Neg_rotate_y_arbitrary s -> neg_rotate_y_arbitrary s
    | Rotate_z n -> rotate_z n
    | Rotate_z_arbitrary (_, a) -> rotate_z_arbitrary a
    | Rotate_z_bare_var name -> rotate_z_bare_var name
    | Neg_rotate_z_bare_var name -> neg_rotate_z_bare_var name
    | Neg_rotate_z_arbitrary s -> neg_rotate_z_arbitrary s
    | Perspective_none -> perspective_none ()
    | Perspective_dramatic -> perspective_dramatic
    | Perspective_theme name -> perspective_theme theme name
    | Perspective_near -> perspective_near
    | Perspective_normal -> perspective_normal
    | Perspective_midrange -> perspective_midrange
    | Perspective_distant -> perspective_distant
    | Perspective_arbitrary (_, len) -> perspective_arbitrary len
    | Perspective_origin_center -> perspective_origin_center ()
    | Perspective_origin_top -> perspective_origin_top ()
    | Perspective_origin_bottom -> perspective_origin_bottom ()
    | Perspective_origin_left -> perspective_origin_left ()
    | Perspective_origin_right -> perspective_origin_right ()
    | Perspective_origin_top_left -> perspective_origin_top_left ()
    | Perspective_origin_top_right -> perspective_origin_top_right ()
    | Perspective_origin_bottom_left -> perspective_origin_bottom_left ()
    | Perspective_origin_bottom_right -> perspective_origin_bottom_right ()
    | Perspective_origin_arbitrary (_, po) -> perspective_origin_arbitrary po
    | Transform_style_3d -> transform_style_3d
    | Transform_style_flat -> transform_style_flat
    | Transform_box_border -> transform_box_border
    | Transform_box_content -> transform_box_content
    | Transform_box_fill -> transform_box_fill
    | Transform_box_stroke -> transform_box_stroke
    | Transform_box_view -> transform_box_view
    | Backface_visible -> backface_visible
    | Backface_hidden -> backface_hidden
    | Transform -> transform
    | Transform_cpu -> transform_cpu
    | Transform_none -> transform_none
    | Transform_gpu -> transform_gpu
    | Transform_arbitrary (_, ts) -> style [ transforms ts ]
    | Origin_center -> origin_center ()
    | Origin_top -> origin_top ()
    | Origin_bottom -> origin_bottom ()
    | Origin_left -> origin_left ()
    | Origin_right -> origin_right ()
    | Origin_top_left -> origin_top_left ()
    | Origin_top_right -> origin_top_right ()
    | Origin_bottom_left -> origin_bottom_left ()
    | Origin_bottom_right -> origin_bottom_right ()
    | Origin_arbitrary (_, t) -> origin_arbitrary t

  let suborder = function
    | Transform -> 2000
    | Transform_arbitrary _ | Transform_raw _ -> 2001
    | Transform_cpu -> 2002
    | Transform_gpu -> 2003
    | Transform_none -> 2004
    (* Candidate values share a slot within each sign/axis band. Tailwind uses
       the natural candidate spelling inside that slot; baking the magnitude
       into the suborder reverses negatives and lets a large value spill into
       the next axis. *)
    | Neg_translate _ | Neg_translate_arbitrary _ | Neg_translate_full
    | Neg_translate_px | Neg_translate_fraction _ ->
        20
    | Translate _ | Translate_arbitrary _ | Translate_raw _ | Translate_full
    | Translate_px | Translate_1_2 | Translate_fraction _ ->
        21
    | Translate_x n when n < 0 -> 100
    | Translate_x_step f when f < 0. -> 100
    | Neg_translate_x_arbitrary _ | Neg_translate_x_full | Neg_translate_x_px
    | Neg_translate_x_1_2 | Neg_translate_x_fraction _ ->
        100
    | Translate_x _ | Translate_x_fraction _ | Translate_x_full | Translate_x_px
    | Translate_x_step _ | Translate_x_arbitrary _ | Translate_x_raw _ ->
        101
    | Translate_y n when n < 0 -> 200
    | Translate_y_step f when f < 0. -> 200
    | Neg_translate_y_arbitrary _ | Neg_translate_y_full | Neg_translate_y_px
    | Neg_translate_y_1_2 | Neg_translate_y_fraction _ ->
        200
    | Translate_y _ | Translate_y_fraction _ | Translate_y_full | Translate_y_px
    | Translate_y_step _ | Translate_y_arbitrary _ | Translate_y_raw _ ->
        201
    | Translate_z n when n < 0 -> 300
    | Translate_z_step f when f < 0. -> 300
    | Neg_translate_z_arbitrary _ | Neg_translate_z_px -> 300
    | Translate_z _ | Translate_z_step _ | Translate_z_px
    | Translate_z_arbitrary _ ->
        301
    | Translate_3d | Translate_none -> 302
    (* Scale utilities use the same sign/axis bands. *)
    | Scale n when n < 0 -> 400
    | Neg_scale_arbitrary _ -> 400
    | Scale _ | Scale_raw_1 _ | Scale_raw_3 _ | Scale_arbitrary_raw _ -> 401
    | Scale_x n when n < 0 -> 500
    | Neg_scale_x_arbitrary _ -> 500
    | Scale_x _ | Scale_x_arbitrary _ -> 501
    | Scale_y n when n < 0 -> 600
    | Neg_scale_y_arbitrary _ -> 600
    | Scale_y _ | Scale_y_arbitrary _ -> 601
    | Scale_z n when n < 0 -> 700
    | Neg_scale_z_arbitrary _ -> 700
    | Scale_z _ | Scale_z_arbitrary _ -> 701
    | Scale_3d | Scale_none -> 702
    (* Rotate utilities: sign first, then a bare variable, named values and the
       arbitrary/none tail. Axes each get their own sign pair. *)
    | Rotate n when n < 0 -> 799
    | Neg_rotate_bare_var _ | Neg_rotate_arbitrary _ -> 799
    | Rotate_bare_var _ -> 800
    | Rotate _ -> 801
    | Rotate_3d_arbitrary _ | Rotate_arbitrary _ | Rotate_raw _ | Rotate_none ->
        802
    | Rotate_x n when n < 0 -> 900
    | Neg_rotate_x_bare_var _ | Neg_rotate_x_arbitrary _ -> 900
    | Rotate_x _ | Rotate_x_bare_var _ | Rotate_x_arbitrary _ | Rotate_x_raw _
      ->
        901
    | Rotate_y n when n < 0 -> 1000
    | Neg_rotate_y_bare_var _ | Neg_rotate_y_arbitrary _ -> 1000
    | Rotate_y _ | Rotate_y_bare_var _ | Rotate_y_arbitrary _ | Rotate_y_raw _
      ->
        1001
    | Rotate_z n when n < 0 -> 1100
    | Neg_rotate_z_bare_var _ | Neg_rotate_z_arbitrary _ -> 1100
    | Rotate_z _ | Rotate_z_bare_var _ | Rotate_z_arbitrary _ | Rotate_z_raw _
      ->
        1101
    (* Combined skew precedes skew-x, then skew-y. *)
    | Skew n when n < 0 -> 1200
    | Neg_skew_arbitrary _ -> 1200
    | Skew _ | Skew_arbitrary _ -> 1201
    | Skew_x n when n < 0 -> 1210
    | Neg_skew_x_arbitrary _ -> 1210
    | Skew_x _ | Skew_x_arbitrary _ -> 1211
    | Skew_y n when n < 0 -> 1300
    | Neg_skew_y_arbitrary _ -> 1300
    | Skew_y _ | Skew_y_arbitrary _ -> 1301
    (* Perspective depths are one candidate band; Tailwind orders their class
       spellings rather than their semantic distance. *)
    | Perspective_arbitrary _ | Perspective_raw _ | Perspective_dramatic
    | Perspective_none | Perspective_theme _ | Perspective_normal
    | Perspective_near | Perspective_midrange | Perspective_distant ->
        1400
    | Perspective_origin_arbitrary _ | Perspective_origin_raw _ -> 1499
    | Perspective_origin_bottom -> 1500
    | Perspective_origin_bottom_left -> 1501
    | Perspective_origin_bottom_right -> 1502
    | Perspective_origin_center -> 1503
    | Perspective_origin_left -> 1504
    | Perspective_origin_right -> 1505
    | Perspective_origin_top -> 1506
    | Perspective_origin_top_left -> 1507
    | Perspective_origin_top_right -> 1508
    (* Alphabetical by class name: backface-hidden, backface-visible,
       transform-3d, transform-border, ..., transform-flat, ...,
       transform-view *)
    | Backface_hidden -> 1600
    | Backface_visible -> 1601
    | Transform_style_3d -> 1602
    | Transform_box_border -> 1603
    | Transform_box_content -> 1604
    | Transform_box_fill -> 1605
    | Transform_style_flat -> 1606
    | Transform_box_stroke -> 1607
    | Transform_box_view -> 1608
    (* Transform origin - alphabetical: bottom, bottom-left, bottom-right,
       center, left, right, top, top-left, top-right *)
    | Origin_bottom -> 1700
    | Origin_bottom_left -> 1701
    | Origin_bottom_right -> 1702
    | Origin_center -> 1703
    | Origin_left -> 1704
    | Origin_right -> 1705
    | Origin_top -> 1706
    | Origin_top_left -> 1707
    | Origin_top_right -> 1708
    | Origin_arbitrary _ | Origin_raw _ -> 1699

  (* A fractional spacing step: [0.5], [2.5]. Integers keep the existing
     path. *)
  let parse_spacing_step s =
    match Parse.decimal_float s with
    | Some f when f > 0. && not (Float.is_integer f) -> Some f
    | _ -> None

  (* The translate family writes [calc(n / m * 100%)] out rather than folding
     it, so it takes every fraction Tailwind reads, a zero on either side
     included. *)
  let parse_fraction = Parse.fraction

  (* The value a bracket denotes, read with the grammar cascade already has for
     the property, off the arbitrary-value pipeline every other family reads:
     [_] stands for a space, [--spacing(n)] expands, and a binary [+] gets the
     spaces CSS math wants, so [calc(1px+1px)] is a value rather than a parse
     error. [None] is a bracket that grammar refuses, and [of_class] declines
     the utility rather than leaving [to_style] to raise.

     A data-type hint chooses which longhand a bracket lands in and says nothing
     about the value. Every family reading through here writes one longhand, so
     the hint lands there and [read] is handed what follows it. A bracket whose
     hint is empty names no utility, which is the other [None]. The caller keeps
     the bracket whole for the class name, which is what the markup carries. *)
  let arbitrary_value read inner =
    Option.bind (Parse.value_after_hint inner) (fun value ->
        let cursor =
          Cascade.Cursor.of_string (Parse.decode_arbitrary_value value)
        in
        match Cascade.Cursor.try_parse_full_err read cursor with
        | Ok v -> Some v
        | Error _ -> None)

  let of_class theme class_name =
    let parts = Parse.split_class class_name in
    match parts with
    | [ "rotate"; n ] when Parse.is_bare_var n ->
        Ok (Rotate_bare_var (Parse.bare_var_inner n))
    | [ "rotate"; n ] when Parse.is_bracket_value n -> (
        let inner = Parse.bracket_inner n in
        (* The 3D form is four components, [x y z <angle>]. [_] separates them
           and [\_] is a literal underscore inside one, so the value is decoded
           before it is split. What the axes take is a CSS number, which OCaml's
           own float reader is wider than: it reads [1_2] as 12, where the value
           is meant to reach the sheet as written. *)
        let parts_3d =
          String.split_on_char ' ' (Parse.decode_underscores inner)
        in
        match parts_3d with
        | [ x; y; z; a ] -> (
            match
              ( Parse.decimal_float x,
                Parse.decimal_float y,
                Parse.decimal_float z,
                parse_bracket_angle ("[" ^ a ^ "]") )
            with
            | Some fx, Some fy, Some fz, Ok (_, angle) ->
                Ok (Rotate_3d_arbitrary (inner, fx, fy, fz, angle))
            | _ -> (
                match parse_bracket_angle n with
                | Ok (raw, a) -> Ok (Rotate_arbitrary (raw, a))
                | Error _ -> (
                    match Parse.arbitrary_declaration_value inner with
                    | Some value -> Ok (Rotate_raw (inner, value))
                    | None -> err_not_utility)))
        | _ -> (
            match parse_bracket_angle n with
            | Ok (raw, a) -> Ok (Rotate_arbitrary (raw, a))
            | Error _ -> (
                match Parse.arbitrary_declaration_value inner with
                | Some value -> Ok (Rotate_raw (inner, value))
                | None -> err_not_utility)))
    | [ "rotate"; "none" ] -> Ok Rotate_none
    | [ "rotate"; n ] -> Parse.int_any n >|= fun n -> Rotate n
    | [ "translate"; "x"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_length n with
        | Ok len -> Ok (Translate_x_arbitrary (Parse.bracket_inner n, len))
        | Error _ -> (
            let raw = Parse.bracket_inner n in
            match Parse.arbitrary_declaration_value raw with
            | Some v -> Ok (Translate_x_raw (raw, v))
            | None -> err_not_utility))
    | [ "translate"; "x"; "full" ] -> Ok Translate_x_full
    | [ "translate"; "x"; "px" ] -> Ok Translate_x_px
    | [ "translate"; "x"; n ] when String.contains n '/' -> (
        match parse_fraction n with
        | Some (num, denom) -> Ok (Translate_x_fraction (num, denom))
        | None -> err_not_utility)
    | [ "translate"; "x"; n ] when parse_spacing_step n <> None ->
        Ok (Translate_x_step (Option.get (parse_spacing_step n)))
    | [ "translate"; "x"; n ] -> Parse.int_any n >|= fun n -> Translate_x n
    | [ "translate"; "y"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_length n with
        | Ok len -> Ok (Translate_y_arbitrary (Parse.bracket_inner n, len))
        | Error _ -> (
            let raw = Parse.bracket_inner n in
            match Parse.arbitrary_declaration_value raw with
            | Some v -> Ok (Translate_y_raw (raw, v))
            | None -> err_not_utility))
    | [ "translate"; "y"; "full" ] -> Ok Translate_y_full
    | [ "translate"; "y"; "px" ] -> Ok Translate_y_px
    | [ "translate"; "y"; n ] when String.contains n '/' -> (
        match parse_fraction n with
        | Some (num, denom) -> Ok (Translate_y_fraction (num, denom))
        | None -> err_not_utility)
    | [ "translate"; "y"; n ] when parse_spacing_step n <> None ->
        Ok (Translate_y_step (Option.get (parse_spacing_step n)))
    | [ "translate"; "y"; n ] -> Parse.int_any n >|= fun n -> Translate_y n
    | [ "translate"; "z"; n ] when Parse.is_bracket_value n -> (
        let inner = Parse.bracket_inner n in
        match Parse.arbitrary_length inner with
        | Some length -> Ok (Translate_z_arbitrary (inner, `Length length))
        | None -> (
            match Parse.arbitrary_declaration_value inner with
            | Some value -> Ok (Translate_z_arbitrary (inner, `Raw value))
            | None -> err_not_utility))
    | [ "translate"; "z"; "px" ] -> Ok Translate_z_px
    | [ "translate"; "z"; n ] when parse_spacing_step n <> None ->
        Ok (Translate_z_step (Option.get (parse_spacing_step n)))
    | [ "translate"; "z"; n ] -> Parse.int_any n >|= fun n -> Translate_z n
    | [ "translate"; "full" ] -> Ok Translate_full
    | [ "translate"; "none" ] -> Ok Translate_none
    | [ "translate"; "px" ] -> Ok Translate_px
    | [ "translate"; "1/2" ] -> Ok Translate_1_2
    | [ "translate"; n ] when String.contains n '/' -> (
        match parse_fraction n with
        | Some (num, denom) -> Ok (Translate_fraction (num, denom))
        | None -> err_not_utility)
    | [ "translate"; "3d" ] -> Ok Translate_3d
    | [ "translate"; n ] when not (Parse.is_bracket_value n) ->
        Parse.int_any n >|= fun n -> Translate n
    | "translate" :: rest
      when match rest with
           | [] | [ "x"; _ ] | [ "y"; _ ] | [ "z"; _ ] | [ "full" ] | [ "1/2" ]
             ->
               false
           | [ n ] when String.contains n '/' -> false
           | _ -> true -> (
        let value = String.concat "-" rest in
        match parse_bracket_length value with
        | Ok len -> Ok (Translate_arbitrary (Parse.bracket_inner value, len))
        | Error _ when not (Parse.is_bracket_value value) -> err_not_utility
        | Error _ -> (
            let raw = Parse.bracket_inner value in
            match Parse.arbitrary_declaration_value raw with
            | Some v -> Ok (Translate_raw (raw, v))
            | None -> err_not_utility))
    (* Negative translate utilities: -translate-x-N, -translate-y-N,
       -translate-z-N Split by '-' gives [""; "translate"; axis; n] *)
    | [ ""; "translate"; value ] when neg_bracket value ->
        let inner = Parse.bracket_inner value in
        Ok (Neg_translate_arbitrary inner)
    | [ ""; "translate"; "full" ] -> Ok Neg_translate_full
    | [ ""; "translate"; "px" ] -> Ok Neg_translate_px
    | [ ""; "translate"; n ] when String.contains n '/' -> (
        match parse_fraction n with
        | Some (num, denom) -> Ok (Neg_translate_fraction (num, denom))
        | None -> err_not_utility)
    | [ ""; "translate"; n ] -> Parse.int_any n >|= fun n -> Neg_translate n
    | [ ""; "translate"; "x"; value ] when neg_bracket value ->
        let inner = Parse.bracket_inner value in
        Ok (Neg_translate_x_arbitrary inner)
    | [ ""; "translate"; "x"; "full" ] -> Ok Neg_translate_x_full
    | [ ""; "translate"; "x"; "px" ] -> Ok Neg_translate_x_px
    | [ ""; "translate"; "x"; n ] when String.contains n '/' -> (
        match parse_fraction n with
        | Some (num, denom) -> Ok (Neg_translate_x_fraction (num, denom))
        | None -> err_not_utility)
    | [ ""; "translate"; "x"; n ] when parse_spacing_step n <> None ->
        Ok (Translate_x_step (-.Option.get (parse_spacing_step n)))
    | [ ""; "translate"; "x"; n ] ->
        Parse.int_pos ~name:"translate-x" n >|= fun n -> Translate_x (-n)
    | [ ""; "translate"; "y"; value ] when neg_bracket value ->
        let inner = Parse.bracket_inner value in
        Ok (Neg_translate_y_arbitrary inner)
    | [ ""; "translate"; "y"; "full" ] -> Ok Neg_translate_y_full
    | [ ""; "translate"; "y"; "px" ] -> Ok Neg_translate_y_px
    | [ ""; "translate"; "y"; n ] when String.contains n '/' -> (
        match parse_fraction n with
        | Some (num, denom) -> Ok (Neg_translate_y_fraction (num, denom))
        | None -> err_not_utility)
    | [ ""; "translate"; "y"; n ] when parse_spacing_step n <> None ->
        Ok (Translate_y_step (-.Option.get (parse_spacing_step n)))
    | [ ""; "translate"; "y"; n ] ->
        Parse.int_pos ~name:"translate-y" n >|= fun n -> Translate_y (-n)
    | [ ""; "translate"; "z"; value ] when neg_bracket value ->
        let inner = Parse.bracket_inner value in
        Ok (Neg_translate_z_arbitrary inner)
    | [ ""; "translate"; "z"; "px" ] -> Ok Neg_translate_z_px
    | [ ""; "translate"; "z"; n ] when parse_spacing_step n <> None ->
        Ok (Translate_z_step (-.Option.get (parse_spacing_step n)))
    | [ ""; "translate"; "z"; n ] ->
        Parse.int_pos ~name:"translate-z" n >|= fun n -> Translate_z (-n)
    | [ "scale"; n ] when Parse.is_bracket_value n -> (
        let inner = Parse.bracket_inner n in
        (* Check for multi-value: x_y_z *)
        let parts =
          String.split_on_char '_' inner |> List.filter (fun s -> s <> "")
        in
        match parts with
        | [ x; y; z ] -> (
            match
              ( Float.of_string_opt x,
                Float.of_string_opt y,
                Float.of_string_opt z )
            with
            | Some fx, Some fy, Some fz -> Ok (Scale_raw_3 (inner, fx, fy, fz))
            | _ -> (
                match Parse.arbitrary_declaration_value inner with
                | Some value -> Ok (Scale_arbitrary_raw (inner, value))
                | None -> err_not_utility))
        | [ _ ] -> (
            match Float.of_string_opt inner with
            | Some f -> Ok (Scale_raw_1 (inner, f))
            | None -> (
                match Parse.arbitrary_declaration_value inner with
                | Some value -> Ok (Scale_arbitrary_raw (inner, value))
                | None -> err_not_utility))
        | _ -> (
            match Parse.arbitrary_declaration_value inner with
            | Some value -> Ok (Scale_arbitrary_raw (inner, value))
            | None -> err_not_utility))
    | [ "scale"; "3d" ] -> Ok Scale_3d
    | [ "scale"; "none" ] -> Ok Scale_none
    | [ "scale"; n ] -> Parse.int_pos ~name:"scale" n >|= fun n -> Scale n
    | [ "scale"; "x"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_number n with
        | Ok (raw, f) -> Ok (Scale_x_arbitrary (raw, f))
        | Error _ -> err_not_utility)
    | [ "scale"; "x"; n ] ->
        Parse.int_pos ~name:"scale-x" n >|= fun n -> Scale_x n
    | [ "scale"; "y"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_number n with
        | Ok (raw, f) -> Ok (Scale_y_arbitrary (raw, f))
        | Error _ -> err_not_utility)
    | [ "scale"; "y"; n ] ->
        Parse.int_pos ~name:"scale-y" n >|= fun n -> Scale_y n
    | [ "scale"; "z"; n ]
      when Parse.is_bracket_value n
           && Parse.is_declaration_value
                (Parse.decode_arbitrary_value (Parse.bracket_inner n)) ->
        Ok (Scale_z_arbitrary (Parse.bracket_inner n))
    | [ "scale"; "z"; n ] ->
        Parse.int_pos ~name:"scale-z" n >|= fun n -> Scale_z n
    | [ "skew"; "x"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_angle n with
        | Ok (raw, a) -> Ok (Skew_x_arbitrary (raw, `Angle a))
        | Error _ -> (
            let raw = Parse.bracket_inner n in
            match Parse.arbitrary_declaration_value raw with
            | Some value -> Ok (Skew_x_arbitrary (raw, `Raw value))
            | None -> err_not_utility))
    | [ "skew"; "x"; n ] -> Parse.int_any n >|= fun n -> Skew_x n
    | [ "skew"; "y"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_angle n with
        | Ok (raw, a) -> Ok (Skew_y_arbitrary (raw, `Angle a))
        | Error _ -> (
            let raw = Parse.bracket_inner n in
            match Parse.arbitrary_declaration_value raw with
            | Some value -> Ok (Skew_y_arbitrary (raw, `Raw value))
            | None -> err_not_utility))
    | [ "skew"; "y"; n ] -> Parse.int_any n >|= fun n -> Skew_y n
    | [ "skew"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_angle n with
        | Ok (raw, a) -> Ok (Skew_arbitrary (raw, `Angle a))
        | Error _ -> (
            let raw = Parse.bracket_inner n in
            match Parse.arbitrary_declaration_value raw with
            | Some value -> Ok (Skew_arbitrary (raw, `Raw value))
            | None -> err_not_utility))
    | [ "skew"; n ] -> Parse.int_any n >|= fun n -> Skew n
    | [ "rotate"; "x"; n ] when Parse.is_bare_var n ->
        Ok (Rotate_x_bare_var (Parse.bare_var_inner n))
    | [ "rotate"; "x"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_angle n with
        | Ok (raw, a) -> Ok (Rotate_x_arbitrary (raw, a))
        | Error _ -> (
            (* The channel is this family's longhand, so a bracket no angle
               reader took still reaches it. *)
            let raw = Parse.bracket_inner n in
            match Parse.arbitrary_declaration_value raw with
            | Some value -> Ok (Rotate_x_raw (raw, value))
            | None -> err_not_utility))
    | [ "rotate"; "x"; n ] -> Parse.int_any n >|= fun n -> Rotate_x n
    | [ "rotate"; "y"; n ] when Parse.is_bare_var n ->
        Ok (Rotate_y_bare_var (Parse.bare_var_inner n))
    | [ "rotate"; "y"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_angle n with
        | Ok (raw, a) -> Ok (Rotate_y_arbitrary (raw, a))
        | Error _ -> (
            (* The channel is this family's longhand, so a bracket no angle
               reader took still reaches it. *)
            let raw = Parse.bracket_inner n in
            match Parse.arbitrary_declaration_value raw with
            | Some value -> Ok (Rotate_y_raw (raw, value))
            | None -> err_not_utility))
    | [ "rotate"; "y"; n ] -> Parse.int_any n >|= fun n -> Rotate_y n
    | [ "rotate"; "z"; n ] when Parse.is_bare_var n ->
        Ok (Rotate_z_bare_var (Parse.bare_var_inner n))
    | [ "rotate"; "z"; n ] when Parse.is_bracket_value n -> (
        match parse_bracket_angle n with
        | Ok (raw, a) -> Ok (Rotate_z_arbitrary (raw, a))
        | Error _ -> (
            (* The channel is this family's longhand, so a bracket no angle
               reader took still reaches it. *)
            let raw = Parse.bracket_inner n in
            match Parse.arbitrary_declaration_value raw with
            | Some value -> Ok (Rotate_z_raw (raw, value))
            | None -> err_not_utility))
    | [ "rotate"; "z"; n ] -> Parse.int_any n >|= fun n -> Rotate_z n
    (* Negative rotate: -rotate-N, -rotate-(--var), -rotate-[123deg] *)
    | [ ""; "rotate"; n ] when Parse.is_bare_var n ->
        Ok (Neg_rotate_bare_var (Parse.bare_var_inner n))
    | [ ""; "rotate"; value ] when neg_bracket value ->
        Ok (Neg_rotate_arbitrary (Parse.bracket_inner value))
    | [ ""; "rotate"; n ] ->
        Parse.int_pos ~name:"rotate" n >|= fun n -> Rotate (-n)
    | [ ""; "rotate"; "x"; n ] when Parse.is_bare_var n ->
        Ok (Neg_rotate_x_bare_var (Parse.bare_var_inner n))
    | [ ""; "rotate"; "x"; value ] when neg_bracket value ->
        Ok (Neg_rotate_x_arbitrary (Parse.bracket_inner value))
    | [ ""; "rotate"; "x"; n ] ->
        Parse.int_pos ~name:"rotate-x" n >|= fun n -> Rotate_x (-n)
    | [ ""; "rotate"; "y"; n ] when Parse.is_bare_var n ->
        Ok (Neg_rotate_y_bare_var (Parse.bare_var_inner n))
    | [ ""; "rotate"; "y"; value ] when neg_bracket value ->
        Ok (Neg_rotate_y_arbitrary (Parse.bracket_inner value))
    | [ ""; "rotate"; "y"; n ] ->
        Parse.int_pos ~name:"rotate-y" n >|= fun n -> Rotate_y (-n)
    | [ ""; "rotate"; "z"; n ] when Parse.is_bare_var n ->
        Ok (Neg_rotate_z_bare_var (Parse.bare_var_inner n))
    | [ ""; "rotate"; "z"; value ] when neg_bracket value ->
        Ok (Neg_rotate_z_arbitrary (Parse.bracket_inner value))
    | [ ""; "rotate"; "z"; n ] ->
        Parse.int_pos ~name:"rotate-z" n >|= fun n -> Rotate_z (-n)
    (* Negative scale: -scale-N, -scale-[1.5] *)
    | [ ""; "scale"; value ] when neg_bracket value ->
        Ok (Neg_scale_arbitrary (Parse.bracket_inner value))
    | [ ""; "scale"; n ] ->
        Parse.int_pos ~name:"scale" n >|= fun n -> Scale (-n)
    | [ ""; "scale"; "x"; value ] when neg_bracket value ->
        Ok (Neg_scale_x_arbitrary (Parse.bracket_inner value))
    | [ ""; "scale"; "x"; n ] ->
        Parse.int_pos ~name:"scale-x" n >|= fun n -> Scale_x (-n)
    | [ ""; "scale"; "y"; value ] when neg_bracket value ->
        Ok (Neg_scale_y_arbitrary (Parse.bracket_inner value))
    | [ ""; "scale"; "y"; n ] ->
        Parse.int_pos ~name:"scale-y" n >|= fun n -> Scale_y (-n)
    | [ ""; "scale"; "z"; value ] when neg_bracket value ->
        Ok (Neg_scale_z_arbitrary (Parse.bracket_inner value))
    | [ ""; "scale"; "z"; n ] ->
        Parse.int_pos ~name:"scale-z" n >|= fun n -> Scale_z (-n)
    (* Negative skew: -skew-N, -skew-x-N, -skew-y-N, -skew-x-[10deg] *)
    | [ ""; "skew"; "x"; value ] when neg_bracket value ->
        Ok (Neg_skew_x_arbitrary (Parse.bracket_inner value))
    | [ ""; "skew"; "x"; n ] ->
        Parse.int_pos ~name:"skew-x" n >|= fun n -> Skew_x (-n)
    | [ ""; "skew"; "y"; value ] when neg_bracket value ->
        Ok (Neg_skew_y_arbitrary (Parse.bracket_inner value))
    | [ ""; "skew"; "y"; n ] ->
        Parse.int_pos ~name:"skew-y" n >|= fun n -> Skew_y (-n)
    | [ ""; "skew"; value ] when neg_bracket value ->
        Ok (Neg_skew_arbitrary (Parse.bracket_inner value))
    | [ ""; "skew"; n ] -> Parse.int_pos ~name:"skew" n >|= fun n -> Skew (-n)
    | [ "perspective"; "none" ] -> Ok Perspective_none
    | [ "perspective"; "dramatic" ] -> Ok Perspective_dramatic
    | [ "perspective"; "near" ] -> Ok Perspective_near
    | [ "perspective"; "normal" ] -> Ok Perspective_normal
    | [ "perspective"; "midrange" ] -> Ok Perspective_midrange
    | [ "perspective"; "distant" ] -> Ok Perspective_distant
    | "perspective" :: rest
      when (match rest with "origin" :: _ | [] -> false | _ -> true)
           && is_theme_perspective theme (String.concat "-" rest) ->
        Ok (Perspective_theme (String.concat "-" rest))
    | "perspective" :: rest
      when match rest with "origin" :: _ | [] -> false | _ -> true -> (
        let value = String.concat "-" rest in
        match parse_bracket_length value with
        | Ok len -> Ok (Perspective_arbitrary (Parse.bracket_inner value, len))
        | Error _ when not (Parse.is_bracket_value value) -> err_not_utility
        | Error _ -> (
            let inner = Parse.bracket_inner value in
            match Parse.arbitrary_declaration_value inner with
            | Some v -> Ok (Perspective_raw (inner, v))
            | None -> err_not_utility))
    | [ "perspective"; "origin"; "center" ] -> Ok Perspective_origin_center
    | [ "perspective"; "origin"; "top" ] -> Ok Perspective_origin_top
    | [ "perspective"; "origin"; "bottom" ] -> Ok Perspective_origin_bottom
    | [ "perspective"; "origin"; "left" ] -> Ok Perspective_origin_left
    | [ "perspective"; "origin"; "right" ] -> Ok Perspective_origin_right
    | [ "perspective"; "origin"; "top"; "left" ] ->
        Ok Perspective_origin_top_left
    | [ "perspective"; "origin"; "top"; "right" ] ->
        Ok Perspective_origin_top_right
    | [ "perspective"; "origin"; "bottom"; "left" ] ->
        Ok Perspective_origin_bottom_left
    | [ "perspective"; "origin"; "bottom"; "right" ] ->
        Ok Perspective_origin_bottom_right
    | "perspective" :: "origin" :: rest when rest <> [] ->
        let value = String.concat "-" rest in
        if Parse.is_bracket_value value then
          let inner = Parse.bracket_inner value in
          match
            arbitrary_value Css.Properties.read_perspective_origin inner
          with
          | Some po -> Ok (Perspective_origin_arbitrary (inner, po))
          | None -> (
              match Parse.arbitrary_declaration_value inner with
              | Some value -> Ok (Perspective_origin_raw (inner, value))
              | None ->
                  Error
                    (`Msg
                       ("perspective-origin-[" ^ inner
                      ^ "]: not a valid perspective-origin")))
        else err_not_utility
    | [ "transform"; "style"; "3d" ] -> Ok Transform_style_3d
    | [ "transform"; "style"; "flat" ] -> Ok Transform_style_flat
    | [ "transform"; "3d" ] -> Ok Transform_style_3d
    | [ "transform"; "flat" ] -> Ok Transform_style_flat
    | [ "backface"; "hidden" ] -> Ok Backface_hidden
    | [ "backface"; "visible" ] -> Ok Backface_visible
    | [ "transform"; "border" ] -> Ok Transform_box_border
    | [ "transform"; "content" ] -> Ok Transform_box_content
    | [ "transform"; "fill" ] -> Ok Transform_box_fill
    | [ "transform"; "stroke" ] -> Ok Transform_box_stroke
    | [ "transform"; "view" ] -> Ok Transform_box_view
    | [ "transform"; value ] when Parse.is_bracket_value value -> (
        let inner = Parse.bracket_inner value in
        match arbitrary_value Css.Properties.read_transforms inner with
        | Some ts -> Ok (Transform_arbitrary (inner, ts))
        | None -> (
            match Parse.arbitrary_declaration_value inner with
            | Some value -> Ok (Transform_raw (inner, value))
            | None ->
                Error
                  (`Msg ("transform-[" ^ inner ^ "]: not a valid transform list"))
            ))
    | [ "transform" ] -> Ok Transform
    | [ "transform"; "cpu" ] -> Ok Transform_cpu
    | [ "transform"; "none" ] -> Ok Transform_none
    | [ "transform"; "gpu" ] -> Ok Transform_gpu
    | [ "origin"; "center" ] -> Ok Origin_center
    | [ "origin"; "top" ] -> Ok Origin_top
    | [ "origin"; "bottom" ] -> Ok Origin_bottom
    | [ "origin"; "left" ] -> Ok Origin_left
    | [ "origin"; "right" ] -> Ok Origin_right
    | [ "origin"; "top"; "left" ] -> Ok Origin_top_left
    | [ "origin"; "top"; "right" ] -> Ok Origin_top_right
    | [ "origin"; "bottom"; "left" ] -> Ok Origin_bottom_left
    | [ "origin"; "bottom"; "right" ] -> Ok Origin_bottom_right
    | "origin" :: rest when rest <> [] ->
        let value = String.concat "-" rest in
        if Parse.is_bracket_value value then
          let inner = Parse.bracket_inner value in
          match arbitrary_value Css.Properties.read_transform_origin inner with
          | Some t -> Ok (Origin_arbitrary (inner, t))
          | None -> (
              match Parse.arbitrary_declaration_value inner with
              | Some value -> Ok (Origin_raw (inner, value))
              | None ->
                  Error
                    (`Msg
                       ("origin-[" ^ inner ^ "]: not a valid transform-origin"))
              )
        else err_not_utility
    | _ -> err_not_utility

  (* [translate-x-0.5], and [-translate-x-0.5] for the negative step. Tailwind
     writes the fraction as the author did, so keep the trailing digits. *)
  let step_class prefix f =
    (if f < 0. then "-" else "") ^ prefix ^ "-" ^ pp_float (Float.abs f)

  let to_class = function
    | Rotate n -> neg_class "rotate-" n
    | Rotate_arbitrary (raw, _) -> "rotate-" ^ "[" ^ raw ^ "]"
    | Rotate_raw (raw, _) -> "rotate-[" ^ raw ^ "]"
    | Rotate_none -> "rotate-none"
    | Rotate_3d_arbitrary (raw, _, _, _, _) -> "rotate-[" ^ raw ^ "]"
    | Rotate_bare_var name -> "rotate-(" ^ name ^ ")"
    | Neg_rotate_bare_var name -> "-rotate-(" ^ name ^ ")"
    | Neg_rotate_arbitrary s -> "-rotate-[" ^ s ^ "]"
    | Translate_x n -> neg_class "translate-x-" n
    | Translate_x_full -> "translate-x-full"
    | Translate_x_px -> "translate-x-px"
    | Translate_x_step f -> step_class "translate-x" f
    | Translate_x_arbitrary (raw, _) | Translate_x_raw (raw, _) ->
        "translate-x-[" ^ raw ^ "]"
    | Translate_y_raw (raw, _) -> "translate-y-[" ^ raw ^ "]"
    | Translate_raw (raw, _) -> "translate-[" ^ raw ^ "]"
    | Translate_x_fraction (num, denom) ->
        "translate-x-" ^ string_of_int num ^ "/" ^ string_of_int denom
    | Translate_y n -> neg_class "translate-y-" n
    | Translate_y_full -> "translate-y-full"
    | Translate_y_px -> "translate-y-px"
    | Translate_y_step f -> step_class "translate-y" f
    | Translate_y_arbitrary (raw, _) -> "translate-y-[" ^ raw ^ "]"
    | Translate_y_fraction (num, denom) ->
        "translate-y-" ^ string_of_int num ^ "/" ^ string_of_int denom
    | Translate_z n -> neg_class "translate-z-" n
    | Translate_z_step f -> step_class "translate-z" f
    | Translate_z_px -> "translate-z-px"
    | Translate_z_arbitrary (raw, _) -> "translate-z-[" ^ raw ^ "]"
    | Neg_translate_z_arbitrary s -> "-translate-z-[" ^ s ^ "]"
    | Neg_translate_z_px -> "-translate-z-px"
    | Translate_3d -> "translate-3d"
    | Translate n -> "translate-" ^ string_of_int n
    | Neg_translate n -> "-translate-" ^ string_of_int n
    | Translate_full -> "translate-full"
    | Translate_none -> "translate-none"
    | Translate_px -> "translate-px"
    | Translate_1_2 -> "translate-1/2"
    | Translate_fraction (num, denom) ->
        "translate-" ^ string_of_int num ^ "/" ^ string_of_int denom
    | Translate_arbitrary (raw, _) -> "translate-" ^ "[" ^ raw ^ "]"
    | Neg_translate_arbitrary s -> "-translate-[" ^ s ^ "]"
    | Neg_translate_full -> "-translate-full"
    | Neg_translate_px -> "-translate-px"
    | Neg_translate_x_px -> "-translate-x-px"
    | Neg_translate_y_px -> "-translate-y-px"
    | Neg_translate_fraction (num, denom) ->
        "-translate-" ^ string_of_int num ^ "/" ^ string_of_int denom
    | Neg_translate_x_arbitrary s -> "-translate-x-[" ^ s ^ "]"
    | Neg_translate_x_full -> "-translate-x-full"
    | Neg_translate_x_1_2 -> "-translate-x-1/2"
    | Neg_translate_x_fraction (num, denom) ->
        "-translate-x-" ^ string_of_int num ^ "/" ^ string_of_int denom
    | Neg_translate_y_arbitrary s -> "-translate-y-[" ^ s ^ "]"
    | Neg_translate_y_full -> "-translate-y-full"
    | Neg_translate_y_1_2 -> "-translate-y-1/2"
    | Neg_translate_y_fraction (num, denom) ->
        "-translate-y-" ^ string_of_int num ^ "/" ^ string_of_int denom
    | Scale n -> neg_class "scale-" n
    | Scale_x n -> neg_class "scale-x-" n
    | Scale_x_arbitrary (raw, _) -> "scale-x-[" ^ raw ^ "]"
    | Scale_y n -> neg_class "scale-y-" n
    | Scale_y_arbitrary (raw, _) -> "scale-y-[" ^ raw ^ "]"
    | Scale_raw_1 (raw, _) -> "scale-[" ^ raw ^ "]"
    | Scale_raw_3 (raw, _, _, _) -> "scale-[" ^ raw ^ "]"
    | Scale_arbitrary_raw (raw, _) -> "scale-[" ^ raw ^ "]"
    | Scale_z n -> neg_class "scale-z-" n
    | Scale_z_arbitrary s -> "scale-z-[" ^ s ^ "]"
    | Neg_scale_arbitrary s -> "-scale-[" ^ s ^ "]"
    | Neg_scale_x_arbitrary s -> "-scale-x-[" ^ s ^ "]"
    | Neg_scale_y_arbitrary s -> "-scale-y-[" ^ s ^ "]"
    | Neg_scale_z_arbitrary s -> "-scale-z-[" ^ s ^ "]"
    | Scale_3d -> "scale-3d"
    | Scale_none -> "scale-none"
    | Skew_x n -> neg_class "skew-x-" n
    | Skew_x_arbitrary (raw, _) -> "skew-x-" ^ "[" ^ raw ^ "]"
    | Skew_y n -> neg_class "skew-y-" n
    | Skew_y_arbitrary (raw, _) -> "skew-y-" ^ "[" ^ raw ^ "]"
    | Skew n -> neg_class "skew-" n
    | Skew_arbitrary (raw, _) -> "skew-" ^ "[" ^ raw ^ "]"
    | Neg_skew_arbitrary s -> "-skew-[" ^ s ^ "]"
    | Neg_skew_x_arbitrary s -> "-skew-x-[" ^ s ^ "]"
    | Neg_skew_y_arbitrary s -> "-skew-y-[" ^ s ^ "]"
    | Rotate_x n -> neg_class "rotate-x-" n
    | Rotate_x_arbitrary (raw, _) | Rotate_x_raw (raw, _) ->
        "rotate-x-[" ^ raw ^ "]"
    | Rotate_y_raw (raw, _) -> "rotate-y-[" ^ raw ^ "]"
    | Rotate_z_raw (raw, _) -> "rotate-z-[" ^ raw ^ "]"
    | Rotate_x_bare_var name -> "rotate-x-(" ^ name ^ ")"
    | Neg_rotate_x_bare_var name -> "-rotate-x-(" ^ name ^ ")"
    | Neg_rotate_x_arbitrary s -> "-rotate-x-[" ^ s ^ "]"
    | Rotate_y n -> neg_class "rotate-y-" n
    | Rotate_y_arbitrary (raw, _) -> "rotate-y-" ^ "[" ^ raw ^ "]"
    | Rotate_y_bare_var name -> "rotate-y-(" ^ name ^ ")"
    | Neg_rotate_y_bare_var name -> "-rotate-y-(" ^ name ^ ")"
    | Neg_rotate_y_arbitrary s -> "-rotate-y-[" ^ s ^ "]"
    | Rotate_z n -> neg_class "rotate-z-" n
    | Rotate_z_arbitrary (raw, _) -> "rotate-z-" ^ "[" ^ raw ^ "]"
    | Rotate_z_bare_var name -> "rotate-z-(" ^ name ^ ")"
    | Neg_rotate_z_bare_var name -> "-rotate-z-(" ^ name ^ ")"
    | Neg_rotate_z_arbitrary s -> "-rotate-z-[" ^ s ^ "]"
    | Perspective_none -> "perspective-none"
    | Perspective_dramatic -> "perspective-dramatic"
    | Perspective_theme name -> "perspective-" ^ name
    | Perspective_near -> "perspective-near"
    | Perspective_normal -> "perspective-normal"
    | Perspective_midrange -> "perspective-midrange"
    | Perspective_distant -> "perspective-distant"
    | Perspective_arbitrary (raw, _) | Perspective_raw (raw, _) ->
        "perspective-[" ^ raw ^ "]"
    | Perspective_origin_center -> "perspective-origin-center"
    | Perspective_origin_top -> "perspective-origin-top"
    | Perspective_origin_bottom -> "perspective-origin-bottom"
    | Perspective_origin_left -> "perspective-origin-left"
    | Perspective_origin_right -> "perspective-origin-right"
    | Perspective_origin_top_left -> "perspective-origin-top-left"
    | Perspective_origin_top_right -> "perspective-origin-top-right"
    | Perspective_origin_bottom_left -> "perspective-origin-bottom-left"
    | Perspective_origin_bottom_right -> "perspective-origin-bottom-right"
    | Perspective_origin_arbitrary (s, _) | Perspective_origin_raw (s, _) ->
        "perspective-origin-[" ^ s ^ "]"
    | Transform_style_3d -> "transform-3d"
    | Transform_style_flat -> "transform-flat"
    | Transform_box_border -> "transform-border"
    | Transform_box_content -> "transform-content"
    | Transform_box_fill -> "transform-fill"
    | Transform_box_stroke -> "transform-stroke"
    | Transform_box_view -> "transform-view"
    | Backface_visible -> "backface-visible"
    | Backface_hidden -> "backface-hidden"
    | Transform -> "transform"
    | Transform_cpu -> "transform-cpu"
    | Transform_none -> "transform-none"
    | Transform_gpu -> "transform-gpu"
    | Transform_arbitrary (s, _) | Transform_raw (s, _) ->
        "transform-[" ^ s ^ "]"
    | Origin_center -> "origin-center"
    | Origin_top -> "origin-top"
    | Origin_bottom -> "origin-bottom"
    | Origin_left -> "origin-left"
    | Origin_right -> "origin-right"
    | Origin_top_left -> "origin-top-left"
    | Origin_top_right -> "origin-top-right"
    | Origin_bottom_left -> "origin-bottom-left"
    | Origin_bottom_right -> "origin-bottom-right"
    | Origin_arbitrary (s, _) | Origin_raw (s, _) -> "origin-[" ^ s ^ "]"

  let examples =
    [
      Origin_top;
      Perspective_none;
      Perspective_origin_top;
      Backface_hidden;
      Transform_none;
      Transform_style_flat;
      Rotate 45;
      Scale 50;
      Translate_x 2;
    ]
end

open Handler

module Utility_factory = Utility.Make (Handler)
(** Register the transform utility handlers *)

(** Public API returning Utility.t *)
let utility = Utility_factory.v

let rotate n = utility (Rotate n)
let translate_x n = utility (Translate_x n)

(* A whole-number float keeps the int constructor's own 0/1 shortcuts
   (calc(var(--spacing)) rather than calc(var(--spacing) * 1)); only a genuine
   fractional value needs the step form. *)
let translate_x' f =
  if Float.is_integer f then translate_x (int_of_float f)
  else utility (Translate_x_step f)

let translate_x_fraction num denom = utility (Translate_x_fraction (num, denom))
let translate_y n = utility (Translate_y n)

let translate_y' f =
  if Float.is_integer f then translate_y (int_of_float f)
  else utility (Translate_y_step f)

let translate_y_fraction num denom = utility (Translate_y_fraction (num, denom))
let scale n = utility (Scale n)
let scale_x n = utility (Scale_x n)
let scale_y n = utility (Scale_y n)
let skew_x n = utility (Skew_x n)
let skew_y n = utility (Skew_y n)
let translate_z n = utility (Translate_z n)

let translate_z' f =
  if Float.is_integer f then translate_z (int_of_float f)
  else utility (Translate_z_step f)

let rotate_x n = utility (Rotate_x n)
let rotate_y n = utility (Rotate_y n)
let rotate_z n = utility (Rotate_z n)
let scale_z n = utility (Scale_z n)
let perspective_none = utility Perspective_none
let perspective_dramatic = utility Perspective_dramatic
let perspective_near = utility Perspective_near
let perspective_normal = utility Perspective_normal
let perspective_midrange = utility Perspective_midrange
let perspective_distant = utility Perspective_distant
let neg_translate_x_1_2 = utility Neg_translate_x_1_2
let neg_translate_y_1_2 = utility Neg_translate_y_1_2
let perspective_origin_center = utility Perspective_origin_center
let perspective_origin_top = utility Perspective_origin_top
let perspective_origin_bottom = utility Perspective_origin_bottom
let perspective_origin_left = utility Perspective_origin_left
let perspective_origin_right = utility Perspective_origin_right
let transform_style_3d = utility Transform_style_3d
let transform_style_flat = utility Transform_style_flat
let transform_box_border = utility Transform_box_border
let transform_box_content = utility Transform_box_content
let transform_box_fill = utility Transform_box_fill
let transform_box_stroke = utility Transform_box_stroke
let transform_box_view = utility Transform_box_view
let backface_visible = utility Backface_visible
let backface_hidden = utility Backface_hidden
let transform = utility Transform
let transform_none = utility Transform_none
let transform_gpu = utility Transform_gpu
let origin_center = utility Origin_center
let origin_top = utility Origin_top
let origin_bottom = utility Origin_bottom
let origin_left = utility Origin_left
let origin_right = utility Origin_right
let origin_top_left = utility Origin_top_left
let origin_top_right = utility Origin_top_right
let origin_bottom_left = utility Origin_bottom_left
let origin_bottom_right = utility Origin_bottom_right