Struct patternfly_dioxus::dioxus_elements::script

pub struct script;

Build a <script> element.

The script HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code. The script element can also be used with other languages, such as WebGL’s GLSL shader programming language and JSON.

Implementations

impl script

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

Normal script elements pass minimal information to the window.onerror for scripts which do not pass the standard CORS checks. To allow error logging for sites which use a separate domain for static media, use this attribute. See CORS settings attributes for a more descriptive explanation of its valid arguments.

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

This Boolean attribute is set to indicate to a browser that the script is meant to be executed after the document has been parsed, but before firing DOMContentLoaded.

Scripts with the defer attribute will prevent the DOMContentLoaded event from firing until the script has loaded and finished evaluating.

---

Warning:

This attribute must not be used if the src attribute is absent (i.e. for inline scripts), in this case it would have no effect.

---

The defer attribute has no effect on module scripts — they defer by default. Scripts with the defer attribute will execute in the order in which they appear in the document.

This attribute allows the elimination of parser-blocking JavaScript where the browser would have to load and evaluate scripts before continuing to parse. async has a similar effect in this case.

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

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

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

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

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

impl script

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

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

Trait Implementations

impl DioxusElement for script

const TAG_NAME: &'static str = "script"

The tag name of the element.

const NAME_SPACE: Option<&'static str> = None

The namespace of the element.

fn tag_name(&self) -> &'static str

The tag name of the element.

fn namespace(&self) -> Option<&'static str>

The namespace of the element.

impl GlobalAttributes for script

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

Prevent the default action for this element.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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