use alloc::string::String;
use super::elements;
use crate::value;
use crate::Tag;
pub trait Accept: elements::HtmlElement {
fn attr() -> &'static str {
"accept"
}
}
impl<T> Tag<T>
where
T: Accept + 'static,
{
pub fn accept(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Accept,
{
pub fn get_accept(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_accept(&self) {
self.rem_attr(T::attr())
}
}
impl Accept for elements::Form {}
impl Accept for elements::Input {}
pub trait AcceptCharset: elements::HtmlElement {
fn attr() -> &'static str {
"accept-charset"
}
}
impl<T> Tag<T>
where
T: AcceptCharset + 'static,
{
pub fn accept_charset(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: AcceptCharset,
{
pub fn get_accept_charset(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_accept_charset(&self) {
self.rem_attr(T::attr())
}
}
impl AcceptCharset for elements::Form {}
pub trait Accesskey: elements::HtmlElement {
fn attr() -> &'static str {
"accesskey"
}
}
impl<T> Tag<T>
where
T: Accesskey + 'static,
{
pub fn accesskey(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Accesskey,
{
pub fn get_accesskey(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_accesskey(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Accesskey for T where T: elements::HtmlElement {}
pub trait Action: elements::HtmlElement {
fn attr() -> &'static str {
"action"
}
}
impl<T> Tag<T>
where
T: Action + 'static,
{
pub fn action(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Action,
{
pub fn get_action(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_action(&self) {
self.rem_attr(T::attr())
}
}
impl Action for elements::Form {}
pub trait Align: elements::HtmlElement {
fn attr() -> &'static str {
"align"
}
}
impl<T> Tag<T>
where
T: Align + 'static,
{
pub fn align(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Align,
{
pub fn get_align(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_align(&self) {
self.rem_attr(T::attr())
}
}
impl Align for elements::Caption {}
impl Align for elements::Col {}
impl Align for elements::Colgroup {}
impl Align for elements::Hr {}
impl Align for elements::Iframe {}
impl Align for elements::Img {}
impl Align for elements::Table {}
impl Align for elements::Tbody {}
impl Align for elements::Td {}
impl Align for elements::Tfoot {}
impl Align for elements::Th {}
impl Align for elements::Thead {}
impl Align for elements::Tr {}
pub trait Allow: elements::HtmlElement {
fn attr() -> &'static str {
"allow"
}
}
impl<T> Tag<T>
where
T: Allow + 'static,
{
pub fn allow(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Allow,
{
pub fn get_allow(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_allow(&self) {
self.rem_attr(T::attr())
}
}
impl Allow for elements::Iframe {}
pub trait Alt: elements::HtmlElement {
fn attr() -> &'static str {
"alt"
}
}
impl<T> Tag<T>
where
T: Alt + 'static,
{
pub fn alt(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Alt,
{
pub fn get_alt(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_alt(&self) {
self.rem_attr(T::attr())
}
}
impl Alt for elements::Area {}
impl Alt for elements::Img {}
impl Alt for elements::Input {}
pub trait Async: elements::HtmlElement {
fn attr() -> &'static str {
"async"
}
}
impl<T> Tag<T>
where
T: Async + 'static,
{
pub fn set_async(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Async,
{
pub fn get_set_async(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_set_async(&self) {
self.rem_attr(T::attr())
}
}
impl Async for elements::Script {}
pub trait Autocapitalize: elements::HtmlElement {
fn attr() -> &'static str {
"autocapitalize"
}
}
impl<T> Tag<T>
where
T: Autocapitalize + 'static,
{
pub fn autocapitalize(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Autocapitalize,
{
pub fn get_autocapitalize(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_autocapitalize(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Autocapitalize for T where T: elements::HtmlElement {}
pub trait Autocomplete: elements::HtmlElement {
fn attr() -> &'static str {
"autocomplete"
}
}
impl<T> Tag<T>
where
T: Autocomplete + 'static,
{
pub fn autocomplete(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Autocomplete,
{
pub fn get_autocomplete(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_autocomplete(&self) {
self.rem_attr(T::attr())
}
}
impl Autocomplete for elements::Form {}
impl Autocomplete for elements::Input {}
impl Autocomplete for elements::Select {}
impl Autocomplete for elements::Textarea {}
pub trait Autofocus: elements::HtmlElement {
fn attr() -> &'static str {
"autofocus"
}
}
impl<T> Tag<T>
where
T: Autofocus + 'static,
{
pub fn autofocus(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Autofocus,
{
pub fn get_autofocus(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_autofocus(&self) {
self.rem_attr(T::attr())
}
}
impl Autofocus for elements::Button {}
impl Autofocus for elements::Input {}
impl Autofocus for elements::Select {}
impl Autofocus for elements::Textarea {}
pub trait Autoplay: elements::HtmlElement {
fn attr() -> &'static str {
"autoplay"
}
}
impl<T> Tag<T>
where
T: Autoplay + 'static,
{
pub fn autoplay(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Autoplay,
{
pub fn get_autoplay(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_autoplay(&self) {
self.rem_attr(T::attr())
}
}
impl Autoplay for elements::Audio {}
impl Autoplay for elements::Video {}
pub trait Background: elements::HtmlElement {
fn attr() -> &'static str {
"background"
}
}
impl<T> Tag<T>
where
T: Background + 'static,
{
pub fn background(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Background,
{
pub fn get_background(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_background(&self) {
self.rem_attr(T::attr())
}
}
impl Background for elements::Body {}
impl Background for elements::Table {}
impl Background for elements::Td {}
impl Background for elements::Th {}
pub trait Bgcolor: elements::HtmlElement {
fn attr() -> &'static str {
"bgcolor"
}
}
impl<T> Tag<T>
where
T: Bgcolor + 'static,
{
pub fn bgcolor(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Bgcolor,
{
pub fn get_bgcolor(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_bgcolor(&self) {
self.rem_attr(T::attr())
}
}
impl Bgcolor for elements::Body {}
impl Bgcolor for elements::Col {}
impl Bgcolor for elements::Colgroup {}
impl Bgcolor for elements::Table {}
impl Bgcolor for elements::Tbody {}
impl Bgcolor for elements::Tfoot {}
impl Bgcolor for elements::Td {}
impl Bgcolor for elements::Th {}
impl Bgcolor for elements::Tr {}
pub trait Border: elements::HtmlElement {
fn attr() -> &'static str {
"border"
}
}
impl<T> Tag<T>
where
T: Border + 'static,
{
pub fn border(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Border,
{
pub fn get_border(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_border(&self) {
self.rem_attr(T::attr())
}
}
impl Border for elements::Img {}
impl Border for elements::Object {}
impl Border for elements::Table {}
pub trait Buffered: elements::HtmlElement {
fn attr() -> &'static str {
"buffered"
}
}
impl<T> Tag<T>
where
T: Buffered + 'static,
{
pub fn buffered(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Buffered,
{
pub fn get_buffered(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_buffered(&self) {
self.rem_attr(T::attr())
}
}
impl Buffered for elements::Audio {}
impl Buffered for elements::Video {}
pub trait Capture: elements::HtmlElement {
fn attr() -> &'static str {
"capture"
}
}
impl<T> Tag<T>
where
T: Capture + 'static,
{
pub fn capture(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Capture,
{
pub fn get_capture(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_capture(&self) {
self.rem_attr(T::attr())
}
}
impl Capture for elements::Input {}
pub trait Charset: elements::HtmlElement {
fn attr() -> &'static str {
"charset"
}
}
impl<T> Tag<T>
where
T: Charset + 'static,
{
pub fn charset(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Charset,
{
pub fn get_charset(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_charset(&self) {
self.rem_attr(T::attr())
}
}
impl Charset for elements::Meta {}
impl Charset for elements::Script {}
pub trait Checked: elements::HtmlElement {
fn attr() -> &'static str {
"checked"
}
}
impl<T> Tag<T>
where
T: Checked + 'static,
{
pub fn checked(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Checked,
{
pub fn get_checked(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_checked(&self) {
self.rem_attr(T::attr())
}
}
impl Checked for elements::Input {}
pub trait Cite: elements::HtmlElement {
fn attr() -> &'static str {
"cite"
}
}
impl<T> Tag<T>
where
T: Cite + 'static,
{
pub fn cite(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Cite,
{
pub fn get_cite(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_cite(&self) {
self.rem_attr(T::attr())
}
}
impl Cite for elements::Blockquote {}
impl Cite for elements::Del {}
impl Cite for elements::Ins {}
impl Cite for elements::Q {}
pub trait Class: elements::HtmlElement {
fn attr() -> &'static str {
"class"
}
}
impl<T> Class for T where T: elements::HtmlElement {}
pub trait Color: elements::HtmlElement {
fn attr() -> &'static str {
"color"
}
}
impl<T> Tag<T>
where
T: Color + 'static,
{
pub fn color(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Color,
{
pub fn get_color(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_color(&self) {
self.rem_attr(T::attr())
}
}
impl Color for elements::Hr {}
pub trait Cols: elements::HtmlElement {
fn attr() -> &'static str {
"cols"
}
}
impl<T> Tag<T>
where
T: Cols + 'static,
{
pub fn cols(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Cols,
{
pub fn get_cols(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_cols(&self) {
self.rem_attr(T::attr())
}
}
impl Cols for elements::Textarea {}
pub trait Colspan: elements::HtmlElement {
fn attr() -> &'static str {
"colspan"
}
}
impl<T> Tag<T>
where
T: Colspan + 'static,
{
pub fn colspan(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Colspan,
{
pub fn get_colspan(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_colspan(&self) {
self.rem_attr(T::attr())
}
}
impl Colspan for elements::Td {}
impl Colspan for elements::Th {}
pub trait Content: elements::HtmlElement {
fn attr() -> &'static str {
"content"
}
}
impl<T> Tag<T>
where
T: Content + 'static,
{
pub fn content(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Content,
{
pub fn get_content(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_content(&self) {
self.rem_attr(T::attr())
}
}
impl Content for elements::Meta {}
pub trait Contenteditable: elements::HtmlElement {
fn attr() -> &'static str {
"contenteditable"
}
}
impl<T> Tag<T>
where
T: Contenteditable + 'static,
{
pub fn contenteditable(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Contenteditable,
{
pub fn get_contenteditable(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_contenteditable(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Contenteditable for T where T: elements::HtmlElement {}
pub trait Contextmenu: elements::HtmlElement {
fn attr() -> &'static str {
"contextmenu"
}
}
impl<T> Tag<T>
where
T: Contextmenu + 'static,
{
pub fn contextmenu(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Contextmenu,
{
pub fn get_contextmenu(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_contextmenu(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Contextmenu for T where T: elements::HtmlElement {}
pub trait Controls: elements::HtmlElement {
fn attr() -> &'static str {
"controls"
}
}
impl<T> Tag<T>
where
T: Controls + 'static,
{
pub fn controls(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Controls,
{
pub fn get_controls(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_controls(&self) {
self.rem_attr(T::attr())
}
}
impl Controls for elements::Audio {}
impl Controls for elements::Video {}
pub trait Coords: elements::HtmlElement {
fn attr() -> &'static str {
"coords"
}
}
impl<T> Tag<T>
where
T: Coords + 'static,
{
pub fn coords(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Coords,
{
pub fn get_coords(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_coords(&self) {
self.rem_attr(T::attr())
}
}
impl Coords for elements::Area {}
pub trait Crossorigin: elements::HtmlElement {
fn attr() -> &'static str {
"crossorigin"
}
}
impl<T> Tag<T>
where
T: Crossorigin + 'static,
{
pub fn crossorigin(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Crossorigin,
{
pub fn get_crossorigin(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_crossorigin(&self) {
self.rem_attr(T::attr())
}
}
impl Crossorigin for elements::Audio {}
impl Crossorigin for elements::Img {}
impl Crossorigin for elements::Link {}
impl Crossorigin for elements::Script {}
impl Crossorigin for elements::Video {}
pub trait Csp: elements::HtmlElement {
fn attr() -> &'static str {
"csp"
}
}
impl<T> Tag<T>
where
T: Csp + 'static,
{
pub fn csp(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Csp,
{
pub fn get_csp(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_csp(&self) {
self.rem_attr(T::attr())
}
}
impl Csp for elements::Iframe {}
pub trait Data: elements::HtmlElement {
fn attr() -> &'static str {
"data"
}
}
impl<T> Tag<T>
where
T: Data + 'static,
{
pub fn data(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Data,
{
pub fn get_data(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_data(&self) {
self.rem_attr(T::attr())
}
}
impl Data for elements::Object {}
pub trait Datetime: elements::HtmlElement {
fn attr() -> &'static str {
"datetime"
}
}
impl<T> Tag<T>
where
T: Datetime + 'static,
{
pub fn datetime(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Datetime,
{
pub fn get_datetime(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_datetime(&self) {
self.rem_attr(T::attr())
}
}
impl Datetime for elements::Del {}
impl Datetime for elements::Ins {}
impl Datetime for elements::Time {}
pub trait Decoding: elements::HtmlElement {
fn attr() -> &'static str {
"decoding"
}
}
impl<T> Tag<T>
where
T: Decoding + 'static,
{
pub fn decoding(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Decoding,
{
pub fn get_decoding(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_decoding(&self) {
self.rem_attr(T::attr())
}
}
impl Decoding for elements::Img {}
pub trait Default: elements::HtmlElement {
fn attr() -> &'static str {
"default"
}
}
impl<T> Tag<T>
where
T: Default + 'static,
{
pub fn default(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Default,
{
pub fn get_default(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_default(&self) {
self.rem_attr(T::attr())
}
}
impl Default for elements::Track {}
pub trait Defer: elements::HtmlElement {
fn attr() -> &'static str {
"defer"
}
}
impl<T> Tag<T>
where
T: Defer + 'static,
{
pub fn defer(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Defer,
{
pub fn get_defer(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_defer(&self) {
self.rem_attr(T::attr())
}
}
impl Defer for elements::Script {}
pub trait Dir: elements::HtmlElement {
fn attr() -> &'static str {
"dir"
}
}
impl<T> Tag<T>
where
T: Dir + 'static,
{
pub fn dir(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Dir,
{
pub fn get_dir(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_dir(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Dir for T where T: elements::HtmlElement {}
pub trait Dirname: elements::HtmlElement {
fn attr() -> &'static str {
"dirname"
}
}
impl<T> Tag<T>
where
T: Dirname + 'static,
{
pub fn dirname(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Dirname,
{
pub fn get_dirname(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_dirname(&self) {
self.rem_attr(T::attr())
}
}
impl Dirname for elements::Input {}
impl Dirname for elements::Textarea {}
pub trait Disabled: elements::HtmlElement {
fn attr() -> &'static str {
"disabled"
}
}
impl<T> Tag<T>
where
T: Disabled + 'static,
{
pub fn disabled(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Disabled,
{
pub fn get_disabled(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_disabled(&self) {
self.rem_attr(T::attr())
}
}
impl Disabled for elements::Button {}
impl Disabled for elements::Fieldset {}
impl Disabled for elements::Input {}
impl Disabled for elements::Optgroup {}
impl Disabled for elements::Option {}
impl Disabled for elements::Select {}
impl Disabled for elements::Textarea {}
pub trait Download: elements::HtmlElement {
fn attr() -> &'static str {
"download"
}
}
impl<T> Tag<T>
where
T: Download + 'static,
{
pub fn download(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Download,
{
pub fn get_download(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_download(&self) {
self.rem_attr(T::attr())
}
}
impl Download for elements::A {}
impl Download for elements::Area {}
pub trait Draggable: elements::HtmlElement {
fn attr() -> &'static str {
"draggable"
}
}
impl<T> Tag<T>
where
T: Draggable + 'static,
{
pub fn draggable(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Draggable,
{
pub fn get_draggable(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_draggable(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Draggable for T where T: elements::HtmlElement {}
pub trait Dropzone: elements::HtmlElement {
fn attr() -> &'static str {
"dropzone"
}
}
impl<T> Tag<T>
where
T: Dropzone + 'static,
{
pub fn dropzone(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Dropzone,
{
pub fn get_dropzone(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_dropzone(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Dropzone for T where T: elements::HtmlElement {}
pub trait Enctype: elements::HtmlElement {
fn attr() -> &'static str {
"enctype"
}
}
impl<T> Tag<T>
where
T: Enctype + 'static,
{
pub fn enctype(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Enctype,
{
pub fn get_enctype(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_enctype(&self) {
self.rem_attr(T::attr())
}
}
impl Enctype for elements::Form {}
pub trait Enterkeyhint: elements::HtmlElement {
fn attr() -> &'static str {
"enterkeyhint"
}
}
impl<T> Tag<T>
where
T: Enterkeyhint + 'static,
{
pub fn enterkeyhint(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Enterkeyhint,
{
pub fn get_enterkeyhint(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_enterkeyhint(&self) {
self.rem_attr(T::attr())
}
}
impl Enterkeyhint for elements::Textarea {}
pub trait For: elements::HtmlElement {
fn attr() -> &'static str {
"for"
}
}
impl<T> Tag<T>
where
T: For + 'static,
{
pub fn set_for(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: For,
{
pub fn get_set_for(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_set_for(&self) {
self.rem_attr(T::attr())
}
}
impl For for elements::Label {}
impl For for elements::Output {}
pub trait Form: elements::HtmlElement {
fn attr() -> &'static str {
"form"
}
}
impl<T> Tag<T>
where
T: Form + 'static,
{
pub fn form(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Form,
{
pub fn get_form(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_form(&self) {
self.rem_attr(T::attr())
}
}
impl Form for elements::Button {}
impl Form for elements::Fieldset {}
impl Form for elements::Input {}
impl Form for elements::Label {}
impl Form for elements::Meter {}
impl Form for elements::Object {}
impl Form for elements::Output {}
impl Form for elements::Progress {}
impl Form for elements::Select {}
impl Form for elements::Textarea {}
pub trait Formaction: elements::HtmlElement {
fn attr() -> &'static str {
"formaction"
}
}
impl<T> Tag<T>
where
T: Formaction + 'static,
{
pub fn formaction(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Formaction,
{
pub fn get_formaction(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_formaction(&self) {
self.rem_attr(T::attr())
}
}
impl Formaction for elements::Input {}
impl Formaction for elements::Button {}
pub trait Formenctype: elements::HtmlElement {
fn attr() -> &'static str {
"formenctype"
}
}
impl<T> Tag<T>
where
T: Formenctype + 'static,
{
pub fn formenctype(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Formenctype,
{
pub fn get_formenctype(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_formenctype(&self) {
self.rem_attr(T::attr())
}
}
impl Formenctype for elements::Button {}
impl Formenctype for elements::Input {}
pub trait Formmethod: elements::HtmlElement {
fn attr() -> &'static str {
"formmethod"
}
}
impl<T> Tag<T>
where
T: Formmethod + 'static,
{
pub fn formmethod(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Formmethod,
{
pub fn get_formmethod(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_formmethod(&self) {
self.rem_attr(T::attr())
}
}
impl Formmethod for elements::Button {}
impl Formmethod for elements::Input {}
pub trait Formnovalidate: elements::HtmlElement {
fn attr() -> &'static str {
"formnovalidate"
}
}
impl<T> Tag<T>
where
T: Formnovalidate + 'static,
{
pub fn formnovalidate(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Formnovalidate,
{
pub fn get_formnovalidate(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_formnovalidate(&self) {
self.rem_attr(T::attr())
}
}
impl Formnovalidate for elements::Button {}
impl Formnovalidate for elements::Input {}
pub trait Formtarget: elements::HtmlElement {
fn attr() -> &'static str {
"formtarget"
}
}
impl<T> Tag<T>
where
T: Formtarget + 'static,
{
pub fn formtarget(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Formtarget,
{
pub fn get_formtarget(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_formtarget(&self) {
self.rem_attr(T::attr())
}
}
impl Formtarget for elements::Button {}
impl Formtarget for elements::Input {}
pub trait Headers: elements::HtmlElement {
fn attr() -> &'static str {
"headers"
}
}
impl<T> Tag<T>
where
T: Headers + 'static,
{
pub fn headers(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Headers,
{
pub fn get_headers(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_headers(&self) {
self.rem_attr(T::attr())
}
}
impl Headers for elements::Td {}
impl Headers for elements::Th {}
pub trait Height: elements::HtmlElement {
fn attr() -> &'static str {
"height"
}
}
impl<T> Tag<T>
where
T: Height + 'static,
{
pub fn height(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Height,
{
pub fn get_height(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_height(&self) {
self.rem_attr(T::attr())
}
}
impl Height for elements::Canvas {}
impl Height for elements::Embed {}
impl Height for elements::Iframe {}
impl Height for elements::Img {}
impl Height for elements::Input {}
impl Height for elements::Object {}
impl Height for elements::Video {}
pub trait Hidden: elements::HtmlElement {
fn attr() -> &'static str {
"hidden"
}
}
impl<T> Tag<T>
where
T: Hidden + 'static,
{
pub fn hidden(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Hidden,
{
pub fn get_hidden(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_hidden(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Hidden for T where T: elements::HtmlElement {}
pub trait High: elements::HtmlElement {
fn attr() -> &'static str {
"high"
}
}
impl<T> Tag<T>
where
T: High + 'static,
{
pub fn high(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: High,
{
pub fn get_high(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_high(&self) {
self.rem_attr(T::attr())
}
}
impl High for elements::Meter {}
pub trait Href: elements::HtmlElement {
fn attr() -> &'static str {
"href"
}
}
impl<T> Tag<T>
where
T: Href + 'static,
{
pub fn href(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Href,
{
pub fn get_href(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_href(&self) {
self.rem_attr(T::attr())
}
}
impl Href for elements::A {}
impl Href for elements::Area {}
impl Href for elements::Base {}
impl Href for elements::Link {}
pub trait Hreflang: elements::HtmlElement {
fn attr() -> &'static str {
"hreflang"
}
}
impl<T> Tag<T>
where
T: Hreflang + 'static,
{
pub fn hreflang(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Hreflang,
{
pub fn get_hreflang(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_hreflang(&self) {
self.rem_attr(T::attr())
}
}
impl Hreflang for elements::A {}
impl Hreflang for elements::Area {}
impl Hreflang for elements::Link {}
pub trait HttpEquiv: elements::HtmlElement {
fn attr() -> &'static str {
"http-equiv"
}
}
impl<T> Tag<T>
where
T: HttpEquiv + 'static,
{
pub fn http_equiv(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: HttpEquiv,
{
pub fn get_http_equiv(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_http_equiv(&self) {
self.rem_attr(T::attr())
}
}
impl HttpEquiv for elements::Meta {}
pub trait Id: elements::HtmlElement {
fn attr() -> &'static str {
"id"
}
}
impl<T> Id for T where T: elements::HtmlElement {}
pub trait Importance: elements::HtmlElement {
fn attr() -> &'static str {
"importance"
}
}
impl<T> Tag<T>
where
T: Importance + 'static,
{
pub fn importance(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Importance,
{
pub fn get_importance(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_importance(&self) {
self.rem_attr(T::attr())
}
}
impl Importance for elements::Iframe {}
impl Importance for elements::Img {}
impl Importance for elements::Link {}
impl Importance for elements::Script {}
pub trait Integrity: elements::HtmlElement {
fn attr() -> &'static str {
"integrity"
}
}
impl<T> Tag<T>
where
T: Integrity + 'static,
{
pub fn integrity(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Integrity,
{
pub fn get_integrity(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_integrity(&self) {
self.rem_attr(T::attr())
}
}
impl Integrity for elements::Link {}
impl Integrity for elements::Script {}
pub trait Intrinsicsize: elements::HtmlElement {
fn attr() -> &'static str {
"intrinsicsize"
}
}
impl<T> Tag<T>
where
T: Intrinsicsize + 'static,
{
pub fn intrinsicsize(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Intrinsicsize,
{
pub fn get_intrinsicsize(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_intrinsicsize(&self) {
self.rem_attr(T::attr())
}
}
impl Intrinsicsize for elements::Img {}
pub trait Inputmode: elements::HtmlElement {
fn attr() -> &'static str {
"inputmode"
}
}
impl<T> Tag<T>
where
T: Inputmode + 'static,
{
pub fn inputmode(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Inputmode,
{
pub fn get_inputmode(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_inputmode(&self) {
self.rem_attr(T::attr())
}
}
impl Inputmode for elements::Textarea {}
pub trait Ismap: elements::HtmlElement {
fn attr() -> &'static str {
"ismap"
}
}
impl<T> Tag<T>
where
T: Ismap + 'static,
{
pub fn ismap(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Ismap,
{
pub fn get_ismap(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_ismap(&self) {
self.rem_attr(T::attr())
}
}
impl Ismap for elements::Img {}
pub trait Itemprop: elements::HtmlElement {
fn attr() -> &'static str {
"itemprop"
}
}
impl<T> Tag<T>
where
T: Itemprop + 'static,
{
pub fn itemprop(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Itemprop,
{
pub fn get_itemprop(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_itemprop(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Itemprop for T where T: elements::HtmlElement {}
pub trait Kind: elements::HtmlElement {
fn attr() -> &'static str {
"kind"
}
}
impl<T> Tag<T>
where
T: Kind + 'static,
{
pub fn kind(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Kind,
{
pub fn get_kind(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_kind(&self) {
self.rem_attr(T::attr())
}
}
impl Kind for elements::Track {}
pub trait Label: elements::HtmlElement {
fn attr() -> &'static str {
"label"
}
}
impl<T> Tag<T>
where
T: Label + 'static,
{
pub fn label(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Label,
{
pub fn get_label(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_label(&self) {
self.rem_attr(T::attr())
}
}
impl Label for elements::Optgroup {}
impl Label for elements::Option {}
impl Label for elements::Track {}
pub trait Lang: elements::HtmlElement {
fn attr() -> &'static str {
"lang"
}
}
impl<T> Tag<T>
where
T: Lang + 'static,
{
pub fn lang(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Lang,
{
pub fn get_lang(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_lang(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Lang for T where T: elements::HtmlElement {}
pub trait Language: elements::HtmlElement {
fn attr() -> &'static str {
"language"
}
}
impl<T> Tag<T>
where
T: Language + 'static,
{
pub fn language(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Language,
{
pub fn get_language(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_language(&self) {
self.rem_attr(T::attr())
}
}
impl Language for elements::Script {}
pub trait Loading: elements::HtmlElement {
fn attr() -> &'static str {
"loading"
}
}
impl<T> Tag<T>
where
T: Loading + 'static,
{
pub fn loading(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Loading,
{
pub fn get_loading(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_loading(&self) {
self.rem_attr(T::attr())
}
}
impl Loading for elements::Img {}
impl Loading for elements::Iframe {}
pub trait List: elements::HtmlElement {
fn attr() -> &'static str {
"list"
}
}
impl<T> Tag<T>
where
T: List + 'static,
{
pub fn list(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: List,
{
pub fn get_list(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_list(&self) {
self.rem_attr(T::attr())
}
}
impl List for elements::Input {}
pub trait Loop: elements::HtmlElement {
fn attr() -> &'static str {
"loop"
}
}
impl<T> Tag<T>
where
T: Loop + 'static,
{
pub fn set_loop(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Loop,
{
pub fn get_set_loop(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_set_loop(&self) {
self.rem_attr(T::attr())
}
}
impl Loop for elements::Audio {}
impl Loop for elements::Video {}
pub trait Low: elements::HtmlElement {
fn attr() -> &'static str {
"low"
}
}
impl<T> Tag<T>
where
T: Low + 'static,
{
pub fn low(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Low,
{
pub fn get_low(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_low(&self) {
self.rem_attr(T::attr())
}
}
impl Low for elements::Meter {}
pub trait Manifest: elements::HtmlElement {
fn attr() -> &'static str {
"manifest"
}
}
impl<T> Tag<T>
where
T: Manifest + 'static,
{
pub fn manifest(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Manifest,
{
pub fn get_manifest(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_manifest(&self) {
self.rem_attr(T::attr())
}
}
impl Manifest for elements::Html {}
pub trait Max: elements::HtmlElement {
fn attr() -> &'static str {
"max"
}
}
impl<T> Tag<T>
where
T: Max + 'static,
{
pub fn max(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Max,
{
pub fn get_max(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_max(&self) {
self.rem_attr(T::attr())
}
}
impl Max for elements::Input {}
impl Max for elements::Meter {}
impl Max for elements::Progress {}
pub trait Maxlength: elements::HtmlElement {
fn attr() -> &'static str {
"maxlength"
}
}
impl<T> Tag<T>
where
T: Maxlength + 'static,
{
pub fn maxlength(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Maxlength,
{
pub fn get_maxlength(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_maxlength(&self) {
self.rem_attr(T::attr())
}
}
impl Maxlength for elements::Input {}
impl Maxlength for elements::Textarea {}
pub trait Minlength: elements::HtmlElement {
fn attr() -> &'static str {
"minlength"
}
}
impl<T> Tag<T>
where
T: Minlength + 'static,
{
pub fn minlength(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Minlength,
{
pub fn get_minlength(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_minlength(&self) {
self.rem_attr(T::attr())
}
}
impl Minlength for elements::Input {}
impl Minlength for elements::Textarea {}
pub trait Media: elements::HtmlElement {
fn attr() -> &'static str {
"media"
}
}
impl<T> Tag<T>
where
T: Media + 'static,
{
pub fn media(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Media,
{
pub fn get_media(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_media(&self) {
self.rem_attr(T::attr())
}
}
impl Media for elements::A {}
impl Media for elements::Area {}
impl Media for elements::Link {}
impl Media for elements::Source {}
impl Media for elements::Style {}
pub trait Method: elements::HtmlElement {
fn attr() -> &'static str {
"method"
}
}
impl<T> Tag<T>
where
T: Method + 'static,
{
pub fn method(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Method,
{
pub fn get_method(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_method(&self) {
self.rem_attr(T::attr())
}
}
impl Method for elements::Form {}
pub trait Min: elements::HtmlElement {
fn attr() -> &'static str {
"min"
}
}
impl<T> Tag<T>
where
T: Min + 'static,
{
pub fn min(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Min,
{
pub fn get_min(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_min(&self) {
self.rem_attr(T::attr())
}
}
impl Min for elements::Input {}
impl Min for elements::Meter {}
pub trait Multiple: elements::HtmlElement {
fn attr() -> &'static str {
"multiple"
}
}
impl<T> Tag<T>
where
T: Multiple + 'static,
{
pub fn multiple(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Multiple,
{
pub fn get_multiple(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_multiple(&self) {
self.rem_attr(T::attr())
}
}
impl Multiple for elements::Input {}
impl Multiple for elements::Select {}
pub trait Muted: elements::HtmlElement {
fn attr() -> &'static str {
"muted"
}
}
impl<T> Tag<T>
where
T: Muted + 'static,
{
pub fn muted(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Muted,
{
pub fn get_muted(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_muted(&self) {
self.rem_attr(T::attr())
}
}
impl Muted for elements::Audio {}
impl Muted for elements::Video {}
pub trait Name: elements::HtmlElement {
fn attr() -> &'static str {
"name"
}
}
impl<T> Tag<T>
where
T: Name + 'static,
{
pub fn name(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Name,
{
pub fn get_name(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_name(&self) {
self.rem_attr(T::attr())
}
}
impl Name for elements::Button {}
impl Name for elements::Form {}
impl Name for elements::Fieldset {}
impl Name for elements::Iframe {}
impl Name for elements::Input {}
impl Name for elements::Object {}
impl Name for elements::Output {}
impl Name for elements::Select {}
impl Name for elements::Textarea {}
impl Name for elements::Map {}
impl Name for elements::Meta {}
impl Name for elements::Param {}
pub trait Novalidate: elements::HtmlElement {
fn attr() -> &'static str {
"novalidate"
}
}
impl<T> Tag<T>
where
T: Novalidate + 'static,
{
pub fn novalidate(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Novalidate,
{
pub fn get_novalidate(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_novalidate(&self) {
self.rem_attr(T::attr())
}
}
impl Novalidate for elements::Form {}
pub trait Open: elements::HtmlElement {
fn attr() -> &'static str {
"open"
}
}
impl<T> Tag<T>
where
T: Open + 'static,
{
pub fn open(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Open,
{
pub fn get_open(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_open(&self) {
self.rem_attr(T::attr())
}
}
impl Open for elements::Details {}
pub trait Optimum: elements::HtmlElement {
fn attr() -> &'static str {
"optimum"
}
}
impl<T> Tag<T>
where
T: Optimum + 'static,
{
pub fn optimum(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Optimum,
{
pub fn get_optimum(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_optimum(&self) {
self.rem_attr(T::attr())
}
}
impl Optimum for elements::Meter {}
pub trait Pattern: elements::HtmlElement {
fn attr() -> &'static str {
"pattern"
}
}
impl<T> Tag<T>
where
T: Pattern + 'static,
{
pub fn pattern(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Pattern,
{
pub fn get_pattern(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_pattern(&self) {
self.rem_attr(T::attr())
}
}
impl Pattern for elements::Input {}
pub trait Ping: elements::HtmlElement {
fn attr() -> &'static str {
"ping"
}
}
impl<T> Tag<T>
where
T: Ping + 'static,
{
pub fn ping(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Ping,
{
pub fn get_ping(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_ping(&self) {
self.rem_attr(T::attr())
}
}
impl Ping for elements::A {}
impl Ping for elements::Area {}
pub trait Placeholder: elements::HtmlElement {
fn attr() -> &'static str {
"placeholder"
}
}
impl<T> Tag<T>
where
T: Placeholder + 'static,
{
pub fn placeholder(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Placeholder,
{
pub fn get_placeholder(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_placeholder(&self) {
self.rem_attr(T::attr())
}
}
impl Placeholder for elements::Input {}
impl Placeholder for elements::Textarea {}
pub trait Poster: elements::HtmlElement {
fn attr() -> &'static str {
"poster"
}
}
impl<T> Tag<T>
where
T: Poster + 'static,
{
pub fn poster(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Poster,
{
pub fn get_poster(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_poster(&self) {
self.rem_attr(T::attr())
}
}
impl Poster for elements::Video {}
pub trait Preload: elements::HtmlElement {
fn attr() -> &'static str {
"preload"
}
}
impl<T> Tag<T>
where
T: Preload + 'static,
{
pub fn preload(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Preload,
{
pub fn get_preload(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_preload(&self) {
self.rem_attr(T::attr())
}
}
impl Preload for elements::Audio {}
impl Preload for elements::Video {}
pub trait Readonly: elements::HtmlElement {
fn attr() -> &'static str {
"readonly"
}
}
impl<T> Tag<T>
where
T: Readonly + 'static,
{
pub fn readonly(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Readonly,
{
pub fn get_readonly(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_readonly(&self) {
self.rem_attr(T::attr())
}
}
impl Readonly for elements::Input {}
impl Readonly for elements::Textarea {}
pub trait Referrerpolicy: elements::HtmlElement {
fn attr() -> &'static str {
"referrerpolicy"
}
}
impl<T> Tag<T>
where
T: Referrerpolicy + 'static,
{
pub fn referrerpolicy(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Referrerpolicy,
{
pub fn get_referrerpolicy(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_referrerpolicy(&self) {
self.rem_attr(T::attr())
}
}
impl Referrerpolicy for elements::A {}
impl Referrerpolicy for elements::Area {}
impl Referrerpolicy for elements::Iframe {}
impl Referrerpolicy for elements::Img {}
impl Referrerpolicy for elements::Link {}
impl Referrerpolicy for elements::Script {}
pub trait Rel: elements::HtmlElement {
fn attr() -> &'static str {
"rel"
}
}
impl<T> Tag<T>
where
T: Rel + 'static,
{
pub fn rel(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Rel,
{
pub fn get_rel(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_rel(&self) {
self.rem_attr(T::attr())
}
}
impl Rel for elements::A {}
impl Rel for elements::Area {}
impl Rel for elements::Link {}
pub trait Required: elements::HtmlElement {
fn attr() -> &'static str {
"required"
}
}
impl<T> Tag<T>
where
T: Required + 'static,
{
pub fn required(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Required,
{
pub fn get_required(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_required(&self) {
self.rem_attr(T::attr())
}
}
impl Required for elements::Input {}
impl Required for elements::Select {}
impl Required for elements::Textarea {}
pub trait Reversed: elements::HtmlElement {
fn attr() -> &'static str {
"reversed"
}
}
impl<T> Tag<T>
where
T: Reversed + 'static,
{
pub fn reversed(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Reversed,
{
pub fn get_reversed(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_reversed(&self) {
self.rem_attr(T::attr())
}
}
impl Reversed for elements::Ol {}
pub trait Rows: elements::HtmlElement {
fn attr() -> &'static str {
"rows"
}
}
impl<T> Tag<T>
where
T: Rows + 'static,
{
pub fn rows(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Rows,
{
pub fn get_rows(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_rows(&self) {
self.rem_attr(T::attr())
}
}
impl Rows for elements::Textarea {}
pub trait Rowspan: elements::HtmlElement {
fn attr() -> &'static str {
"rowspan"
}
}
impl<T> Tag<T>
where
T: Rowspan + 'static,
{
pub fn rowspan(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Rowspan,
{
pub fn get_rowspan(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_rowspan(&self) {
self.rem_attr(T::attr())
}
}
impl Rowspan for elements::Td {}
impl Rowspan for elements::Th {}
pub trait Sandbox: elements::HtmlElement {
fn attr() -> &'static str {
"sandbox"
}
}
impl<T> Tag<T>
where
T: Sandbox + 'static,
{
pub fn sandbox(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Sandbox,
{
pub fn get_sandbox(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_sandbox(&self) {
self.rem_attr(T::attr())
}
}
impl Sandbox for elements::Iframe {}
pub trait Scope: elements::HtmlElement {
fn attr() -> &'static str {
"scope"
}
}
impl<T> Tag<T>
where
T: Scope + 'static,
{
pub fn scope(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Scope,
{
pub fn get_scope(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_scope(&self) {
self.rem_attr(T::attr())
}
}
impl Scope for elements::Th {}
pub trait Scoped: elements::HtmlElement {
fn attr() -> &'static str {
"scoped"
}
}
impl<T> Tag<T>
where
T: Scoped + 'static,
{
pub fn scoped(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Scoped,
{
pub fn get_scoped(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_scoped(&self) {
self.rem_attr(T::attr())
}
}
impl Scoped for elements::Style {}
pub trait Selected: elements::HtmlElement {
fn attr() -> &'static str {
"selected"
}
}
impl<T> Tag<T>
where
T: Selected + 'static,
{
pub fn selected(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Selected,
{
pub fn get_selected(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_selected(&self) {
self.rem_attr(T::attr())
}
}
impl Selected for elements::Option {}
pub trait Shape: elements::HtmlElement {
fn attr() -> &'static str {
"shape"
}
}
impl<T> Tag<T>
where
T: Shape + 'static,
{
pub fn shape(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Shape,
{
pub fn get_shape(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_shape(&self) {
self.rem_attr(T::attr())
}
}
impl Shape for elements::A {}
impl Shape for elements::Area {}
pub trait Size: elements::HtmlElement {
fn attr() -> &'static str {
"size"
}
}
impl<T> Tag<T>
where
T: Size + 'static,
{
pub fn size(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Size,
{
pub fn get_size(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_size(&self) {
self.rem_attr(T::attr())
}
}
impl Size for elements::Input {}
impl Size for elements::Select {}
pub trait Sizes: elements::HtmlElement {
fn attr() -> &'static str {
"sizes"
}
}
impl<T> Tag<T>
where
T: Sizes + 'static,
{
pub fn sizes(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Sizes,
{
pub fn get_sizes(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_sizes(&self) {
self.rem_attr(T::attr())
}
}
impl Sizes for elements::Link {}
impl Sizes for elements::Img {}
impl Sizes for elements::Source {}
pub trait Slot: elements::HtmlElement {
fn attr() -> &'static str {
"slot"
}
}
impl<T> Tag<T>
where
T: Slot + 'static,
{
pub fn slot(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Slot,
{
pub fn get_slot(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_slot(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Slot for T where T: elements::HtmlElement {}
pub trait Span: elements::HtmlElement {
fn attr() -> &'static str {
"span"
}
}
impl<T> Tag<T>
where
T: Span + 'static,
{
pub fn span(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Span,
{
pub fn get_span(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_span(&self) {
self.rem_attr(T::attr())
}
}
impl Span for elements::Col {}
impl Span for elements::Colgroup {}
pub trait Spellcheck: elements::HtmlElement {
fn attr() -> &'static str {
"spellcheck"
}
}
impl<T> Tag<T>
where
T: Spellcheck + 'static,
{
pub fn spellcheck(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Spellcheck,
{
pub fn get_spellcheck(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_spellcheck(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Spellcheck for T where T: elements::HtmlElement {}
pub trait Src: elements::HtmlElement {
fn attr() -> &'static str {
"src"
}
}
impl<T> Tag<T>
where
T: Src + 'static,
{
pub fn src(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Src,
{
pub fn get_src(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_src(&self) {
self.rem_attr(T::attr())
}
}
impl Src for elements::Audio {}
impl Src for elements::Embed {}
impl Src for elements::Iframe {}
impl Src for elements::Img {}
impl Src for elements::Input {}
impl Src for elements::Script {}
impl Src for elements::Source {}
impl Src for elements::Track {}
impl Src for elements::Video {}
pub trait Srcdoc: elements::HtmlElement {
fn attr() -> &'static str {
"srcdoc"
}
}
impl<T> Tag<T>
where
T: Srcdoc + 'static,
{
pub fn srcdoc(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Srcdoc,
{
pub fn get_srcdoc(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_srcdoc(&self) {
self.rem_attr(T::attr())
}
}
impl Srcdoc for elements::Iframe {}
pub trait Srclang: elements::HtmlElement {
fn attr() -> &'static str {
"srclang"
}
}
impl<T> Tag<T>
where
T: Srclang + 'static,
{
pub fn srclang(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Srclang,
{
pub fn get_srclang(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_srclang(&self) {
self.rem_attr(T::attr())
}
}
impl Srclang for elements::Track {}
pub trait Srcset: elements::HtmlElement {
fn attr() -> &'static str {
"srcset"
}
}
impl<T> Tag<T>
where
T: Srcset + 'static,
{
pub fn srcset(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Srcset,
{
pub fn get_srcset(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_srcset(&self) {
self.rem_attr(T::attr())
}
}
impl Srcset for elements::Img {}
impl Srcset for elements::Source {}
pub trait Start: elements::HtmlElement {
fn attr() -> &'static str {
"start"
}
}
impl<T> Tag<T>
where
T: Start + 'static,
{
pub fn start(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Start,
{
pub fn get_start(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_start(&self) {
self.rem_attr(T::attr())
}
}
impl Start for elements::Ol {}
pub trait Step: elements::HtmlElement {
fn attr() -> &'static str {
"step"
}
}
impl<T> Tag<T>
where
T: Step + 'static,
{
pub fn step(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Step,
{
pub fn get_step(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_step(&self) {
self.rem_attr(T::attr())
}
}
impl Step for elements::Input {}
pub trait Style: elements::HtmlElement {
fn attr() -> &'static str {
"style"
}
}
impl<T> Tag<T>
where
T: Style + 'static,
{
pub fn style(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Style,
{
pub fn get_style(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_style(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Style for T where T: elements::HtmlElement {}
pub trait Summary: elements::HtmlElement {
fn attr() -> &'static str {
"summary"
}
}
impl<T> Tag<T>
where
T: Summary + 'static,
{
pub fn summary(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Summary,
{
pub fn get_summary(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_summary(&self) {
self.rem_attr(T::attr())
}
}
impl Summary for elements::Table {}
pub trait Tabindex: elements::HtmlElement {
fn attr() -> &'static str {
"tabindex"
}
}
impl<T> Tag<T>
where
T: Tabindex + 'static,
{
pub fn tabindex(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Tabindex,
{
pub fn get_tabindex(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_tabindex(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Tabindex for T where T: elements::HtmlElement {}
pub trait Target: elements::HtmlElement {
fn attr() -> &'static str {
"target"
}
}
impl<T> Tag<T>
where
T: Target + 'static,
{
pub fn target(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Target,
{
pub fn get_target(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_target(&self) {
self.rem_attr(T::attr())
}
}
impl Target for elements::A {}
impl Target for elements::Area {}
impl Target for elements::Base {}
impl Target for elements::Form {}
pub trait Title: elements::HtmlElement {
fn attr() -> &'static str {
"title"
}
}
impl<T> Tag<T>
where
T: Title + 'static,
{
pub fn title(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Title,
{
pub fn get_title(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_title(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Title for T where T: elements::HtmlElement {}
pub trait Translate: elements::HtmlElement {
fn attr() -> &'static str {
"translate"
}
}
impl<T> Tag<T>
where
T: Translate + 'static,
{
pub fn translate(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Translate,
{
pub fn get_translate(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_translate(&self) {
self.rem_attr(T::attr())
}
}
impl<T> Translate for T where T: elements::HtmlElement {}
pub trait Type: elements::HtmlElement {
fn attr() -> &'static str {
"type"
}
}
impl<T> Tag<T>
where
T: Type + 'static,
{
pub fn set_type(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Type,
{
pub fn get_set_type(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_set_type(&self) {
self.rem_attr(T::attr())
}
}
impl Type for elements::Button {}
impl Type for elements::Input {}
impl Type for elements::Embed {}
impl Type for elements::Object {}
impl Type for elements::Script {}
impl Type for elements::Source {}
impl Type for elements::Style {}
impl Type for elements::Menu {}
pub trait Usemap: elements::HtmlElement {
fn attr() -> &'static str {
"usemap"
}
}
impl<T> Tag<T>
where
T: Usemap + 'static,
{
pub fn usemap(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Usemap,
{
pub fn get_usemap(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_usemap(&self) {
self.rem_attr(T::attr())
}
}
impl Usemap for elements::Img {}
impl Usemap for elements::Input {}
impl Usemap for elements::Object {}
pub trait Value: elements::HtmlElement {
fn attr() -> &'static str {
"value"
}
}
impl<T> Tag<T>
where
T: Value + 'static,
{
pub fn value(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Value,
{
pub fn get_value(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_value(&self) {
self.rem_attr(T::attr())
}
}
impl Value for elements::Button {}
impl Value for elements::Data {}
impl Value for elements::Input {}
impl Value for elements::Li {}
impl Value for elements::Meter {}
impl Value for elements::Option {}
impl Value for elements::Progress {}
impl Value for elements::Param {}
pub trait Width: elements::HtmlElement {
fn attr() -> &'static str {
"width"
}
}
impl<T> Tag<T>
where
T: Width + 'static,
{
pub fn width(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Width,
{
pub fn get_width(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_width(&self) {
self.rem_attr(T::attr())
}
}
impl Width for elements::Canvas {}
impl Width for elements::Embed {}
impl Width for elements::Iframe {}
impl Width for elements::Img {}
impl Width for elements::Input {}
impl Width for elements::Object {}
impl Width for elements::Video {}
pub trait Wrap: elements::HtmlElement {
fn attr() -> &'static str {
"wrap"
}
}
impl<T> Tag<T>
where
T: Wrap + 'static,
{
pub fn wrap(self, value: impl value::Value) -> Self {
self.attr(T::attr(), value)
}
}
impl<T> Tag<T>
where
T: Wrap,
{
pub fn get_wrap(&self) -> Option<String> {
self.get_attr(T::attr())
}
pub fn rem_wrap(&self) {
self.rem_attr(T::attr())
}
}
impl Wrap for elements::Textarea {}