Trait dioxus_html::GlobalAttributes

source · [−]
pub trait GlobalAttributes {

Show 470 methods    fn prevent_default<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn accesskey<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn class<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn contenteditable<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn data<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dir<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn draggable<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hidden<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn id<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn lang<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn spellcheck<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn tabindex<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn title<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn translate<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn role<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn dangerous_inner_html<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn align_content<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn align_items<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn align_self<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn alignment_adjust<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn alignment_baseline<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn all<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn alt<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn animation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_delay<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_direction<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_duration<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_fill_mode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_iteration_count<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_name<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_play_state<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn animation_timing_function<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn azimuth<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn backface_visibility<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_attachment<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_clip<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_image<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_origin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_repeat<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_size<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn background_blend_mode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn baseline_shift<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bleed<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bookmark_label<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bookmark_level<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bookmark_state<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_left<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_left_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_left_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_left_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_right<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_right_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_right_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_right_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_collapse<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_outset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_repeat<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_slice<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_source<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_image_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_radius<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_left_radius<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_bottom_right_radius<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_left_radius<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_top_right_radius<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn border_spacing<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn bottom<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn box_decoration_break<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn box_shadow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn box_sizing<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn box_snap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn break_after<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn break_before<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn break_inside<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn buffered_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn caption_side<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn clear<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn clear_side<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn clip<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn clip_path<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn clip_rule<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_adjust<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_correction<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_interpolation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_interpolation_filters<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_profile<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn color_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_fill<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_gap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_rule<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_rule_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_rule_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_rule_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_span<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn columns<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_count<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn column_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn contain<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn content<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn counter_increment<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn counter_reset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn counter_set<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn cue<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn cue_after<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn cue_before<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn cursor<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn direction<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display_inside<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display_outside<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display_extras<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn display_box<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn dominant_baseline<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn elevation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn empty_cells<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn enable_background<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn fill<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn fill_opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn fill_rule<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn filter<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn float<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn float_defer_column<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn float_defer_page<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn float_offset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn float_wrap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flow_into<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flow_from<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flex<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn flex_basis<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flex_grow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flex_shrink<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flex_flow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flex_direction<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flex_wrap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flood_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn flood_opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn font_family<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_size<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_stretch<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_weight<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_feature_settings<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_kerning<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_language_override<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_size_adjust<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_synthesis<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_alternates<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_caps<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_east_asian<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_ligatures<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_numeric<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn font_variant_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn footnote_policy<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn glyph_orientation_horizontal<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn glyph_orientation_vertical<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn grid_auto_flow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_auto_columns<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_auto_rows<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_template<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_template_areas<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_template_columns<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_template_rows<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_area<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_column<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_column_start<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_column_end<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_row<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_row_start<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn grid_row_end<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hanging_punctuation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_character<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_limit_chars<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_limit_last<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_limit_lines<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphenate_limit_zone<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn hyphens<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn icon<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn image_orientation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn image_resolution<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn image_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ime<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn ime_align<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ime_mode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ime_offset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ime_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn initial_letters<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn inline_box_align<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn isolation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn justify_content<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn justify_items<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn justify_self<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn kerning<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn left<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn letter_spacing<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn lighting_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_box_contain<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_break<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_grid<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_slack<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn line_snap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn list_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn list_style_image<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn list_style_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn list_style_type<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin_bottom<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin_left<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin_right<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn margin_top<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_end<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_mid<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_pattern<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_segment<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_start<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_knockout_left<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_knockout_right<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marker_side<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marks<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marquee_direction<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marquee_play_count<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marquee_speed<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn marquee_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn mask_image<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_repeat<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_clip<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_origin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_size<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_outset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_repeat<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_slice<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_source<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_box_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mask_type<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn max_height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn max_lines<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn max_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn min_height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn min_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn mix_blend_mode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn nav_down<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn nav_index<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn nav_left<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn nav_right<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn nav_up<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn object_fit<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn object_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn offset_after<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn offset_before<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn offset_end<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn offset_start<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn order<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn orphans<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn outline<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn outline_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn outline_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn outline_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn outline_offset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overflow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overflow_x<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overflow_y<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overflow_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn overflow_wrap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding_bottom<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding_left<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding_right<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn padding_top<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn page<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn page_break_after<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn page_break_before<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn page_break_inside<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn paint_order<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pause<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pause_after<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pause_before<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn perspective<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn perspective_origin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pitch<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pitch_range<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn play_during<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn pointer_events<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn quotes<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn region_fragment<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn resize<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn rest<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn rest_after<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn rest_before<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn richness<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn right<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ruby_align<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ruby_merge<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn ruby_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_behavior<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_coordinate<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_destination<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_points_x<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_points_y<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn scroll_snap_type<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_image_threshold<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_inside<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_margin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_outside<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_padding<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn shape_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn size<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn speak<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speak_as<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speak_header<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speak_numeral<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speak_punctuation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn speech_rate<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stop_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stop_opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stress<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn string_set<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_dasharray<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_dashoffset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_linecap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_linejoin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_miterlimit<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_opacity<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn stroke_width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn tab_size<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn table_layout<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_align<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_align_all<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_align_last<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_anchor<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_combine_upright<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration_line<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_decoration_skip<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis_color<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_emphasis_skip<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_height<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_indent<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_justify<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_orientation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_overflow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_rendering<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_shadow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_size_adjust<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_space_collapse<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_spacing<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_transform<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_underline_position<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn text_wrap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn top<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn touch_action<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transform<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transform_box<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transform_origin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transform_style<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transition<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transition_delay<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transition_duration<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transition_property<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn unicode_bidi<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vector_effect<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn vertical_align<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn visibility<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_balance<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_duration<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_family<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_pitch<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_range<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_rate<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_stress<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn voice_volumn<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn volume<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn white_space<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn widows<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn width<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn will_change<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn word_break<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn word_spacing<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn word_wrap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn wrap_flow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn wrap_through<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn writing_mode<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn gap<'a>(&self, cx: NodeFactory<'a>, val: Arguments<'_>) -> Attribute<'a> { ... }
    fn list_styler_type<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn row_gap<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn transition_timing_function<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn user_select<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn webkit_user_select<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn z_index<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_current<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_details<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_disabled<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_hidden<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_invalid<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_keyshortcuts<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_label<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_roledescription<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_autocomplete<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_checked<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_expanded<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_haspopup<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_level<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_modal<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_multiline<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_multiselectable<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_orientation<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_placeholder<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_pressed<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_readonly<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_required<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_selected<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_sort<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_valuemax<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_valuemin<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_valuenow<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_valuetext<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_atomic<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_busy<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_live<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_relevant<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_dropeffect<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_grabbed<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_activedescendant<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_colcount<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_colindex<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_colspan<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_controls<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_describedby<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_errormessage<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_flowto<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_labelledby<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_owns<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_posinset<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_rowcount<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_rowindex<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_rowspan<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }
    fn aria_setsize<'a>(
        &self, 
        cx: NodeFactory<'a>, 
        val: Arguments<'_>
    ) -> Attribute<'a> { ... }

}

Provided Methods

Prevent the default action for this element.

For more information, see the MDN docs: https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault

The HTML class attribute is used to specify a class for an HTML element.

Details

Multiple HTML elements can share the same class.

The class global attribute is a space-separated list of the case-sensitive classes of the element. Classes allow CSS and Javascript to select and access specific elements via the class selectors or functions like the DOM method document.getElementsByClassName.

Example
HTML:
<p class="note editorial">Above point sounds a bit obvious. Remove/rewrite?</p>
CSS:
.note {
    font-style: italic;
    font-weight: bold;
}

.editorial {
    background: rgb(255, 0, 0, .25);
    padding: 10px;
}

dangerous_inner_html is Dioxus’s replacement for using innerHTML in the browser DOM. In general, setting HTML from code is risky because it’s easy to inadvertently expose your users to a cross-site scripting (XSS) attack. So, you can set HTML directly from Dioxus, but you have to type out dangerous_inner_html to remind yourself that it’s dangerous

source

fn align_content<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn float_defer_page<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

source

fn justify_content<'a>(
    &self,
    cx: NodeFactory<'a>,
    val: Arguments<'_>
) -> Attribute<'a>

Implementors