cfg

Documentation

Index

• Variables
• func AttributeTypeBool() *pb.Attribute_Type
• func AttributeTypeChoice(name, description string) *pb.Attribute_Choice
• func AttributeTypeChoices(choices ...*pb.Attribute_Choice) *pb.Attribute_Type
• func AttributeTypeCommaDelimited() *pb.Attribute_Type
• func AttributeTypeCustom(hasKey bool, valueType *pb.Attribute_Type, ...) *pb.Attribute_Type
• func AttributeTypeCustomModifier(name string, hasKey bool, valueType *pb.Attribute_Type, ...) *pb.Attribute_Type
• func AttributeTypeDelimited(s string) *pb.Attribute_Type
• func AttributeTypeDuration() *pb.Attribute_Type
• func AttributeTypeInt() *pb.Attribute_Type
• func AttributeTypeJSON() *pb.Attribute_Type
• func AttributeTypeKV(keyValueDelim, pairDelim string) *pb.Attribute_Type
• func AttributeTypeKVColonSemicolon() *pb.Attribute_Type
• func AttributeTypeNumber() *pb.Attribute_Type
• func AttributeTypeRune() *pb.Attribute_Type
• func AttributeTypeSpaceDelimited() *pb.Attribute_Type
• func AttributeTypeString() *pb.Attribute_Type

Variables

var DatastarExtensions = []*pb.Attribute{

	{
		Name:        "DatastarStore",
		Key:         "store",
		Description: "Merges the singleton store with the given object",
		Type:        AttributeTypeCustom(false, AttributeTypeJSON()),
	},
	{
		Name:        "DatastarRef",
		Key:         "ref",
		Description: "Sets the reference of the element",
		Type:        AttributeTypeCustom(false, AttributeTypeString()),
	},

	{
		Name:        "DatastarBind",
		Key:         "bind",
		Description: "Sets the value of the element",
		Type:        AttributeTypeCustom(true, AttributeTypeString()),
	},
	{
		Name:        "DatastarModel",
		Key:         "model",
		Description: "Sets the value of the element",
		Type:        AttributeTypeCustom(false, AttributeTypeString()),
	},
	{
		Name:        "DatastarText",
		Key:         "text",
		Description: "Sets the textContent of the element",
		Type:        AttributeTypeCustom(false, AttributeTypeString()),
	},
	{
		Name:        "DatastarOn",
		Key:         "on",
		Description: "Sets the event handler of the element",
		Type: AttributeTypeCustom(true, AttributeTypeString(),
			&pb.Attribute_Custom_Modifier{
				Name:        "Debounce",
				Description: "Debounces the event handler",
				Type:        AttributeTypeCustomModifier("debounce", false, AttributeTypeDuration()),
				Prefix:      "debounce_",
				Suffix:      "ms",
			},
			&pb.Attribute_Custom_Modifier{
				Name:        "Throttle",
				Description: "Throttles the event handler",
				Type:        AttributeTypeCustomModifier("throttle", false, AttributeTypeDuration()),
				Prefix:      "throttle_",
				Suffix:      "ms",
			},
		),
	},
	{
		Name:        "DatastarFocus",
		Key:         "focus",
		Description: "Sets the focus of the element",
		Type:        AttributeTypeCustom(true, AttributeTypeBool()),
	},

	{
		Name:        "DatastarHeader",
		Key:         "header",
		Description: "Sets the header of for fetch requests",
		Type:        AttributeTypeCustom(true, AttributeTypeString()),
	},
	{
		Name:        "DatastarFetchIndicator",
		Key:         "fetch-indicator",
		Description: "Sets the indicator selector for fetch requests",
		Type:        AttributeTypeCustom(false, AttributeTypeString()),
	},

	{
		Name:        "DatastarShow",
		Key:         "show",
		Description: "Sets the visibility of the element",
		Type:        AttributeTypeCustom(false, AttributeTypeBool()),
	},
	{
		Name:        "DatastarIntersects",
		Key:         "intersects",
		Description: "Triggers the callback when the element intersects the viewport",
		Type:        AttributeTypeCustom(false, AttributeTypeString()),
	},
	{
		Name:        "DatastarTeleport",
		Key:         "teleport",
		Description: "Teleports the element to the given selector",
		Type:        AttributeTypeCustom(false, AttributeTypeBool()),
	},
	{
		Name:        "DatastarScrollIntoView",
		Key:         "scroll-into-view",
		Description: "Scrolls the element into view",
		Type:        AttributeTypeCustom(false, AttributeTypeBool()),
	},
	{
		Name:        "DatastarViewTransition",
		Key:         "view-transition",
		Description: "Setup the ViewTransitionAPI for the element",
		Type:        AttributeTypeCustom(false, AttributeTypeString()),
	},
}

var Default = &pb.Namespaces{
	Namespaces: []*pb.Namespace{
		HTML,
		SVG,
		MathML,
	},
	Attributes: lo.Flatten([][]*pb.Attribute{
		DatastarExtensions,
	}),
}

var HTML = &pb.Namespace{
	Name:        "html",
	Description: `HTML (HyperText Markup Language) is the most basic building block of the Web. It defines the meaning and structure of web content. Other technologies besides HTML are generally used to describe a web page's appearance/presentation (CSS) or functionality/behavior (JavaScript). "Hypertext" refers to links that connect web pages to one another, either within a single website or between websites. Links are a fundamental aspect of the Web. By uploading content to the Internet and linking it to pages created by other people, you become an active participant in the World Wide Web.`,
	Attributes: []*pb.Attribute{
		{
			Key:         "accesskey",
			Description: `The accesskey global attribute provides a hint for generating a keyboard shortcut for the current element. The attribute value must consist of a single printable character (which includes accented and other characters that can be generated by the keyboard).`,
			Type:        AttributeTypeRune(),
		},

		{
			Key:         "autocapitalize",
			Description: `The autocapitalize global attribute is an enumerated attribute that controls whether and how text input is automatically capitalized as it is entered/edited by the user. autocapitalize can be set on <input> and <textarea> elements, and on their containing <form> elements. When autocapitalize is set on a <form> element, it sets the autocapitalize behavior for all contained <input>s and <textarea>s, overriding any autocapitalize values set on contained elements. autocapitalize has no effect on the url, email, or password <input> types, where autocapitalization is never enabled. Where autocapitalize is not specified, the adopted default behavior varies between browsers. For example: Chrome and Safari default to on/sentences Firefox defaults to off/none.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("off", "Do not automatically capitalize any text."),
				AttributeTypeChoice("none", "Do not automatically capitalize any text."),
				AttributeTypeChoice("sentences", "Automatically capitalize the first character of each sentence."),
				AttributeTypeChoice("on", "Automatically capitalize the first character of each sentence."),
				AttributeTypeChoice("words", "Automatically capitalize the first character of each word."),
				AttributeTypeChoice("characters", "Automatically capitalize all characters."),
			),
		},
		{
			Key: "autofocus",
			Description: `The autofocus global attribute is a Boolean attribute indicating that an element should be focused on page load, or when the <dialog> that it is part of is displayed.
		Accessibility concerns Automatically focusing a form control can confuse visually-impaired people using screen-reading technology and people with cognitive impairments. When autofocus is assigned, screen-readers "teleport" their user to the form control without warning them beforehand.
		Use careful consideration for accessibility when applying the autofocus attribute. Automatically focusing on a control can cause the page to scroll on load. The focus can also cause dynamic keyboards to display on some touch devices. While a screen reader will announce the label of the form control receiving focus, the screen reader will not announce anything before the label, and the sighted user on a small device will equally miss the context created by the preceding content.`,
			Type: AttributeTypeBool(),
		},

		{
			Key:         "class",
			Description: `The class global attribute is a space-separated list of the case-sensitive classes of the element. Classes allow CSS and JavaScript to select and access specific elements via the class selectors or functions like the DOM method document.getElementsByClassName.`,
			Type:        AttributeTypeSpaceDelimited(),
		},

		{
			Key:         "contenteditable",
			Description: `The contenteditable global attribute is an enumerated attribute indicating if the element should be editable by the user. If so, the browser modifies its widget to allow editing.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("", "The element is editable."),
				AttributeTypeChoice("true", "The element is editable."),
				AttributeTypeChoice("false", "The element is not editable."),
				AttributeTypeChoice("plaintext-only", "which indicates that the element's raw text is editable, but rich text formatting is disabled."),
			),
		},

		{
			Key:         "dir",
			Description: `The dir global attribute is an enumerated attribute that indicates the directionality of the element's text. Note: This attribute is mandatory for the <bdo> element where it has a different semantic meaning. This attribute is not inherited by the <bdi> element. If not set, its value is auto. This attribute can be overridden by the CSS properties direction and unicode-bidi, if a CSS page is active and the element supports these properties. As the directionality of the text is semantically related to its content and not to its presentation, it is recommended that web developers use this attribute instead of the related CSS properties when possible. That way, the text will display correctly even on a browser that doesn't support CSS or has the CSS deactivated. The auto value should be used for data with an unknown directionality, like data coming from user input, eventually stored in a database.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("ltr", "which means left to right and is to be used for languages that are written from the left to the right (like English);"),
				AttributeTypeChoice("rtl", "which means right to left and is to be used for languages that are written from the right to the left (like Arabic);"),
				AttributeTypeChoice("auto", "which lets the user agent decide. It uses a basic algorithm as it parses the characters inside the element until it finds a character with a strong directionality, then it applies that directionality to the whole element."),
			),
		},

		{
			Key:         "draggable",
			Description: `The draggable global attribute is an enumerated attribute that indicates whether the element can be dragged, either with native browser behavior or the HTML Drag and Drop API.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("true", "The element is draggable."),
				AttributeTypeChoice("false", "The element is not draggable."),
				AttributeTypeChoice("", "drag behavior is the default browser behavior: only text selections, images, and links can be dragged. For other elements, the event ondragstart must be set for drag and drop to work"),
				AttributeTypeChoice("auto", "drag behavior is the default browser behavior: only text selections, images, and links can be dragged. For other elements, the event ondragstart must be set for drag and drop to work"),
			),
		},

		{
			Key:         "enterkeyhint",
			Description: `The enterkeyhint global attribute is an enumerated attribute defining what action label (or icon) to present for the enter key on virtual keyboards.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("enter", "Typically inserting a new line."),
				AttributeTypeChoice("done", "Typically meaning there is nothing more to input and the input method editor (IME) will be closed."),
				AttributeTypeChoice("go", "Typically meaning to take the user to the target of the text they typed."),
				AttributeTypeChoice("next", "Typically meaning to take the user to the next field that will accept text."),
				AttributeTypeChoice("previous", "Typically meaning to take the user to the previous field that will accept text."),
				AttributeTypeChoice("search", "Typically taking the user to the results of searching for the text they have typed."),
				AttributeTypeChoice("send", "Typically delivering the text to its target."),
			),
		},

		{
			Key:         "exportparts",
			Description: `The exportparts global attribute allows you to select and style elements existing in nested shadow trees, by exporting their part names. The shadow tree is an isolated structure where identifiers, classes, and styles cannot be reached by selectors or queries belonging to a regular DOM. To apply a style to an element living in a shadow tree, by CSS rule created outside of it, part global attribute has to be used. It has to be assigned to an element present in Shadow Tree, and its value should be some identifier. Rules present outside of the shadow tree, must use the ::part pseudo-element, containing the same identifier as the argument. The global attribute part makes the element visible on just a single level of depth. When the shadow tree is nested, parts will be visible only to the parent of the shadow tree but not to its ancestor. Exporting parts further down is exactly what exportparts attribute is for. Attribute exportparts must be placed on a shadow Host, which is the element to which the shadow tree is attached. The value of the attribute should be a comma-separated list of part names present in the shadow tree and which should be made available via a DOM outside of the current structure.`,
			Type:        AttributeTypeCommaDelimited(),
		},

		{
			Key:         "hidden",
			Description: `The hidden global attribute is a Boolean attribute indicating that the element is not yet, or is no longer, relevant. For example, it can be used to hide elements of the page that can't be used until the login process has been completed. Note that browsers typically implement hidden until found using content-visibility: hidden. This means that unlike elements in the hidden state, elements in the hidden until found state will have generated boxes, meaning that: the element will participate in page layout margin, borders, padding, and background for the element will be rendered. Also, the element needs to be affected by layout containment in order to be revealed. This means that if the element in the hidden until found state has a display value of none, contents, or inline, then the element will not be revealed by find in page or fragment navigation.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("", "set the element to the hidden state. Additionally, invalid values set the element to the hidden state."),
				AttributeTypeChoice("hidden", "set the element to the hidden state. Additionally, invalid values set the element to the hidden state."),
				AttributeTypeChoice("until-found", `the element is hidden but its content will be accessible to the browser's "find in page" feature or to fragment navigation. When these features cause a scroll to an element in a hidden until found subtree, the browser will fire a beforematch event on the hidden element remove the hidden attribute from the element scroll to the element
			`),
			),
		},

		{
			Key:         "id",
			Description: `The id global attribute defines a unique identifier (ID) which must be unique in the whole document. Its purpose is to identify the element when linking (using a fragment identifier), scripting, or styling (with CSS).`,
			Type:        AttributeTypeString(),
		},

		{
			Key:         "inert",
			Description: `The inert global attribute is a Boolean attribute indicating that the browser will ignore the element. With the inert attribute, all of the element's flat tree descendants (such as modal <dialog>s) that don't otherwise escape inertness are ignored. The inert attribute also makes the browser ignore input events sent by the user, including focus-related events and events from assistive technologies. Specifically, inert does the following: Prevents the click event from being fired when the user clicks on the element. Prevents the focus event from being raised by preventing the element from gaining focus. Hides the element and its content from assistive technologies by excluding them from the accessibility tree.`,
			Type:        AttributeTypeBool(),
		},

		{
			Key:         "inputmode",
			Description: `The inputmode global attribute is an enumerated attribute that hints at the type of data that might be entered by the user while editing the element or its contents. This allows a browser to display an appropriate virtual keyboard. It is used primarily on <input> elements, but is usable on any element in contenteditable mode. It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("none", "No virtual keyboard. For when the page implements its own keyboard input control."),
				AttributeTypeChoice("", `Standard input keyboard for the user's current locale.`),
				AttributeTypeChoice("text", `Standard input keyboard for the user's current locale.`),
				AttributeTypeChoice("decimal", `Fractional numeric input keyboard containing the digits and decimal separator for the user's locale (typically . or ,). Devices may or may not show a minus key (-).`),
				AttributeTypeChoice("numeric", `Numeric input keyboard, but only requires the digits 0–9. Devices may or may not show a minus key.`),
				AttributeTypeChoice("tel", `A telephone keypad input, including the digits 0–9, the asterisk (*), and the pound (#) key. Inputs that *require* a telephone number should typically use <input type="tel"> instead.`),
				AttributeTypeChoice("search", `A virtual keyboard optimized for search input. For instance, the return/submit key may be labeled "Search", along with possible other optimizations. Inputs that require a search query should typically use <input type="search"> instead.`),
				AttributeTypeChoice("email", `A virtual keyboard optimized for entering email addresses. Typically includes the @character as well as other optimizations. Inputs that require email addresses should typically use <input type="email"> instead.`),
				AttributeTypeChoice("url", `A keypad optimized for entering URLs. This may have the / key more prominent, for example. Enhanced features could include history access and so on. Inputs that require a URL should typically use <input type="url"> instead.`),
			),
		},

		{
			Key:         "is",
			Description: `The is global attribute allows you to specify that a standard HTML element should behave like a defined custom built-in element (see Using custom elements for more details). This attribute can only be used if the specified custom element name has been successfully defined in the current document, and extends the element type it is being applied to.`,
			Type:        AttributeTypeString(),
		},

		{
			Key: "itemid",
			Description: `The itemid global attribute provides microdata in the form of a unique, global identifier of an item.

		An itemid attribute can only be specified for an element that has both itemscope and itemtype attributes. Also, itemid can only be specified on elements that possess an itemscope attribute whose corresponding itemtype refers to or defines a vocabulary that supports global identifiers. The exact meaning of an itemtype's global identifier is provided by the definition of that identifier within the specified vocabulary. The vocabulary defines whether several items with the same global identifier can coexist and, if so, how items with the same identifier are handled.`,
			Type: AttributeTypeString(),
		},

		{
			Key:         "itemprop",
			Description: `The itemprop global attribute is used to add properties to an item. Every HTML element can have an itemprop attribute specified, and an itemprop consists of a name-value pair. Each name-value pair is called a property, and a group of one or more properties forms an item. Property values are either a string or a URL and can be associated with a very wide range of elements including <audio>, <embed>, <iframe>, <img>, <link>, <object>, <source>, <track>, and <video>.`,
			Type:        AttributeTypeString(),
		},

		{
			Key:         "itemref",
			Description: `Properties that are not descendants of an element with the itemscope attribute can be associated with an item using the global attribute itemref. itemref provides a list of element IDs (not itemids) elsewhere in the document, with additional properties The itemref attribute can only be specified on elements that have an itemscope attribute specified.`,
			Type:        AttributeTypeString(),
		},

		{
			Key:         "itemscope",
			Description: `The itemscope global attribute is used to add an item to a microdata DOM tree. Every HTML element can have an itemscope attribute specified, and an itemscope consists of a name-value pair. Each name-value pair is called a property, and a group of one or more properties forms an item. Property values are either a string or a URL and can be associated with a very wide range of elements including <audio>, <embed>, <iframe>, <img>, <link>, <object>, <source>, <track>, and <video>.`,
			Type:        AttributeTypeBool(),
		},

		{
			Key:         "itemtype",
			Description: `The itemtype global attribute is used to add types to an item. Every HTML element can have an itemtype attribute specified, and an itemtype consists of a name-value pair. Each name-value pair is called a property, and a group of one or more properties forms an item. Property values are either a string or a URL and can be associated with a very wide range of elements including <audio>, <embed>, <iframe>, <img>, <link>, <object>, <source>, <track>, and <video>.`,
			Type:        AttributeTypeString(),
		},

		{
			Key:         "lang",
			Description: `The lang global attribute helps define the language of an element: the language that non-editable elements are written in or the language that editable elements should be written in by the user. The tag contains one single entry value in the format defines in the Tags for Identifying Languages (BCP47) IETF document. xml:lang has priority over it.`,
			Type:        AttributeTypeString(),
		},

		{
			Key:         "nonce",
			Description: `The nonce global attribute is a unique identifier used to declare inline scripts and style elements to be used in a specific document. It is a cryptographic nonce (number used once) that is used by Content Security Policy to determine whether or not a given inline script is allowed to execute.`,
			Type:        AttributeTypeString(),
		},

		{
			Key:         "part",
			Description: `The part global attribute contains a space-separated list of the part names of the element. Part names allows CSS to select and style specific elements in a shadow tree via the ::part pseudo-element.`,
			Type:        AttributeTypeSpaceDelimited(),
		},

		{
			Key:         "popver",
			Description: `The popover global attribute is used to designate an element as a popover element. Popover elements are hidden via display: none until opened via an invoking/control element (i.e. a <button> or <input type="button"> with a popovertarget attribute) or a HTMLElement.showPopover() call. When open, popover elements will appear above all other elements in the top layer, and won't be influenced by parent elements' position or overflow styling.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("auto", `Popovers that have the auto state can be "light dismissed" by selecting outside the popover area, and generally only allow one popover to be displayed on-screen at a time.`),
				AttributeTypeChoice("", `Popovers that have the auto state can be "light dismissed" by selecting outside the popover area, and generally only allow one popover to be displayed on-screen at a time.`),
				AttributeTypeChoice("manual", `manual popovers must always be explicitly hidden, but allow for use cases such as nested popovers in menus.`),
			),
		},

		{
			Key:         "role",
			Description: `The role global attribute is used to define the purpose or state of an element to the browser, in order to facilitate assistive technology such as screen readers. It is a simple string value that can be used to describe the role of an element.`,
			Type:        AttributeTypeString(),
		},

		{

			Key:         "slot",
			Description: `The slot global attribute assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is assigned to the slot created by the <slot> element whose name attribute's value matches that slot attribute's value.`,
			Type:        AttributeTypeString(),
		},

		{

			Key:         "spellcheck",
			Description: `The spellcheck global attribute is an enumerated attribute that defines whether the element may be checked for spelling errors. If this attribute is not set, its default value is element-type and browser-defined. This default value may also be inherited, which means that the element content will be checked for spelling errors only if its nearest ancestor has a spellcheck state of true. Security and privacy concerns Using spellchecking can have consequences for users' security and privacy. The specification does not regulate how spellchecking is done and the content of the element may be sent to a third party for spellchecking results (see enhanced spellchecking and "spell-jacking"). You should consider setting spellcheck to false for elements that can contain sensitive information.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("", `The element will be checked for spelling errors.`),
				AttributeTypeChoice("true", `The element will be checked for spelling errors.`),
				AttributeTypeChoice("false", `The element will not be checked for spelling errors.`),
			),
		},

		{

			Key:         "style",
			Description: `The style global attribute is used to add styles to an element, such as color, font, size, and more. Styles are written in CSS.`,
			Type:        AttributeTypeKVColonSemicolon(),
		},

		{

			Key:         "tabindex",
			Description: `The tabindex global attribute indicates if its element can be focused, and if/where it participates in sequential keyboard navigation (usually with the Tab key, hence the name). It accepts an integer as a value, with different results depending on the integer's value: a negative value (usually tabindex="-1") means that the element should be focusable, but should not be reachable via sequential keyboard navigation; a value of 0 (tabindex="0") means that the element should be focusable and reachable via sequential keyboard navigation, but its relative order is defined by the platform convention; a positive value means should be focusable and reachable via sequential keyboard navigation; its relative order is defined by the value of the attribute: the sequential follow the increasing number of the tabindex. If several elements share the same tabindex, their relative order follows their relative position in the document.`,
			Type:        AttributeTypeInt(),
		},

		{

			Key:         "title",
			Description: `The title global attribute contains text representing advisory information related to the element it belongs to. Such information can typically, but not necessarily, be presented to the user as a tooltip. The main use of the title attribute is to label <iframe> elements for assistive technology. The title attribute may also be used to label controls in data tables. The title attribute, when added to <link rel="stylesheet">, creates an alternate stylesheet. When defining an alternative style sheet with <link rel="alternate"> the attribute is required and must be set to a non-empty string. If included on the <abbr> opening tag, the title must be a full expansion of the abbreviation or acronym. Instead of using title, when possible, provide an expansion of the abbreviation or acronym in plain text on first use, using the <abbr> to mark up the abbreviation. This enables all users know what name or term the abbreviation or acronym shortens while providing a hint to user agents on how to announce the content. While title can be used to provide a programmatically associated label for an <input> element, this is not good practice. Use a <label> instead.`,
			Type:        AttributeTypeString(),
		},

		{

			Key:         "translate",
			Description: `The translate global attribute is an enumerated attribute that is used to specify whether an element's attribute values and the values of its Text node children are to be translated when the page is localized, or whether to leave them unchanged.`,
			Type: AttributeTypeChoices(
				AttributeTypeChoice("", `indicates that the element should be translated when the page is localized.`),
				AttributeTypeChoice("yes", `indicates that the element should be translated when the page is localized.`),
				AttributeTypeChoice("no", `indicates that the element must not be translated when the page is localized.`),
			),
		},
	},

	Elements: []*pb.Element{
		{
			Tag:         "a",
			Description: "The HTML <a> element (or anchor element), with its href attribute, creates a hyperlink to web pages, files, email addresses, locations in the same page, or anything else a URL can address. Content within each <a> should indicate the link's destination.",
			Attributes: []*pb.Attribute{
				{
					Key:         "download",
					Description: "Causes the browser to treat the linked URL as a download. Can be used with or without a filename",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "href",
					Description: "The URL that the hyperlink points to. Links are not restricted to HTTP-based URLs — they can use any URL scheme supported by browsers",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "hreflang",
					Description: "Specifies the language of the linked resource. It is purely advisory. Allowed values are determined by BCP47 for HTML5 and by RFC1766 for HTML 4. Use this attribute only if the href attribute is present",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "ping",
					Description: "A space-separated list of URLs. When the link is followed, the browser will send POST requests with the body PING to the URLs. Typically for tracking.",
					Type:        AttributeTypeCommaDelimited(),
				},
				{
					Key:         "referrerpolicy",
					Description: "Specifies which referrer to send when fetching the resource. See Referrer-Policy for possible values and their effects.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("no-referrer", "The Referer header will not be sent."),
						AttributeTypeChoice("no-referrer-when-downgrade", "The Referer header will not be sent to origins without TLS (HTTPS)."),
						AttributeTypeChoice("origin", "The Referer header will be the origin of the page."),
						AttributeTypeChoice("origin-when-cross-origin", "The Referer header will be the origin of the page for same-origin requests, and the full URL for cross-origin requests."),
						AttributeTypeChoice("same-origin", "The Referer header will be sent for same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin", "The Referer header will be sent with same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin-when-cross-origin", "Send a full URL when performing a same-origin request, only send the origin of the document to a-priori as-much-secure destination (HTTPS->HTTPS), and send no header to a less secure destination (HTTPS->HTTP)."),
						AttributeTypeChoice("unsafe-url", "The Referer header will be sent with same-origin and cross-origin requests."),
					),
				},
				{
					Key:         "rel",
					Description: "Specifies the relationship of the target object to the link object. The value is a space-separated list of link types values. The values and their semantics will be registered by some authority that might have meaning to the document author. The default relationship, if no other is given, is void. Use this attribute only if the href attribute is present.",
					Type:        AttributeTypeSpaceDelimited(),
				},
				{
					Key:         "target",
					Description: "Specifies where to display the linked URL. It is a name of, or keyword for, a browsing context: a tab, window, or <iframe>. The following keywords have special meanings:",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("", `the current browsing context. (Default)`),
						AttributeTypeChoice("_self", `the current browsing context. (Default)`),
						AttributeTypeChoice("_blank", `usually a new tab, but users can configure browsers to open a new window instead.`),
						AttributeTypeChoice("_parent", `the parent browsing context of the current one. If no parent, behaves as _self.`),
						AttributeTypeChoice("_top", `the topmost browsing context (the "highest" context that's an ancestor of the current one). If no ancestors, behaves as _self.`),
					),
				},
				{
					Key:         "type",
					Description: `Hints at the linked URL's format with a MIME type. No built-in functionality.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "abbr",
			Description: "The HTML Abbreviation element (<abbr>) represents an abbreviation or acronym; the optional title attribute can provide an expansion or description for the abbreviation.",
			Attributes: []*pb.Attribute{
				{
					Key:         "title",
					Description: "Contains a string that represents the full term or expansion of the abbreviation or acronym, as defined by the abbr element.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "address",
			Description: "The HTML <address> element indicates that the enclosed HTML provides contact information for a person or people, or for an organization.",
		},

		{
			Tag:         "area",
			NoChildren:  true,
			Description: "The HTML <area> element defines an area inside an image map that has predefined clickable areas. An image map allows geometric areas on an image to be associated with hyperlinks.",
			Attributes: []*pb.Attribute{
				{
					Key:         "alt",
					Description: "Alternative text in case an image can't be displayed",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "coords",
					Description: "Coordinates for the shape to be created in an image map",
					Type:        AttributeTypeCommaDelimited(),
				},
				{
					Key:         "download",
					Description: "Causes the browser to download the resource instead of navigating to it. Can be used with or without a value",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "href",
					Description: "The URL of a linked resource",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "ping",
					Description: "A list of URLs to which, when the hyperlink is followed, post requests with the body PING will be sent by the browser (in the background). Typically used for tracking.",
					Type:        AttributeTypeCommaDelimited(),
				},
				{
					Key:         "referrerpolicy",
					Description: "Specifies which referrer to send when fetching the resource. See Referrer-Policy for possible values and their effects.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("no-referrer", "The Referer header will not be sent."),
						AttributeTypeChoice("no-referrer-when-downgrade", "The Referer header will not be sent to origins without TLS (HTTPS)."),
						AttributeTypeChoice("origin", "The Referer header will be the origin of the page."),
						AttributeTypeChoice("origin-when-cross-origin", "The Referer header will be the origin of the page for same-origin requests, and the full URL for cross-origin requests."),
						AttributeTypeChoice("same-origin", "The Referer header will be sent for same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin", "The Referer header will be sent with same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin-when-cross-origin", "Send a full URL when performing a same-origin request, only send the origin of the document to a-priori as-much-secure destination (HTTPS->HTTPS), and send no header to a less secure destination (HTTPS->HTTP)."),
						AttributeTypeChoice("unsafe-url", "The Referer header will be sent with same-origin and cross-origin requests."),
					),
				},
				{
					Key:         "rel",
					Description: "Specifies the relationship of the target object to the link object. The value is a space-separated list of link types values. The values and their semantics will be registered by some authority that might have meaning to the document author. The default relationship, if no other is given, is void. Use this attribute only if the href attribute is present.",
					Type:        AttributeTypeSpaceDelimited(),
				},
				{
					Key:         "shape",
					Description: "The kind of shape to be created in an image map",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("circle", "Defines a circle"),
						AttributeTypeChoice("default", "Defines the entire region"),
						AttributeTypeChoice("poly", "Defines a polygon"),
						AttributeTypeChoice("rect", "Defines a rectangle"),
					),
				},
				{
					Key:         "target",
					Description: "Specifies where to display the linked URL. It is a name of, or keyword for, a browsing context: a tab, window, or <iframe>. The following keywords have special meanings:",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("", `the current browsing context. (Default)`),
						AttributeTypeChoice("_self", `the current browsing context. (Default)`),
						AttributeTypeChoice("_blank", `usually a new tab, but users can configure browsers to open a new window instead.`),
						AttributeTypeChoice("_parent", `the parent browsing context of the current one. If no parent, behaves as _self.`),
						AttributeTypeChoice("_top", `the topmost browsing context (the "highest" context that's an ancestor of the current one). If no ancestors, behaves as _self.`),
					),
				},
			},
		},

		{
			Tag:         "article",
			Description: "The HTML <article> element represents a self-contained composition in a document, page, application, or site, which is intended to be independently distributable or reusable (e.g., in syndication).",
		},

		{
			Tag:         "aside",
			Description: "The HTML <aside> element represents a portion of a document whose content is only indirectly related to the document's main content.",
		},

		{
			Tag:         "audio",
			Description: "The HTML <audio> element is used to embed sound content in documents. It may contain one or more audio sources, represented using the src attribute or the <source> element: the browser will choose the most suitable one. It can also be the destination for streamed media, using a MediaStream.",
			Attributes: []*pb.Attribute{
				{
					Key:         "autoplay",
					Description: "A Boolean attribute; if specified (even if the value is \"false\"!), the audio will automatically begin playback as soon as it can do so, without waiting for the entire audio file to finish downloading.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "controls",
					Description: "If this attribute is present, the browser will offer controls to allow the user to control audio playback, including volume, seeking, and pause/resume playback.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "loop",
					Description: "A Boolean attribute; if specified, the audio player will automatically seek back to the start upon reaching the end of the audio.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "muted",
					Description: "A Boolean attribute which indicates whether the audio will be initially silenced. Its default value is false, meaning that the audio will be played when the <audio> element is loaded.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "preload",
					Description: "This enumerated attribute is intended to provide a hint to the browser about what the author thinks will lead to the best user experience. It may have one of the following values:",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", "Hints to the browser that either the author does not expect the user to need the media resource, or that the server wants to minimize unnecessary traffic."),
						AttributeTypeChoice("metadata", "Hints to the browser that the author does not expect the user to need the media resource, but that fetching the resource metadata (dimensions, first frame, track list, duration, etc), is reasonable."),
						AttributeTypeChoice("auto", "Hints to the browser that the user is likely to need the media resource, and that fetching the entire media resource is reasonable."),
					),
				},
				{
					Key:         "src",
					Description: "The URL of the embeddable content.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "b",
			Description: "The HTML Bring Attention To element (<b>) is used to draw the reader's attention to the element's contents, which are not otherwise granted special importance. This was formerly known as the Boldface element, and most browsers still draw the text in boldface. However, you should not use <b> for styling text; instead, you should use the CSS font-weight property to create boldface text, or the <strong> element to indicate that text is of special importance.",
		},

		{
			Tag:         "base",
			NoChildren:  true,
			Description: "The HTML <base> element specifies the base URL to use for all relative URLs in a document. There can be only one <base> element in a document.",
			Attributes: []*pb.Attribute{
				{
					Key:         "href",
					Description: "Specifies the base URL to use for all relative URLs in the page.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "target",
					Description: "Specifies the default target attribute to use for the page.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "bdi",
			Description: "The HTML Bidirectional Isolate element (<bdi>) tells the browser's bidirectional algorithm to treat the text it contains in isolation from its surrounding text.",
		},

		{
			Tag:         "bdo",
			Description: "The HTML Bidirectional Override element (<bdo>) overrides the current directionality of text, so that the text within is rendered in a different direction.",
		},

		{
			Tag:         "blockquote",
			Description: "The HTML <blockquote> Element (or HTML Block Quotation Element) indicates that the enclosed text is an extended quotation. Usually, this is rendered visually by indentation (see Notes for how to change it). A URL for the source of the quotation may be given using the cite attribute, while a text representation of the source can be given using the <cite> element.",
			Attributes: []*pb.Attribute{
				{
					Key:         "cite",
					Description: "Contains a URI which points to the source of the quote or change.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "body",
			Description: "The HTML <body> Element represents the content of an HTML document. There can be only one <body> element in a document.",
		},

		{
			Tag:         "br",
			NoChildren:  true,
			Description: "The HTML <br> element produces a line break in text (carriage-return). It is useful for writing a poem or an address, where the division of lines is significant.",
		},

		{
			Tag:         "button",
			Description: "The HTML <button> element represents a clickable button, used to submit forms or anywhere in a document for accessible, standard button functionality.",
			Attributes: []*pb.Attribute{
				{
					Key:         "autofocus",
					Description: "A Boolean attribute which, if present, indicates that the button should be focused as soon as the page is loaded.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "disabled",
					Description: "A Boolean attribute which is present if the button is disabled.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "form",
					Description: "The id of the form with which to associate the element.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "formaction",
					Description: "The URI of a program that processes the information submitted by the button. If specified, it overrides the action attribute of the button's form owner.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "formenctype",
					Description: "If the button is a submit button, this attribute specifies the type of content that is used to submit the form to the server.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("application/x-www-form-urlencoded", "The default value if the attribute is not specified."),
						AttributeTypeChoice("multipart/form-data", "Use this value if you are using an enctype that requires a file upload."),
						AttributeTypeChoice("text/plain", `Use this value if you are using a "text/plain" enctype and the form will not contain any file uploads.`),
					),
				},
				{
					Key:         "formmethod",
					Description: "If the button is a submit button, this attribute specifies the HTTP method that the browser uses to submit the form. Possible values are:",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("post", "The data from the form is included in the body of the HTTP request when sent to the server."),
						AttributeTypeChoice("get", "The data from the form are appended to the form attribute URI, with a '?' as a separator, and the resulting URI is sent to the server. Use this method when the form has no side-effects and contains only ASCII characters."),
						AttributeTypeChoice("dialog", "When the form is inside a <dialog>, closes the dialog on submission."),
					),
				},
				{
					Key:         "formnovalidate",
					Description: "If the button is a submit button, this Boolean attribute specifies that the form is not to be validated when it is submitted. If this attribute is specified, it overrides the novalidate attribute of the button's form owner.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "formtarget",
					Description: "If the button is a submit button, this attribute is a name or keyword indicating where to display the response that is received after submitting the form. This is a name of, or keyword for, a browsing context (for example, tab, window, or inline frame). If this attribute is specified, it overrides the target attribute of the button's form owner. The following keywords have special meanings:",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("_self", "Load the response into the same browsing context as the current one. This value is the default if the attribute is not specified."),
						AttributeTypeChoice("_blank", "Load the response into a new unnamed browsing context."),
						AttributeTypeChoice("_parent", "Load the response into the parent browsing context of the current one. If there is no parent, this option behaves the same way as _self."),
						AttributeTypeChoice("_top", "Load the response into the top-level browsing context (that is, the browsing context that is an ancestor of the current one, and has no parent). If there is no parent, this option behaves the same way as _self."),
					),
				},
				{
					Key:         "name",
					Description: "The name of the button, which is submitted with the form data.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "popovertarget",
					Description: `Turns a <button> element into a popover control button; takes the ID of the popover element to control as its value. See the Popover API landing page for more details.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "popovertargetaction",
					Description: "Specifies the action to take when the popover control button is clicked. Possible values are:",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("toggle", "Toggle the visibility of the popover."),
						AttributeTypeChoice("show", "Show the popover."),
						AttributeTypeChoice("hide", "Hide the popover."),
					),
				},
				{
					Key:         "type",
					Description: "The type of the button. Possible values are:",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("button", "The button has no default behavior. It can have client-side scripts associated with the element's events, which are triggered when the events occur."),
						AttributeTypeChoice("reset", "The button resets all the controls to their initial values."),
						AttributeTypeChoice("submit", "The button submits the form data to the server. This is the default if the attribute is not specified for buttons associated with a <form>, or if the attribute is an empty or invalid value."),
					),
				},
				{
					Key:         "value",
					Description: "The initial value of the button. This attribute is optional except when the value of the type attribute is radio or checkbox.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "canvas",
			Description: "The HTML <canvas> element is used to draw graphics, on the fly, via scripting (usually JavaScript). However, <canvas> has several features that make it more accessible to developers.",
			Attributes: []*pb.Attribute{
				{
					Key:         "height",
					Description: "The height of the coordinate space in CSS pixels.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "width",
					Description: "The width of the coordinate space in CSS pixels.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "caption",
			Description: "The HTML <caption> element specifies the caption (or title) of a table, and if used is always the first child of a <table>.",
		},

		{
			Tag:         "cite",
			Description: "The HTML Citation element (<cite>) is used to describe a reference to a cited creative work, and must include the title of that work. The reference may be in an abbreviated form according to context-appropriate conventions related to citation metadata.",
		},

		{
			Tag:         "code",
			Description: "The HTML <code> element displays its contents styled in a fashion intended to indicate that the text is a short fragment of computer code. By default, the content text is displayed using the user agent's default monospace font.",
		},

		{
			Tag:         "col",
			NoChildren:  true,
			Description: "The HTML <col> element defines a column within a table and is used for defining common semantics on all common cells. It is generally found within a <colgroup> element.",
			Attributes: []*pb.Attribute{
				{
					Key:         "span",
					Description: "How many columns this column element spans.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "colgroup",
			Description: "The HTML <colgroup> element defines a group of columns within a table.",
			Attributes: []*pb.Attribute{
				{
					Key:         "span",
					Description: "How many columns this column group element spans.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "data",
			Description: "The HTML <data> element links a given content with a machine-readable translation. If the content is time- or date-related, the <time> must be used.",
			Attributes: []*pb.Attribute{
				{
					Key:         "value",
					Description: "The machine-readable translation of the content of the element.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "datalist",
			Description: "The HTML <datalist> element contains a set of <option> elements that represent the permissible or recommended options available to choose from within other controls.",
		},

		{
			Tag:         "dd",
			Description: "The HTML <dd> element provides the description, definition, or value for the preceding term (<dt>) in a description list (<dl>).",
		},

		{
			Tag:         "del",
			Description: "The HTML <del> element represents a range of text that has been deleted from a document. This can be used when rendering \"track changes\" or source code diff information, for example. The ins element can be used for the opposite purpose: to indicate text that has been added to the document.",
			Attributes: []*pb.Attribute{
				{
					Key:         "cite",
					Description: "Contains a URI which points to the source of the quote or change.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "datetime",
					Description: "Indicates the date and time associated with the element.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "details",
			Description: "The HTML <details> element is used as a disclosure widget from which the user can retrieve additional information.",
			Attributes: []*pb.Attribute{
				{
					Key:         "open",
					Description: "Indicates whether the details will be shown on page load.",
					Type:        AttributeTypeBool(),
				},
			},
		},

		{
			Tag:         "dfn",
			Description: "The HTML Definition element (<dfn>) is used to indicate the term being defined within the context of a definition phrase or sentence. The <dfn> element is not itself intended to be included in the definition of the term.",
		},

		{
			Tag:         "dialog",
			Description: "The HTML <dialog> element represents a dialog box or other interactive component, such as an inspector or window. <form> elements can be integrated within a dialog by specifying them with the attribute method=\"dialog\".",
			Attributes: []*pb.Attribute{
				{
					Key:         "open",
					Description: "Indicates whether the dialog is showing.",
					Type:        AttributeTypeBool(),
				},
			},
		},

		{
			Tag:         "div",
			Description: "The HTML <div> element is the generic container for flow content and does not inherently represent anything. Use it to group elements for purposes such as styling (using the class or id attributes), marking a section of a document in a different language (using the lang attribute), and so on.",
		},

		{
			Tag:         "dl",
			Description: "The HTML <dl> element represents a description list. The element encloses a list of groups of terms (specified using the <dt> element) and descriptions (provided by <dd> elements). Common uses for this element are to implement a glossary or to display metadata (a list of key-value pairs).",
		},

		{
			Tag:         "dt",
			Description: "The HTML <dt> element specifies a term in a description or definition list, and as such must be used inside a <dl> element.",
		},

		{
			Tag:         "em",
			Description: "The HTML <em> element marks text that has stress emphasis. The <em> element can be nested, with each level of nesting indicating a greater degree of emphasis.",
		},

		{
			Tag:         "embed",
			NoChildren:  true,
			Description: "The HTML <embed> element embeds external content at the specified point in the document. This content is provided by an external application or other source of interactive content such as a browser plug-in.",
			Attributes: []*pb.Attribute{
				{
					Key:         "height",
					Description: "The height of the embedded content.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "src",
					Description: "The URL of the resource being embedded.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: "The type of content being embedded.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: "The width of the embedded content.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "fieldset",
			Description: "The HTML <fieldset> element is used to group several controls as well as labels (<label>) within a web form.",
		},

		{
			Tag:         "figure",
			Description: "The HTML <figure> element represents self-contained content, potentially with an optional caption, which is specified using the (<figcaption>) element. The figure, its caption, and its contents are referenced as a single unit.",
		},

		{
			Tag:         "figcaption",
			Description: "The HTML <figcaption> or Figure Caption element represents a caption or legend describing the rest of the contents of its parent <figure> element.",
		},

		{
			Tag:         "footer",
			Description: "The HTML <footer> element represents a footer for its nearest sectioning content or sectioning root element. A footer typically contains information about the author of the section, copyright data.",
		},

		{
			Tag:         "form",
			Description: "The HTML <form> element represents a document section containing interactive controls for submitting information.",
			Attributes: []*pb.Attribute{
				{
					Key:         "accept-charset",
					Description: "Specifies the character encodings that are to be used for the form submission.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "action",
					Description: "Specifies where to send the form-data when a form is submitted. Only for type=\"submit\" and type=\"image\".",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "autocomplete",
					Description: "Indicates whether controls in this form can by default have their values automatically completed by the browser.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("on", "The browser is allowed to automatically complete the input. (Default)"),
						AttributeTypeChoice("off", "The browser must not automatically complete the input."),
					),
				},
				{
					Key:         "enctype",
					Description: "Defines the content type of the form data when the method is POST.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("application/x-www-form-urlencoded", "The default value if the attribute is not specified."),
						AttributeTypeChoice("multipart/form-data", "Use this value if you are using enctype that requires a file upload."),
						AttributeTypeChoice("text/plain", `Use this value if you are using a "text/plain" enctype and the form will not contain any file uploads.`),
					),
				},
				{
					Key:         "method",
					Description: "Defines which HTTP method to use when submitting the form. Can be GET (default) or POST.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("get", "The browser method to use when submitting the form. (Default)"),
						AttributeTypeChoice("post", "The browser method to use when submitting the form."),
					),
				},
				{
					Key:         "name",
					Description: "Name of the element. For example used by the server to identify the fields in form submits.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "novalidate",
					Description: "This Boolean attribute indicates that the form is not to be validated when submitted. If this attribute is not specified (and therefore the form is validated), this default setting can be overridden by a formnovalidate attribute on a <button>, <input type=\"submit\">, or <input type=\"image\"> element belonging to the form.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "target",
					Description: "Indicates where to display the response after submitting the form.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("_self", "Load the response into the same browsing context as the current one. This value is the default if the attribute is not specified."),
						AttributeTypeChoice("_blank", "Load the response into a new unnamed browsing context."),
						AttributeTypeChoice("_parent", "Load the response into the parent browsing context of the current one. If there is no parent, this option behaves the same way as _self."),
						AttributeTypeChoice("_top", "Load the response into the top-level browsing context (that is, the browsing context that is an ancestor of the current one, and has no parent). If there is no parent, this option behaves the same way as _self."),
					),
				},
			},
		},

		{
			Tag:         "h1",
			Description: "The HTML <h1>–<h6> elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.",
		},

		{
			Tag:         "h2",
			Description: "The HTML <h1>–<h6> elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.",
		},

		{
			Tag:         "h3",
			Description: "The HTML <h1>–<h6> elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.",
		},

		{
			Tag:         "h4",
			Description: "The HTML <h1>–<h6> elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.",
		},

		{
			Tag:         "h5",
			Description: "The HTML <h1>–<h6> elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.",
		},

		{
			Tag:         "h6",
			Description: "The HTML <h1>–<h6> elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.",
		},

		{
			Tag:         "head",
			Description: "The HTML <head> element contains machine-readable information (metadata) about the document, like its title, scripts, and style sheets.",
		},

		{
			Tag:         "header",
			Description: "The HTML <header> element represents introductory content, typically a group of introductory or navigational aids. It may contain some heading elements but also a logo, a search form, an author name, and other elements.",
		},

		{
			Tag:         "hgroup",
			Description: "The HTML <hgroup> element represents a multi-level heading for a section of a document. It groups a set of <h1>–<h6> elements.",
		},

		{
			Tag:         "hr",
			NoChildren:  true,
			Description: "The HTML <hr> element represents a thematic break between paragraph-level elements: for example, a change of scene in a story, or a shift of topic within a section.",
		},
		{
			Tag:         "html",
			Description: "The HTML <html> element represents the root (top-level element) of an HTML document, so it is also referred to as the root element. All other elements must be descendants of this element.",
		},

		{
			Tag:         "i",
			Description: "The HTML Bring Attention To element (<b>) is used to draw the reader's attention to the element's contents, which are not otherwise granted special importance. This was formerly known as the Boldface element, and most browsers still draw the text in boldface. However, you should not use <b> for styling text; instead, you should use the CSS font-weight property to create boldface text, or the <strong> element to indicate that text is of special importance.",
		},

		{
			Tag:         "iframe",
			Description: "The HTML Inline Frame element (<iframe>) represents a nested browsing context, embedding another HTML page into the current one.",
			Attributes: []*pb.Attribute{
				{
					Key:         "allow",
					Description: "Allows the iframe's contents to be treated as being from a different origin.",
					Type:        AttributeTypeCommaDelimited(),
				},
				{
					Key:         "allowfullscreen",
					Description: "Allows the iframe to be placed into full screen mode, and iframes are also allowed to use the Fullscreen API.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "allowpaymentrequest",
					Description: "Allows the iframe to use the PaymentRequest interface to make payment requests via the browser.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "height",
					Description: "The height of the frame in CSS pixels.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "name",
					Description: "The name of the frame.",
					Type:        AttributeTypeString(),
				},

				{
					Key:         "referrerpolicy",
					Description: "Specifies which referrer to send when fetching the resource. See Referrer-Policy for possible values and their effects.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("no-referrer", "The Referer header will not be sent."),
						AttributeTypeChoice("no-referrer-when-downgrade", "The Referer header will not be sent to origins without TLS (HTTPS)."),
						AttributeTypeChoice("origin", "The Referer header will be the origin of the page."),
						AttributeTypeChoice("origin-when-cross-origin", "The Referer header will be the origin of the page for same-origin requests, and the full URL for cross-origin requests."),
						AttributeTypeChoice("same-origin", "The Referer header will be sent for same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin", "The Referer header will be sent with same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin-when-cross-origin", "Send a full URL when performing a same-origin request, only send the origin of the document to a-priori as-much-secure destination (HTTPS->HTTPS), and send no header to a less secure destination (HTTPS->HTTP)."),
						AttributeTypeChoice("unsafe-url", "The Referer header will be sent with same-origin and cross-origin requests."),
					),
				},
				{
					Key:         "sandbox",
					Description: "Enables a set of extra restrictions on any content hosted by the iframe.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("", "Treats the content as being from a unique origin."),
						AttributeTypeChoice("allow-forms", "Allows form submission."),
						AttributeTypeChoice("allow-modals", "Lets the resource open modal windows."),
						AttributeTypeChoice("allow-orientation-lock", "Lets the resource lock the screen orientation."),
						AttributeTypeChoice("allow-pointer-lock", "Lets the resource use the Pointer Lock API."),
						AttributeTypeChoice("allow-popups", "Lets the resource open new windows."),
						AttributeTypeChoice("allow-popups-to-escape-sandbox", "Lets the resource open new windows without inheriting the sandboxing."),
						AttributeTypeChoice("allow-presentation", "Lets the resource start a presentation session."),
						AttributeTypeChoice("allow-same-origin", "Lets the resource be treated as being from the same origin as the current document."),
						AttributeTypeChoice("allow-scripts", "Lets the resource run scripts (but not create pop-up windows)."),
						AttributeTypeChoice("allow-top-navigation", "Lets the iframe navigate the top-level browsing context."),
					),
				},
				{
					Key:         "src",
					Description: "The URL of the page to embed.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "srcdoc",
					Description: "A document to render in the iframe.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: "The width of the frame in CSS pixels.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "img",
			NoChildren:  true,
			Description: "The HTML <img> element embeds an image into the document.",
			Attributes: []*pb.Attribute{
				{
					Key:         "alt",
					Description: "The text alternative of the element's content.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "crossorigin",
					Description: "How the element handles crossorigin requests.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("", "Anonymous usage. Send no cookies and no TLS certificate (if applicable)."),
						AttributeTypeChoice("anonymous", "Anonymous usage. Send no cookies and no TLS certificate (if applicable)."),
						AttributeTypeChoice("use-credentials", "Send cookies and a TLS certificate (if applicable)."),
					),
				},
				{
					Key:         "height",
					Description: "The height of the image in pixels.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "ismap",
					Description: "Indicates that the image is part of a server-side image map.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "loading",
					Description: "Indicates how the browser should load the image.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("auto", "The default lazy-loading behavior."),
						AttributeTypeChoice("eager", "Hint to the browser that the image should be loaded immediately."),
						AttributeTypeChoice("lazy", "Hint to the browser that the image can be loaded lazily, after the rest of the page content is loaded."),
					),
				},
				{
					Key:         "longdesc",
					Description: "A URL to a detailed description of the image.",
					Type:        AttributeTypeString(),
				},

				{
					Key:         "referrerpolicy",
					Description: "Specifies which referrer to send when fetching the resource. See Referrer-Policy for possible values and their effects.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("no-referrer", "The Referer header will not be sent."),
						AttributeTypeChoice("no-referrer-when-downgrade", "The Referer header will not be sent to origins without TLS (HTTPS)."),
						AttributeTypeChoice("origin", "The Referer header will be the origin of the page."),
						AttributeTypeChoice("origin-when-cross-origin", "The Referer header will be the origin of the page for same-origin requests, and the full URL for cross-origin requests."),
						AttributeTypeChoice("same-origin", "The Referer header will be sent for same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin", "The Referer header will be sent with same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin-when-cross-origin", "Send a full URL when performing a same-origin request, only send the origin of the document to a-priori as-much-secure destination (HTTPS->HTTPS), and send no header to a less secure destination (HTTPS->HTTP)."),
						AttributeTypeChoice("unsafe-url", "The Referer header will be sent with same-origin and cross-origin requests."),
					),
				},
				{
					Key:         "sizes",
					Description: "A set of source sizes.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "src",
					Description: "The image URL.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "srcset",
					Description: "A list of one or more strings separated by commas indicating a set of possible image sources for the user agent to use.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "usemap",
					Description: "The <map> element id to use as an image map.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: "The width of the image in pixels.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "input",
			NoChildren:  true,
			Description: "The HTML <input> element is used to create interactive controls for web-based forms in order to accept data from the user; a wide variety of types of input data and control widgets are available, depending on the device and user agent.",
			Attributes: []*pb.Attribute{
				{
					Key:         "accept",
					Description: "Hint for expected file type in file upload controls.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "alt",
					Description: "Alternative text in case an image can't be displayed.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "autocomplete",
					Description: "Hint for form autofill feature.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("on", "The browser is allowed to automatically complete the input. (Default)"),
						AttributeTypeChoice("off", "The browser must not automatically complete the input."),
					),
				},
				{
					Key:         "autofocus",
					Description: "Automatically focus the form control when the page is loaded.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "checked",
					Description: "Whether the command or control is checked.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "dirname",
					Description: "Name of form field to use for sending the element's directionality in form submission.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "disabled",
					Description: "Whether the form control is disabled.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "form",
					Description: "Associates the control with a form element.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "formaction",
					Description: "URL to use for form submission.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "formenctype",
					Description: "Form data set encoding type to use for form submission.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("application/x-www-form-urlencoded", "The default value if the attribute is not specified."),
						AttributeTypeChoice("multipart/form-data", "Use this value if you are using an enctype that requires a file upload."),
						AttributeTypeChoice("text/plain", `Use this value if you are using a "text/plain" enctype and the form will not contain any file uploads.`),
					),
				},
				{
					Key:         "formmethod",
					Description: "HTTP method to use for form submission.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("post", "The data from the form is included in the body of the HTTP request when sent to the server."),
						AttributeTypeChoice("get", "The data from the form are appended to the form attribute URI, with a '?' as a separator, and the resulting URI is sent to the server. Use this method when the form has no side-effects and contains only ASCII characters."),
						AttributeTypeChoice("dialog", "When the form is inside a <dialog>, closes the dialog on submission."),
					),
				},
				{
					Key:         "formnovalidate",
					Description: "Bypass form control validation for form submission.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "formtarget",
					Description: "Browsing context for form submission.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("_self", "Load the response into the same browsing context as the current one. This value is the default if the attribute is not specified."),
						AttributeTypeChoice("_blank", "Load the response into a new unnamed browsing context."),
						AttributeTypeChoice("_parent", "Load the response into the parent browsing context of the current one. If there is no parent, this option behaves the same way as _self."),
						AttributeTypeChoice("_top", "Load the response into the top-level browsing context (that is, the browsing context that is an ancestor of the current one, and has no parent). If there is no parent, this option behaves the same way as _self."),
					),
				},
				{
					Key:         "height",
					Description: "Height of the image in pixels.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "list",
					Description: "Identifies a list of pre-defined options to suggest to the user.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "max",
					Name:        "maxStr",
					Description: `maximum value of an <input> element with type="number" or type="range".`,
					Type:        AttributeTypeString(),
				},

				{
					Key:         "max",
					Description: `the maximum value of an <input> element with type="number" or type="range".`,
					Type:        AttributeTypeNumber(),
				},

				{
					Key:         "maxlength",
					Description: `maximum number of characters (as UTF-16 code units) the user can enter into an <input> element. This must be an integer value 0 or higher. If no maxlength is specified, or an invalid value is specified, the input has no maximum length. This value must also be greater than or equal to the value of minlength.`,
					Type:        AttributeTypeInt(),
				},

				{
					Key:         "min",
					Name:        "minStr",
					Description: `the minimum value of an <input> element with type="number" or type="range".`,
					Type:        AttributeTypeString(),
				},

				{
					Key:         "min",
					Description: `minimum value of an <input> element with type="number" or type="range".`,
					Type:        AttributeTypeNumber(),
				},

				{
					Key:         "minlength",
					Description: `the minimum number of characters (as UTF-16 code units) the user can enter into an <input> or <textarea> element. This must be an integer value 0 or higher. If no minlength is specified, or an invalid value is specified, the <input> or <textarea> has no minimum length. This value must also be less than or equal to the value of maxlength.`,
					Type:        AttributeTypeInt(),
				},

				{
					Key:         "multiple",
					Description: "Whether to allow multiple values.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "name",
					Description: "Name of the element to use for form submission and in the form.elements API.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "pattern",
					Description: "Pattern to be matched by the form control's value.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "placeholder",
					Description: "User-visible label to be placed within the form control.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "readonly",
					Description: "Whether to allow the value to be edited by the user.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "required",
					Description: "Whether the control is required for form submission.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "size",
					Description: "Size of the control.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "src",
					Description: "Address of the resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "step",
					Description: "Granularity to be matched by the form control's value.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: "Type of form control.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("button", "A push button with no default behavior."),
						AttributeTypeChoice("checkbox", "A check box allowing single values to be selected/deselected."),
						AttributeTypeChoice("color", "A control for specifying a color. A color picker's UI has no required features other than accepting simple colors as text (more info)."),
						AttributeTypeChoice("date", "A control for entering a date (year, month, and day, with no time)."),
						AttributeTypeChoice("datetime-local", "A control for entering a date and time, with no time zone."),
						AttributeTypeChoice("email", "A field for editing an e-mail address."),
						AttributeTypeChoice("file", "A control that lets the user select a file. Use the accept attribute to define the types of files that the control can select."),
						AttributeTypeChoice("hidden", "A control that is not displayed but whose value is submitted to the server."),
						AttributeTypeChoice("image", "A graphical submit button. You must use the src attribute to define the source of the image and the alt attribute to define alternative text."),
						AttributeTypeChoice("month", "A control for entering a month and year, with no time zone."),
						AttributeTypeChoice("number", "A control for entering a number."),
						AttributeTypeChoice("password", "A single-line text field whose value is obscured. Use the maxlength and minlength attributes to specify the maximum length of the value that can be entered."),
						AttributeTypeChoice("radio", "A radio button, allowing a single value to be selected out of multiple choices with the same name value."),
						AttributeTypeChoice("range", "A control for entering a number whose exact value is not important."),
						AttributeTypeChoice("reset", "A button that resets the contents of the form to default values."),
						AttributeTypeChoice("search", "A single-line text field for entering search strings. Line-breaks are automatically removed from the input value."),
						AttributeTypeChoice("submit", "A button that submits the form."),
						AttributeTypeChoice("tel", "A control for entering a telephone number."),
						AttributeTypeChoice("text", "A single-line text field. Line-breaks are automatically removed from the input value."),
						AttributeTypeChoice("time", "A control for entering a time value with no time zone."),
						AttributeTypeChoice("url", "A field for entering a URL."),
						AttributeTypeChoice("week", "A control for entering a date consisting of a week-year number and a week number with no time zone."),
					),
				},
				{
					Key:         "value",
					Description: "Value of the form control.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: "Width of the image in pixels.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "ins",
			Description: "The HTML <ins> element represents a range of text that has been added to a document.",
			Attributes: []*pb.Attribute{
				{
					Key:         "cite",
					Description: "Contains a URI which points to the source of the quote or change.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "datetime",
					Description: "Indicates the date and time associated with the element.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "kbd",
			Description: "The HTML Keyboard Input element (<kbd>) represents a span of inline text denoting textual user input from a keyboard, voice input, or any other text entry device.",
		},

		{
			Tag:         "label",
			Description: "The HTML <label> element represents a caption for an item in a user interface.",
			Attributes: []*pb.Attribute{
				{
					Key:         "for",
					Description: "Describes elements which belongs to this one.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "form",
					Description: "Specifies the form that is the owner of the element.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "legend",
			Description: "The HTML <legend> element represents a caption for the content of its parent <fieldset>.",
		},

		{
			Tag:         "li",
			Description: "The HTML <li> element is used to represent an item in a list.",
			Attributes: []*pb.Attribute{
				{
					Key:         "value",
					Description: "Ordinal value of the list item.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "link",
			NoChildren:  true,
			Description: "The HTML External Resource Link element (<link>) specifies relationships between the current document and an external resource. This element is most commonly used to link to stylesheets, but is also used to establish site icons (both \"favicon\" style icons and icons for the home screen and apps on mobile devices) among other things.",
			Attributes: []*pb.Attribute{
				{
					Key:         "as",
					Description: "Indicates the type of content being loaded by the link target.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("audio", "Indicates that the linked resource is intended to be played back on an audio-only device."),
						AttributeTypeChoice("document", "Indicates that the linked resource is intended to be shown in a way that is conceptually distinct from the main body of the document."),
						AttributeTypeChoice("embed", "Indicates that the linked resource is intended to be shown by an external application or plugin, like a calculator."),
						AttributeTypeChoice("fetch", "Indicates that the linked resource is intended to be used to prefetch the resource it leads to (e.g., a link to an article in a web-based version of a newspaper)."),
						AttributeTypeChoice("font", "Indicates that the linked resource is intended to be used to load fonts."),
						AttributeTypeChoice("image", "Indicates that the linked resource is intended to be shown as an image or is used as an image mask."),
						AttributeTypeChoice("object", "Indicates that the linked resource is intended to be used to load a plugin or app."),
						AttributeTypeChoice("script", "Indicates that the linked resource is intended to be run as a web application."),
						AttributeTypeChoice("style", "Indicates that the linked resource is intended to be used as a part of a style sheet."),
						AttributeTypeChoice("track", "Indicates that the linked resource is intended to be used as a track (a sequence of media data) in a media element such as a video or audio element)."),
						AttributeTypeChoice("video", "Indicates that the linked resource is intended to be shown as a video or is used as a video mask."),
						AttributeTypeChoice("worker", "Indicates that the linked resource is intended to be used as a worker."),
					),
				},
				{
					Key:         "crossorigin",
					Description: "How the element handles crossorigin requests.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("", "Anonymous usage. Send no cookies and no TLS certificate (if applicable)."),
						AttributeTypeChoice("anonymous", "Anonymous usage. Send no cookies and no TLS certificate (if applicable)."),
						AttributeTypeChoice("use-credentials", "Send cookies and a TLS certificate (if applicable)."),
					),
				},
				{
					Key:         "href",
					Description: "Address of the hyperlink.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "hreflang",
					Description: "Specifies the language of the linked resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "integrity",
					Description: "Security Feature that allows browsers to verify what they fetch.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "media",
					Description: "Specifies a hint of the media for which the linked resource was designed.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "referrerpolicy",
					Description: "Specifies which referrer to send when fetching the resource. See Referrer-Policy for possible values and their effects.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("no-referrer", "The Referer header will not be sent."),
						AttributeTypeChoice("no-referrer-when-downgrade", "The Referer header will not be sent to origins without TLS (HTTPS)."),
						AttributeTypeChoice("origin", "The Referer header will be the origin of the page."),
						AttributeTypeChoice("origin-when-cross-origin", "The Referer header will be the origin of the page for same-origin requests, and the full URL for cross-origin requests."),
						AttributeTypeChoice("same-origin", "The Referer header will be sent for same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin", "The Referer header will be sent with same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin-when-cross-origin", "Send a full URL when performing a same-origin request, only send the origin of the document to a-priori as-much-secure destination (HTTPS->HTTPS), and send no header to a less secure destination (HTTPS->HTTP)."),
						AttributeTypeChoice("unsafe-url", "The Referer header will be sent with same-origin and cross-origin requests."),
					),
				},
				{
					Key:         "rel",
					Description: "Specifies the relationship of the target object to the link object.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "sizes",
					Description: "Sizes of the icons (for rel=\"icon\").",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: "Specifies the MIME type of the linked resource.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "main",
			Description: "The HTML <main> element represents the dominant content of the <body> of a document. The main content area consists of content that is directly related to or expands upon the central topic of a document, or the central functionality of an application.",
		},

		{
			Tag:         "map",
			Description: "The HTML <map> element is used with <area> elements to define an image map (a clickable link area).",
			Attributes: []*pb.Attribute{
				{
					Key:         "name",
					Description: "Name of the element to use as a target.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "mark",
			Description: "The HTML Mark Text element (<mark>) represents text which is marked or highlighted for reference or notation purposes, due to the marked passage's relevance or importance in the enclosing context.",
		},

		{
			Tag:         "menu",
			Description: "The HTML <menu> element represents a group of commands that a user can perform or activate. This includes both list menus, which might appear across the top of a screen, as well as context menus, such as those that might appear underneath a button after it has been clicked.",
			Attributes: []*pb.Attribute{
				{
					Key:         "type",
					Description: "Indicates the kind of menu.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("list", "Represents a list of commands."),
						AttributeTypeChoice("context", "Represents a context menu."),
						AttributeTypeChoice("toolbar", "Represents a toolbar."),
					),
				},
			},
		},

		{
			Tag:         "meta",
			NoChildren:  true,
			Description: "The HTML <meta> element represents metadata that cannot be represented by other HTML meta-related elements, like <base>, <link>, <script>, <style> or <title>.",
			Attributes: []*pb.Attribute{
				{
					Key:         "charset",
					Description: "Declares the document's character encoding.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "content",
					Description: "Gives the value associated with the http-equiv or name attribute.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "http-equiv",
					Description: "Provides an HTTP header for the information/value of the content attribute.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "name",
					Description: "Specifies a name for the metadata.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "meter",
			Description: "The HTML <meter> element represents either a scalar value within a known range or a fractional value.",
			Attributes: []*pb.Attribute{
				{
					Key:         "high",
					Description: "Indicates the range's upper bound.",
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "low",
					Description: "Indicates the range's lower bound.",
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "max",
					Description: "Indicates the maximum value allowed.",
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "min",
					Description: "Indicates the minimum value allowed.",
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "optimum",
					Description: "Indicates the optimal numeric value.",
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "value",
					Description: "Current numeric value.",
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "nav",
			Description: "The HTML <nav> element represents a section of a page whose purpose is to provide navigation links, either within the current document or to other documents. Common examples of navigation sections are menus, tables of contents, and indexes.",
		},

		{
			Tag:         "noscript",
			Description: "The HTML <noscript> element defines a section of HTML to be inserted if a script type on the page is unsupported or if scripting is currently turned off in the browser.",
		},

		{
			Tag:         "object",
			Description: "The HTML <object> element represents an external resource, which can be treated as an image, a nested browsing context, or a resource to be handled by a plugin.",
			Attributes: []*pb.Attribute{
				{
					Key:         "data",
					Description: "Address of the resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "form",
					Description: "Associates the control with a form element.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "height",
					Description: "Height of the element.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "name",
					Description: "Name of the element to use for form submission and in the form.elements API.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: "Type of embedded resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "typemustmatch",
					Description: "Whether the type attribute and the Content-Type value need to match for the resource to be used.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "usemap",
					Description: "Name of image map to use.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: "Width of the element.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "ol",
			Description: "The HTML <ol> element represents an ordered list of items, typically rendered as a numbered list.",
			Attributes: []*pb.Attribute{
				{
					Key:         "reversed",
					Description: "Number the list backwards.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "start",
					Description: "Starting value of the list.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "type",
					Description: "Kind of list marker.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("1", "Numbers (default)"),
						AttributeTypeChoice("a", "Lowercase letters"),
						AttributeTypeChoice("A", "Uppercase letters"),
						AttributeTypeChoice("i", "Lowercase roman numerals"),
						AttributeTypeChoice("I", "Uppercase roman numerals"),
					),
				},
			},
		},

		{
			Tag:         "optgroup",
			Description: "The HTML <optgroup> element creates a grouping of options within a <select> element.",
			Attributes: []*pb.Attribute{
				{
					Key:         "disabled",
					Description: "Whether the form control is disabled.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "label",
					Description: "User-visible label to give the option group a caption.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "option",
			Description: "The HTML <option> element is used to define an item contained in a <select>, an <optgroup>, or a <datalist> element. As such, <option> can represent menu items in popups and other lists of items in an HTML document.",
			Attributes: []*pb.Attribute{
				{
					Key:         "disabled",
					Description: "Whether the form control is disabled.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "label",
					Description: "User-visible label to give the option a caption.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "selected",
					Description: "Whether the option is selected by default.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "value",
					Description: "Value to be used for form submission.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "output",
			Description: "The HTML <output> element represents the result of a calculation or user action.",
			Attributes: []*pb.Attribute{
				{
					Key:         "for",
					Description: "Specifies controls from which the output was calculated.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "form",
					Description: "Associates the control with a form element.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "name",
					Description: "Name of the element to use for form submission and in the form.elements API.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "p",
			Description: "The HTML <p> element represents a paragraph.",
		},

		{
			Tag:         "param",
			NoChildren:  true,
			Description: "The HTML <param> element defines parameters for an <object> element.",
			Attributes: []*pb.Attribute{
				{
					Key:         "name",
					Description: "Name of the parameter.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "value",
					Description: "Value of the parameter.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "pre",
			Description: "The HTML <pre> element represents preformatted text which is to be presented exactly as written in the HTML file. The text is typically rendered using a non-proportional (monospace) font. Whitespace inside this element is displayed as written.",
		},

		{
			Tag:         "progress",
			Description: "The HTML <progress> element displays an indicator showing the completion progress of a task, typically displayed as a progress bar.",
			Attributes: []*pb.Attribute{
				{
					Key:         "max",
					Description: "Upper bound of range.",
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "value",
					Description: "Current value of the element.",
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "q",
			Description: "The HTML <q> element indicates that the enclosed text is a short inline quotation. This element is intended for short quotations that don't require paragraph breaks; for long quotations use the <blockquote> element.",
			Attributes: []*pb.Attribute{
				{
					Key:         "cite",
					Description: "Contains a URI which points to the source of the quote or change.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "ruby",
			Description: "The HTML <ruby> element represents a ruby annotation. Ruby annotations are for showing pronunciation of East Asian characters.",
		},

		{
			Tag:         "rb",
			Description: "The HTML <rb> element marks the base text component of a ruby annotation, which is used to provide pronunciation, translation, or transliteration information for East Asian typography. It is often used in conjunction with the <rt> element for pronunciation, and the <rp> element to provide parentheses around the ruby text for browsers that do not support ruby annotations.",
		},

		{
			Tag:         "rp",
			Description: "The HTML <rp> element is used to provide fall-back parentheses for browsers that do not support display of ruby annotations using the <ruby> element.",
		},

		{
			Tag:         "rt",
			Description: "The HTML <rt> element embraces pronunciation of characters presented in a ruby annotations, which are used to describe the pronunciation of East Asian characters. This element is always used inside a <ruby> element.",
		},

		{
			Tag:         "rtc",
			Description: "The HTML <rtc> element embraces semantic annotations of characters presented in a ruby of <rb> elements used inside of <ruby> element. <rb> elements can have both pronunciation (<rt>) and semantic (<rtc>) annotations.",
		},

		{
			Tag:         "s",
			Description: "The HTML <s> element renders text with a strikethrough, or a line through it. Use the <s> element to represent things that are no longer relevant or no longer accurate. However, <s> is not appropriate when indicating document edits; for that, use the <del> and <ins> elements, as appropriate.",
		},

		{
			Tag:         "samp",
			Description: "The HTML <samp> element is used to enclose inline text which represents sample (or quoted) output from a computer program.",
		},

		{
			Tag:         "script",
			Description: "The HTML <script> element is used to embed or reference executable code; this is typically used to embed or refer to JavaScript code.",
			Attributes: []*pb.Attribute{
				{
					Key:         "async",
					Description: "Execute script when available, without blocking.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "crossorigin",
					Description: "How the element handles crossorigin requests.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("", "Anonymous usage. Send no cookies and no TLS certificate (if applicable)."),
						AttributeTypeChoice("anonymous", "Anonymous usage. Send no cookies and no TLS certificate (if applicable)."),
						AttributeTypeChoice("use-credentials", "Send cookies and a TLS certificate (if applicable)."),
					),
				},
				{
					Key:         "defer",
					Description: "Defer script execution.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "integrity",
					Description: "Subresource integrity.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "language",
					Description: "Type of script.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "nomodule",
					Description: "Prevents execution in user agents that support module scripts.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "nonce",
					Description: "Cryptographic nonce used in Content Security Policy checks [CSP]",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "referrerpolicy",
					Description: "Specifies which referrer to send when fetching the resource. See Referrer-Policy for possible values and their effects.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("no-referrer", "The Referer header will not be sent."),
						AttributeTypeChoice("no-referrer-when-downgrade", "The Referer header will not be sent to origins without TLS (HTTPS)."),
						AttributeTypeChoice("origin", "The Referer header will be the origin of the page."),
						AttributeTypeChoice("origin-when-cross-origin", "The Referer header will be the origin of the page for same-origin requests, and the full URL for cross-origin requests."),
						AttributeTypeChoice("same-origin", "The Referer header will be sent for same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin", "The Referer header will be sent with same-origin requests, but cross-origin requests will contain no Referer header."),
						AttributeTypeChoice("strict-origin-when-cross-origin", "Send a full URL when performing a same-origin request, only send the origin of the document to a-priori as-much-secure destination (HTTPS->HTTPS), and send no header to a less secure destination (HTTPS->HTTP)."),
						AttributeTypeChoice("unsafe-url", "The Referer header will be sent with same-origin and cross-origin requests."),
					),
				},
				{
					Key:         "src",
					Description: "Address of the resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: "Type of embedded resource.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "s",
			Description: "The HTML <s> element renders text with a strikethrough, or a line through it. Use the <s> element to represent things that are no longer relevant or no longer accurate. However, <s> is not appropriate when indicating document edits; for that, use the <del> and <ins> elements, as appropriate.",
		},

		{
			Tag:         "section",
			Description: "The HTML <section> element represents a standalone section — which doesn't have a more specific semantic element to represent it — contained within an HTML document. Typically, but not always, sections have a heading.",
		},

		{
			Tag:         "select",
			Description: "The HTML <select> element represents a control that provides a menu of options:",
			Attributes: []*pb.Attribute{
				{
					Key:         "autocomplete",
					Description: "Hint for form autofill feature.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("on", "The browser is allowed to automatically complete the input. (Default)"),
						AttributeTypeChoice("off", "The browser must not automatically complete the input."),
					),
				},
				{
					Key:         "disabled",
					Description: "Whether the form control is disabled.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "form",
					Description: "Associates the control with a form element.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "multiple",
					Description: "Whether to allow multiple values.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "name",
					Description: "Name of the element to use for form submission and in the form.elements API.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "required",
					Description: "Whether the control is required for form submission.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "size",
					Description: "Number of options to show.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "slot",
			Description: "The HTML <slot> element—part of the Web Components technology suite—is a placeholder inside a web component that you can fill with your own markup, which lets you create separate DOM trees and present them together.",
			Attributes: []*pb.Attribute{
				{
					Key:         "name",
					Description: "The name of the slot to assign the enclosed markup (and its descendants) to.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "small",
			Description: "The HTML <small> element makes the text font size one size smaller (for example, from large to medium, or from small to x-small) down to the browser's minimum font size. In HTML5, this element is repurposed to represent side-comments and small print, including copyright.",
		},

		{
			Tag:         "source",
			NoChildren:  true,
			Description: "The HTML <source> element specifies multiple media resources for the <picture>, the <audio> element, or the <video> element. It is an empty element. It is commonly used to serve the same media content in multiple formats supported by different browsers.",
			Attributes: []*pb.Attribute{
				{
					Key:         "media",
					Description: "Specifies the intended media type of the media resource, to help the browser determine if it can be played.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "sizes",
					Description: "Specifies the size of the linked resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "src",
					Description: "The URL of the media resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "srcset",
					Description: "A list of one or more strings separated by commas indicating a set of possible image sources for the user agent to use.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: "Specifies the MIME type of the linked resource.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "span",
			Description: `The <span> HTML element is a generic inline container for phrasing content, which does not inherently represent anything. It can be used to group elements for styling purposes (using the class or id attributes), or because they share attribute values, such as lang. It should be used only when no other semantic element is appropriate. <span> is very much like a <div> element, but <div> is a block-level element whereas a <span> is an inline-level element.`,
		},

		{
			Tag:         "strike",
			Description: "The HTML <strike> element (or HTML Strikethrough Element) places a strikethrough (horizontal line) over text.",
		},

		{
			Tag:         "strong",
			Description: "The HTML Strong Importance Element (<strong>) indicates that its contents have strong importance, seriousness, or urgency. Browsers typically render the contents in bold type.",
		},

		{
			Tag:         "style",
			Description: "The HTML <style> element contains style information for a document, or part of a document. By default, the style instructions written inside that element are expected to be CSS.",
			Attributes: []*pb.Attribute{
				{
					Key:         "media",
					Description: "Specifies what media/device the media resource is optimized for.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "nonce",
					Description: "Cryptographic nonce used in Content Security Policy checks [CSP]",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: "Type of embedded resource.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "sub",
			Description: "The HTML <sub> element defines a span of text that should be displayed, for typographic reasons, lower, and often smaller, than the main span of text.",
		},

		{
			Tag:         "summary",
			Description: "The HTML Disclosure Summary element (<summary>) element specifies a summary, caption, or legend for a <details> element's disclosure box. Clicking the <summary> element toggles the state of the parent <details> element open and closed.",
		},

		{
			Tag:         "sup",
			Description: "The HTML <sup> element defines a span of text that should be displayed, for typographic reasons, higher, and often smaller, than the main span of text.",
		},

		{
			Tag:         "table",
			Description: "The HTML <table> element represents tabular data — that is, information presented in a two-dimensional table comprised of rows and columns of cells containing data.",
			Attributes: []*pb.Attribute{
				{
					Key:         "border",
					Description: "Controls whether to show cell borders.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "tbody",
			Description: "The HTML <tbody> element groups one or more <tr> elements as the body of a <table> element.",
		},

		{
			Tag:         "td",
			Description: "The HTML <td> element defines a cell of a table that contains data. It participates in the table model.",
			Attributes: []*pb.Attribute{
				{
					Key:         "colspan",
					Description: "Number of columns that the cell is to span.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "headers",
					Description: "Specifies one or more header cells a cell is related to.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "rowspan",
					Description: "Number of rows that the cell is to span.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "textarea",
			Description: `The HTML <textarea> element represents a multi-line plain-text editing control, useful when you want to allow users to enter a sizeable amount of free-form text, for example a comment on a review or feedback form.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "autocapitalize",
					Description: "Controls whether and how text input is automatically capitalized as it is entered/edited by the user.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("off", "No autocapitalization is applied (all letters default to lowercase)."),
						AttributeTypeChoice("none", "No autocapitalization is applied (all letters default to lowercase)."),
						AttributeTypeChoice("on", "Text input is automatically capitalized following the rules of the current language."),
						AttributeTypeChoice("sentences", "Text input is automatically capitalized following the rules of the current language for sentence capitalization."),
						AttributeTypeChoice("words", "Text input is automatically capitalized following the rules of the current language for word capitalization."),
						AttributeTypeChoice("characters", "Text input is automatically capitalized following the rules of the current language for character capitalization."),
					),
				},
				{
					Key:         "autocomplete",
					Description: "Hint for form autofill feature.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("on", "The browser is allowed to automatically complete the input. (Default)"),
						AttributeTypeChoice("off", "The browser must not automatically complete the input."),
					),
				},
				{
					Key:         "autofocus",
					Description: "Automatically focus the form control when the page is loaded.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "cols",
					Description: "Visible width of the text control, in average character widths.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "dirname",
					Description: "Name of form field to use for sending the element's directionality in form submission.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "disabled",
					Description: "Whether the form control is disabled.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "form",
					Description: "Associates the control with a form element.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "maxlength",
					Description: "Maximum length of value.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "minlength",
					Description: "Minimum length of value.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "name",
					Description: "Name of the element to use for form submission and in the form.elements API.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "placeholder",
					Description: "User-visible label to give the user an idea of what to type.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "readonly",
					Description: "Whether to allow the value to be edited by the user.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "required",
					Description: "Whether the control is required for form submission.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "rows",
					Description: "Visible number of lines in the control.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "spellcheck",
					Description: "Whether the element is to have its spelling and grammar checked.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("true", "Spelling and grammar check is performed."),
						AttributeTypeChoice("false", "Spelling and grammar check is not performed."),
						AttributeTypeChoice("default", "Spelling and grammar check is performed according to the element's parent setting."),
					),
				},
				{
					Key:         "wrap",
					Description: "How the value of the form control is to be wrapped for form submission.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("hard", "The browser automatically inserts line breaks (CR+LF) so that each line has no more than the width of the control."),
						AttributeTypeChoice("soft", "The browser ensures that all line breaks in the value consist of a CR+LF pair, but does not insert any additional line breaks."),
					),
				},
			},
		},

		{
			Tag:         "tfoot",
			Description: "The HTML <tfoot> element defines a set of rows summarizing the columns of the table.",
		},

		{
			Tag:         "th",
			Description: "The HTML <th> element defines a cell as header of a group of table cells. The exact nature of this group is defined by the scope and headers attributes.",
			Attributes: []*pb.Attribute{
				{
					Key:         "abbr",
					Description: "Alternative label to use for the header cell when referencing the cell in other contexts.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "colspan",
					Description: "Number of columns that the cell is to span.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "headers",
					Description: "Specifies one or more header cells a cell is related to.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "rowspan",
					Description: "Number of rows that the cell is to span.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "scope",
					Description: "Specifies which cells the header cell applies to.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("col", "Applies to all cells in the column."),
						AttributeTypeChoice("colgroup", "Applies to all cells in the column group."),
						AttributeTypeChoice("row", "Applies to all cells in the row."),
						AttributeTypeChoice("rowgroup", "Applies to all cells in the row group."),
					),
				},
			},
		},

		{
			Tag:         "thead",
			Description: "The HTML <thead> element defines a set of rows defining the head of the columns of the table.",
		},

		{
			Tag:         "time",
			Description: "The HTML <time> element represents either a time on a 24-hour clock or a precise date in the Gregorian calendar (with optional time and timezone information).",
			Attributes: []*pb.Attribute{
				{
					Key:         "datetime",
					Description: "Machine-readable value.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "title",
			Description: "The HTML <title> element defines the document's title that is shown in a browser's title bar or a page's tab. It only contains text; tags within the element are ignored.",
		},

		{
			Tag:         "tr",
			Description: "The HTML <tr> element defines a row of cells in a table. The row's cells can then be established using a mix of <td> (data cell) and <th> (header cell) elements.",
		},

		{
			Tag:         "track",
			NoChildren:  true,
			Description: "The HTML <track> element is used as a child of the media elements—<audio> and <video>. It lets you specify timed text tracks (or time-based data), for example to automatically handle subtitles. The tracks are formatted in WebVTT format (.vtt files) — Web Video Text Tracks or Timed Text Markup Language (TTML).",
			Attributes: []*pb.Attribute{
				{
					Key:         "default",
					Description: "Enables the track if set to true.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "kind",
					Description: "Specifies the kind of text track.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("captions", "Chapter titles, etc."),
						AttributeTypeChoice("chapters", "Chapter titles, etc."),
						AttributeTypeChoice("descriptions", "Chapter titles, etc."),
						AttributeTypeChoice("metadata", "Chapter titles, etc."),
						AttributeTypeChoice("subtitles", "Chapter titles, etc."),
					),
				},
				{
					Key:         "label",
					Description: "Specifies a user-readable title of the text track.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "src",
					Description: "Address of the resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "srclang",
					Description: "Language of the text track.",
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "u",
			Description: "The HTML <u> element renders text with an underline, a line under the baseline of its content. In HTML5, this element represents a span of text with an unarticulated, though explicitly rendered, non-textual annotation, such as labeling the text as being a proper name in Chinese text (a Chinese proper name mark), or labeling the text as being misspelled.",
		},

		{
			Tag:         "ul",
			Description: "The HTML <ul> element represents an unordered list of items, typically rendered as a bulleted list.",
			Attributes: []*pb.Attribute{
				{
					Key:         "type",
					Description: "Kind of list marker.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("disc", "A filled circle, default."),
						AttributeTypeChoice("circle", "A circle with an empty center."),
						AttributeTypeChoice("square", "A filled square."),
					),
				},
			},
		},

		{
			Tag:         "var",
			Description: "The HTML <var> element represents a variable in a mathematical expression or a programming context.",
		},

		{
			Tag:         "video",
			Description: "The HTML <video> element is used to embed video content.",
			Attributes: []*pb.Attribute{
				{
					Key:         "autoplay",
					Description: "The video should play as soon as possible.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "controls",
					Description: "Show user agent controls.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "crossorigin",
					Description: "How the element handles crossorigin requests.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("", "Anonymous usage. Send no cookies and no TLS certificate (if applicable)."),
						AttributeTypeChoice("anonymous", "Anonymous usage. Send no cookies and no TLS certificate (if applicable)."),
						AttributeTypeChoice("use-credentials", "Send cookies and a TLS certificate (if applicable)."),
					),
				},
				{
					Key:         "height",
					Description: "Vertical dimension.",
					Type:        AttributeTypeInt(),
				},
				{
					Key:         "loop",
					Description: "Whether to loop the media resource.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "muted",
					Description: "Whether to mute the media resource by default.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "playsinline",
					Description: "Encourage the user agent to display video content within the element's playback area.",
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "poster",
					Description: "Poster frame to show prior to video playback.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "preload",
					Description: "Hints how much buffering the media resource will likely need.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("auto", "Hints to the user agent that the user agent can choose its own value."),
						AttributeTypeChoice("metadata", "Hints to the user agent that the user agent can choose its own value."),
						AttributeTypeChoice("none", "Hints to the user agent that the user agent can choose its own value."),
					),
				},
				{
					Key:         "src",
					Description: "Address of the resource.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: "Horizontal dimension.",
					Type:        AttributeTypeInt(),
				},
			},
		},

		{
			Tag:         "wbr",
			NoChildren:  true,
			Description: "The HTML <wbr> element represents a word break opportunity—a position within text where the browser may optionally break a line, though its line-breaking rules would not otherwise create a break at that location.",
		},
	},
}

var MathML = &pb.Namespace{
	Name:        "mathml",
	Description: `This MathML Core specification intends to address these issues by being as accurate as possible on the visual rendering of mathematical formulas using additional rules from the TeXBook’s Appendix G [TEXBOOK] and from the Open Font Format [OPEN-FONT-FORMAT], [OPEN-TYPE-MATH-ILLUMINATED]. It also relies on modern browser implementations and web technologies [HTML] [SVG] [CSS2] [DOM], clarifying interactions with them when needed or introducing new low-level primitives to improve the web platform layering.`,
	Prefix:      "MathML",
	Attributes: []*pb.Attribute{
		{
			Key:         "class",
			Description: "Assigns a class name or set of class names to an element. You may assign the same class name or names to any number of elements. If you specify multiple class names, they must be separated by whitespace characters.",
			Type:        AttributeTypeSpaceDelimited(),
		},
		{
			Key:         "dir",
			Description: "This attribute specifies the text directionality of the element, merely indicating what direction the text flows when surrounded by text with inherent directionality (such as Arabic or Hebrew). Possible values are ltr (left-to-right) and rtl (right-to-left).",
			Type: AttributeTypeChoices(
				AttributeTypeChoice("ltr", "left-to-right"),
				AttributeTypeChoice("rtl", "right-to-left"),
			),
		},
		{
			Key:         "displaystyle",
			Description: "This attribute specifies whether the element should be rendered using displaystyle rules or not. Possible values are true and false.",
			Type: AttributeTypeChoices(
				AttributeTypeChoice("true", "displaystyle rules"),
				AttributeTypeChoice("false", "not displaystyle rules"),
			),
		},
		{
			Key:         "id",
			Description: "This attribute assigns a name to an element. This name must be unique in a document.",
			Type:        AttributeTypeString(),
		},
		{
			Key:         "mathbackground",
			Description: "This attribute specifies the background color of the element. Possible values are a color name or a color specification in the format defined in the CSS3 Color Module [CSS3COLOR].",
			Type:        AttributeTypeString(),
		},
		{
			Key:         "mathcolor",
			Description: "This attribute specifies the color of the element. Possible values are a color name or a color specification in the format defined in the CSS3 Color Module [CSS3COLOR].",
			Type:        AttributeTypeString(),
		},
		{
			Key:         "mathsize",
			Name:        "mathsizeStr",
			Description: "This attribute specifies the size of the element. Possible values are a dimension or a dimensionless number.",
			Type:        AttributeTypeString(),
		},
		{
			Key:         "mathsize",
			Description: "This attribute specifies the size of the element. Possible values are a dimension or a dimensionless number.",
			Type:        AttributeTypeInt(),
		},
		{
			Key:         "nonce",
			Description: "This attribute declares a cryptographic nonce (number used once) that should be used by the server processing the element’s submission, and the resulting resource must be delivered with a Content-Security-Policy nonce attribute matching the value of the nonce attribute.",
			Type:        AttributeTypeString(),
		},
		{
			Key:         "scriptlevel",
			Description: "This attribute specifies the script level of the element. Possible values are an integer between 0 and 7, inclusive.",
			Type:        AttributeTypeInt(),
		},
		{
			Key:         "style",
			Description: "This attribute offers advisory information about the element for which it is set.",
			Type:        AttributeTypeKVColonSemicolon(),
		},
		{
			Key:         "tabindex",
			Description: "This attribute specifies the position of the current element in the tabbing order for the current document. This value must be a number between 0 and 32767. User agents should ignore leading zeros.",
			Type:        AttributeTypeInt(),
		},
	},
	Elements: []*pb.Element{
		{
			Tag:         "annotation",
			Description: "This element is used to include comments or annotations within a MathML expression. It can be used to provide additional information about the expression, or to include comments for the author of the expression.",
			Attributes: []*pb.Attribute{
				{
					Key:         "encoding",
					Description: "This attribute specifies the encoding used for the text content of the element. Possible values are text/plain, text/html, and application/x-tex.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("text/plain", ""),
						AttributeTypeChoice("text/html", ""),
						AttributeTypeChoice("application/x-tex", ""),
					),
				},
				{
					Key:         "name",
					Description: "This attribute specifies the name of the annotation.",
					Type:        AttributeTypeString(),
				},
			},
		},
		{
			Tag:         "annotation-xml",
			Description: "This element is used to include comments or annotations within a MathML expression. It can be used to provide additional information about the expression, or to include comments for the author of the expression.",
			Attributes: []*pb.Attribute{
				{
					Key:         "encoding",
					Description: "This attribute specifies the encoding used for the text content of the element. Possible values are text/plain, text/html, and application/x-tex.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("text/plain", ""),
						AttributeTypeChoice("text/html", ""),
						AttributeTypeChoice("application/x-tex", ""),
					),
				},
				{
					Key:         "name",
					Description: "This attribute specifies the name of the annotation.",
					Type:        AttributeTypeString(),
				},
			},
		},
		{
			Tag:         "maction",
			Description: "This element is used to specify the behavior of a subexpression when it is activated by the user. The action can be to toggle the visibility of the subexpression, or to toggle the selection of the subexpression, or to execute a script.",
			Attributes: []*pb.Attribute{
				{
					Key:         "actiontype",
					Description: "This attribute specifies the type of action performed when the element is activated. Possible values are toggle, statusline, tooltip, and script.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("toggle", ""),
						AttributeTypeChoice("statusline", ""),
						AttributeTypeChoice("tooltip", ""),
						AttributeTypeChoice("script", ""),
					),
				},
				{
					Key:         "selection",
					Description: "This attribute specifies the type of selection performed when the element is activated. Possible values are none, highlight, and unhighlight.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", ""),
						AttributeTypeChoice("highlight", ""),
						AttributeTypeChoice("unhighlight", ""),
					),
				},
			},
		},
		{
			Tag:         "math",
			Description: "This element is the root element of a MathML expression. It is used to identify the document as a MathML document, and to specify the namespaces used in the document.",
			Attributes: []*pb.Attribute{
				{
					Key:         "xmlns",
					Description: "This attribute specifies the default namespace for elements and attributes in the document. Possible values are http://www.w3.org/1998/Math/MathML and http://www.w3.org/1999/xhtml.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("http://www.w3.org/1998/Math/MathML", ""),
						AttributeTypeChoice("http://www.w3.org/1999/xhtml", ""),
					),
				},
				{
					Key:         "xmlns:m",
					Description: "This attribute specifies the namespace for elements and attributes in the document whose names start with the letter m. Possible values are http://www.w3.org/1998/Math/MathML and http://www.w3.org/1999/xhtml.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("http://www.w3.org/1998/Math/MathML", ""),
						AttributeTypeChoice("http://www.w3.org/1999/xhtml", ""),
					),
				},
				{
					Key:         "xmlns:xlink",
					Description: "This attribute specifies the namespace for elements and attributes in the document whose names start with the letters xlink. Possible values are http://www.w3.org/1999/xlink and http://www.w3.org/1999/xhtml.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("http://www.w3.org/1999/xlink", ""),
						AttributeTypeChoice("http://www.w3.org/1999/xhtml", ""),
					),
				},
				{
					Key:         "xmlns:xml",
					Description: "This attribute specifies the namespace for elements and attributes in the document whose names start with the letters xml. Possible values are http://www.w3.org/XML/1998/namespace and http://www.w3.org/1999/xhtml.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("http://www.w3.org/XML/1998/namespace", ""),
						AttributeTypeChoice("http://www.w3.org/1999/xhtml", ""),
					),
				},
			},
		},
		{
			Tag:         "merror",
			Description: `This element is used to indicate that an error has occurred while processing a MathML expression. It can be used to display an error message, or to highlight the error in the expression.`,
		},
		{
			Tag:         "mfrac",
			Description: "This element is used to display a fraction.",
			Attributes: []*pb.Attribute{
				{
					Key:         "bevelled",
					Description: "This attribute specifies whether the fraction line is to be drawn straight or to beveled. Possible values are true and false.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("true", ""),
						AttributeTypeChoice("false", ""),
					),
				},
			},
		},
		{
			Tag:         "mi",
			Description: "This element is used to display a single identifier or a single operator.",
			Attributes: []*pb.Attribute{
				{
					Key:         "mathvariant",
					Description: "This attribute specifies the variant form of the character. Possible values are normal, bold, italic, bold-italic, double-struck, bold-fraktur, script, bold-script, fraktur, sans-serif, bold-sans-serif, sans-serif-italic, sans-serif-bold-italic, monospace, initial, and tailed.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("normal", ""),
						AttributeTypeChoice("bold", ""),
						AttributeTypeChoice("italic", ""),
						AttributeTypeChoice("bold-italic", ""),
						AttributeTypeChoice("double-struck", ""),
						AttributeTypeChoice("bold-fraktur", ""),
						AttributeTypeChoice("script", ""),
						AttributeTypeChoice("bold-script", ""),
						AttributeTypeChoice("fraktur", ""),
						AttributeTypeChoice("sans-serif", ""),
						AttributeTypeChoice("bold-sans-serif", ""),
						AttributeTypeChoice("sans-serif-italic", ""),
						AttributeTypeChoice("sans-serif-bold-italic", ""),
						AttributeTypeChoice("monospace", ""),
						AttributeTypeChoice("initial", ""),
						AttributeTypeChoice("tailed", ""),
					),
				},
			},
		},
		{
			Tag:         "mmultiscripts",
			Description: "This element is used to display a base expression with multiple subscripts and superscripts.",
		},
		{
			Tag:         "mn",
			Description: "This element is used to display a single number.",
		},
		{
			Tag:         "mo",
			Description: "This element is used to display a single operator.",
			Attributes: []*pb.Attribute{
				{
					Key:         "fence",
					Description: "This attribute specifies whether the operator is to be rendered as a fence. Possible values are true and false.",
					Type: AttributeTypeChoices(
						AttributeTypeChoice("true", ""),
						AttributeTypeChoice("false", ""),
					),
				},
				{
					Key:         "lspace",
					Description: "This attribute specifies the minimum amount of space that should be left on the left side of the operator. Possible values are a dimension or a dimensionless number.",
					Type:        AttributeTypeString(),
				},
				{
					Key:         "rspace",
					Description: "This attribute specifies the minimum amount of space that should be left on the right side of the operator. Possible values are a dimension or a dimensionless number.",
					Type:        AttributeTypeString(),
				},
			},
		},
		{
			Tag:         "mover",
			Description: "This element is used to display an expression with an overbar.",
		},
		{
			Tag:         "mpadded",
			Description: "This element is used to display an expression with additional spacing.",
		},
		{
			Tag:         "mphantom",
			Description: "This element is used to display an expression without rendering it.",
		},
		{
			Tag:         "mprescripts",
			Description: "This element is used to display a base expression with multiple subscripts and superscripts.",
		},
		{
			Tag:         "mroot",
			Description: "This element is used to display an expression with a radical.",
		},
		{
			Tag:         "mrow",
			Description: "This element is used to display a sequence of expressions.",
		},
		{
			Tag:         "ms",
			Description: "This element is used to display a single character or a single number.",
		},
		{
			Tag:         "mspace",
			Description: "This element is used to display a space.",
		},
		{
			Tag:         "msqrt",
			Description: "This element is used to display an expression with a radical.",
		},
		{
			Tag:         "mstyle",
			Description: "This element is used to specify the style of a subexpression.",
		},
		{
			Tag:         "msub",
			Description: "This element is used to display a subscript expression.",
		},
		{
			Tag:         "msubsup",
			Description: "This element is used to display a subscript expression with a superscript expression.",
		},
		{
			Tag:         "msup",
			Description: "This element is used to display a superscript expression.",
		},
		{
			Tag:         "mtable",
			Description: "This element is used to display a table of expressions.",
		},
		{
			Tag:         "mtd",
			Description: "This element is used to display a cell in a table.",
		},
		{
			Tag:         "mtext",
			Description: "This element is used to display text.",
		},
		{
			Tag:         "mtr",
			Description: "This element is used to display a row in a table.",
		},
		{
			Tag:         "munder",
			Description: "This element is used to display an expression with an underbar.",
		},
		{
			Tag:         "munderover",
			Description: "This element is used to display an expression with both an underbar and an overbar.",
		},
		{
			Tag:         "semantics",
			Description: "This element is used to specify the meaning of a MathML expression.",
		},
	},
}

var SVG = &pb.Namespace{
	Name:        "svg",
	Description: `Scalable Vector Graphics (SVG) is an XML-based markup language for describing two-dimensional based vector graphics. As such, it's a text-based, open Web standard for describing images that can be rendered cleanly at any size and are designed specifically to work well with other web standards including CSS, DOM, JavaScript, and SMIL. SVG is, essentially, to graphics what HTML is to text. SVG images and their related behaviors are defined in XML text files, which means they can be searched, indexed, scripted, and compressed. Additionally, this means they can be created and edited with any text editor or with drawing software. Compared to classic bitmapped image formats such as JPEG or PNG, SVG-format vector images can be rendered at any size without loss of quality and can be easily localized by updating the text within them, without the need of a graphical editor to do so. With proper libraries, SVG files can even be localized on-the-fly.`,
	Prefix:      "SVG",
	Attributes: []*pb.Attribute{
		{
			Key:         "id",
			Description: "Specifies a unique id for an element",
			Type:        AttributeTypeString(),
		},
		{
			Key:         "class",
			Description: "Specifies one or more classnames for an element (refers to a class in a style sheet)",
			Type:        AttributeTypeSpaceDelimited(),
		},
		{
			Key:         "style",
			Description: "Specifies an inline CSS style for an element",
			Type:        AttributeTypeKVColonSemicolon(),
		},
	},
	Elements: []*pb.Element{
		{
			Tag:         "a",
			Description: `The <a> SVG element creates a hyperlink to other web pages, files, locations in the same page, email addresses, or any other URL. It is very similar to HTML's <a> element. SVG's <a> element is a container, which means you can create a link around text (like in HTML) but also around any shape.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "download",
					Description: `Indicates that the hyperlink is to be used for downloading a resource. When used together with the download attribute, the value of the attribute is used as the file name of the downloaded file. There are no restrictions on allowed values, though / and \ will be converted to underscores and leading spaces in filenames will be removed.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "href",
					Description: `The URL of a linked resource.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "hreflang",
					Description: `Specifies the language of the linked resource.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "ping",
					Description: `A space-separated list of URLs. When the link is followed, the browser should send POST requests with the body PING to the URLs. Typically for tracking.`,
					Type:        AttributeTypeSpaceDelimited(),
				},
				{
					Key:         "referrerpolicy",
					Description: `Referrer policy to use when fetching the resource.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("no-referrer", `The Referer header will not be sent.`),
						AttributeTypeChoice("no-referrer-when-downgrade", `The Referer header will not be sent to origins without TLS (HTTPS).`),
						AttributeTypeChoice("origin", `The Referer header will contain the origin of the request.`),
						AttributeTypeChoice("origin-when-cross-origin", `The Referer header will contain the origin of the request, unless it is a cross-origin request, in which case it will be omitted entirely.`),
						AttributeTypeChoice("same-origin", `The Referer header will contain the origin of the request, unless it is a cross-origin request, in which case it will be omitted entirely.`),
						AttributeTypeChoice("strict-origin", `The Referer header will contain the origin of the request, unless it is a cross-origin request, in which case it will be omitted entirely.`),
						AttributeTypeChoice("strict-origin-when-cross-origin", `The Referer header will contain the origin of the request, unless it is a cross-origin request, in which case it will be omitted entirely.`),
						AttributeTypeChoice("unsafe-url", `The Referer header will contain the origin of the request, unless it is a cross-origin request, in which case it will be omitted entirely.`),
					),
				},
				{
					Key:         "rel",
					Description: `Specifies the relationship of the target object to the link object.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("alternate", `Links to an alternate version of the document (i.e. print page, translated or mirror).`),
						AttributeTypeChoice("author", `Links to the author of the document.`),
						AttributeTypeChoice("bookmark", `Permanent URL used for bookmarking.`),
						AttributeTypeChoice("canonical", `Helps prevent duplicate content issues.`),
						AttributeTypeChoice("dns-prefetch", `Specifies that the browser should preemptively perform DNS resolution for the target resource's origin.`),
						AttributeTypeChoice("external", `Links to an external resource (an external stylesheet).`),
						AttributeTypeChoice("help", `Links to a help document.`),
						AttributeTypeChoice("icon", `Imports an icon to represent the document.`),
						AttributeTypeChoice("license", `Links to a license associated with the document.`),
						AttributeTypeChoice("manifest", `Specifies the location of a manifest file or an entry point for a web application.`),
						AttributeTypeChoice("me", `Links to a resource that is the primary topic of the document.`),
						AttributeTypeChoice("modulepreload", `Specifies that the target resource should be preemptively fetched and cached by the browser for later use.`),
						AttributeTypeChoice("next", `The next document in a selection.`),
						AttributeTypeChoice("nofollow", `Links to an unendorsed document, like a paid link. ("nofollow" is used by Google, to specify that the Google search spider should not follow that link.)`),
						AttributeTypeChoice("noopener", `Specifies that the browser should not open the linked document in a new tab or window.`),
						AttributeTypeChoice("noreferrer", `Specifies that the browser should not send a HTTP referer header if the user follows the hyperlink.`),
						AttributeTypeChoice("opener", `Specifies that the target URL should be opened in a top-level browsing context (that is, in the current tab or window).`),
						AttributeTypeChoice("pingback", `Links to the Pingback server of the current document.`),
						AttributeTypeChoice("preload", `Specifies that the target resource should be loaded immediately.`),
						AttributeTypeChoice("prev", `The previous document in a selection.`),
						AttributeTypeChoice("privacy-policy", `Links to a privacy policy document associated with the current document.`),
						AttributeTypeChoice("search", `Links to a search tool for the document.`),
						AttributeTypeChoice("stylesheet", `Links to an external style sheet.`),
						AttributeTypeChoice("tag", `A tag (keyword) for the current document.`),
						AttributeTypeChoice("terms-of-service", `Links to the terms of service document for the current document.`),
					),
				},
				{
					Key:         "target",
					Description: `Specifies where to display the linked resource.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("_self", `Default. Opens the document in the same frame as it was clicked.`),
						AttributeTypeChoice("_blank", `Opens the document in a new window or tab.`),
						AttributeTypeChoice("_parent", `Opens the document in the parent frame.`),
						AttributeTypeChoice("_top", `Opens the document in the full body of the window.`),
						AttributeTypeChoice("framename", `Opens the document in a named frame.`),
					),
				},
				{
					Key:         "type",
					Description: `Specifies the MIME type of the linked resource.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "animate",
			Description: `The <animate> SVG element is used to animate an attribute or property of an element over time.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "accumulate",
					Description: `Controls whether or not the animation is cumulative.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", `The animation is not cumulative. Each iteration starts over from the beginning.`),
						AttributeTypeChoice("sum", `The animation is cumulative. Each iteration the animation picks up where it left off in the previous iteration.`),
					),
				},
				{
					Key:         "additive",
					Description: `Controls whether or not the animation is additive.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("replace", `The animation is not additive. The animation replaces the underlying value.`),
						AttributeTypeChoice("sum", `The animation is additive. The animation adds to the underlying value.`),
					),
				},
				{
					Key:         "attributeName",
					Description: `The name of the attribute to animate.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "attributeType",
					Description: `The namespace of the attribute to animate.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("auto", `If the attribute is a presentation attribute, the animation will use the target element's corresponding baseVal. If the attribute is not a presentation attribute, the animation will use the target element's corresponding animVal.`),
						AttributeTypeChoice("CSS", `The animation will use the CSS namespace.`),
						AttributeTypeChoice("XML", `The animation will use the XML namespace.`),
						AttributeTypeChoice("XMLID", `The animation will use the XML ID namespace.`),
						AttributeTypeChoice("XMLLANG", `The animation will use the XML LANG namespace.`),
						AttributeTypeChoice("XMLSPACE", `The animation will use the XML SPACE namespace.`),
					),
				},
				{
					Key:         "begin",
					Description: `Defines when the animation should begin.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "by",
					Description: `Defines a relative offset value for the animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "calcMode",
					Description: `Defines the pacing of the animation.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("discrete", `The animation is not paced. Each iteration of the animation is displayed as fast as possible.`),
						AttributeTypeChoice("linear", `The animation is paced such that it takes the same amount of time to go from the start value to the end value throughout the animation.`),
						AttributeTypeChoice("paced", `The animation is paced according to a cubic function.`),
						AttributeTypeChoice("spline", `The animation is paced according to a cubic function, but with easing at both the start and end.`),
					),
				},
				{
					Key:         "dur",
					Description: `Defines the duration of the animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "end",
					Description: `Defines when the animation should end.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "fill",
					Description: `Defines the fill behavior for the animation.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("freeze", `The animation will hold the attribute value when the animation ends.`),
						AttributeTypeChoice("remove", `The animation will remove the attribute value when the animation ends.`),
					),
				},
				{
					Key:         "from",
					Description: `Defines the initial value of the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "keySplines",
					Description: `Defines the values for a cubic Bézier function that controls interval pacing.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "keyTimes",
					Description: `Defines when the animation should take place in terms of time fractions.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "max",
					Description: `Defines the maximum value allowed for the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "min",
					Description: `Defines the minimum value allowed for the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "repeatCount",
					Description: `Defines the number of times the animation should repeat.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "repeatDur",
					Description: `Defines the duration for repeating an animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "restart",
					Description: `Defines if an animation should restart after it completes.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("always", `The animation will restart indefinitely.`),
						AttributeTypeChoice("never", `The animation will not restart after it completes.`),
						AttributeTypeChoice("whenNotActive", `The animation will restart after it completes if the animation is not currently active.`),
					),
				},
				{
					Key:         "to",
					Description: `Defines the ending value of the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "values",
					Description: `Defines a list of discrete values to interpolate.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "animateMotion",
			Description: `The <animateMotion> SVG element is used to animate a transformation attribute on a target element, thereby allowing the animation of translation, rotation, and scaling.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "accumulate",
					Description: `Controls whether or not the animation is cumulative.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", `The animation is not cumulative. Each iteration starts over from the beginning.`),
						AttributeTypeChoice("sum", `The animation is cumulative. Each iteration the animation picks up where it left off in the previous iteration.`),
					),
				},
				{
					Key:         "additive",
					Description: `Controls whether or not the animation is additive.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("replace", `The animation is not additive. The animation replaces the underlying value.`),
						AttributeTypeChoice("sum", `The animation is additive. The animation adds to the underlying value.`),
					),
				},
				{
					Key:         "begin",
					Description: `Defines when the animation should begin.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "by",
					Description: `Defines a relative offset value for the animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "calcMode",
					Description: `Defines the pacing of the animation.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("discrete", `The animation is not paced. Each iteration of the animation is displayed as fast as possible.`),
						AttributeTypeChoice("linear", `The animation is paced such that it takes the same amount of time to go from the start value to the end value throughout the animation.`),
						AttributeTypeChoice("paced", `The animation is paced according to a cubic function.`),
						AttributeTypeChoice("spline", `The animation is paced according to a cubic function, but with easing at both the start and end.`),
					),
				},
				{
					Key:         "dur",
					Description: `Defines the duration of the animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "end",
					Description: `Defines when the animation should end.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "fill",
					Description: `Defines the fill behavior for the animation.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("freeze", `The animation will hold the attribute value when the animation ends.`),
						AttributeTypeChoice("remove", `The animation will remove the attribute value when the animation ends.`),
					),
				},
				{
					Key:         "from",
					Description: `Defines the initial value of the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "keySplines",
					Description: `Defines the values for a cubic Bézier function that controls interval pacing.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "keyTimes",
					Description: `Defines when the animation should take place in terms of time fractions.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "max",
					Description: `Defines the maximum value allowed for the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "min",
					Description: `Defines the minimum value allowed for the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "repeatCount",
					Description: `Defines the number of times the animation should repeat.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "repeatDur",
					Description: `Defines the duration for repeating an animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "restart",
					Description: `Defines if an animation should restart after it completes.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("always", `The animation will restart indefinitely.`),
						AttributeTypeChoice("never", `The animation will not restart after it completes.`),
						AttributeTypeChoice("whenNotActive", `The animation will restart after it completes if the animation is not currently active.`),
					),
				},
				{
					Key:         "to",
					Description: `Defines the ending value of the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "values",
					Description: `Defines a list of discrete values to interpolate.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "animateTransform",
			Description: `The <animateTransform> SVG element animates a transformation attribute on a target element, thereby allowing animations to control translation, scaling, rotation and/or skewing.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "accumulate",
					Description: `Controls whether or not the animation is cumulative.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", `The animation is not cumulative. Each iteration starts over from the beginning.`),
						AttributeTypeChoice("sum", `The animation is cumulative. Each iteration the animation picks up where it left off in the previous iteration.`),
					),
				},
				{
					Key:         "additive",
					Description: `Controls whether or not the animation is additive.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("replace", `The animation is not additive. The animation replaces the underlying value.`),
						AttributeTypeChoice("sum", `The animation is additive. The animation adds to the underlying value.`),
					),
				},
				{
					Key:         "attributeName",
					Description: `The name of the attribute to animate.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "attributeType",
					Description: `The namespace of the attribute to animate.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("auto", `If the attribute is a presentation attribute, the animation will use the target element's corresponding baseVal. If the attribute is not a presentation attribute, the animation will use the target element's corresponding animVal.`),
						AttributeTypeChoice("CSS", `The animation will use the CSS namespace.`),
						AttributeTypeChoice("XML", `The animation will use the XML namespace.`),
						AttributeTypeChoice("XMLID", `The animation will use the XML ID namespace.`),
						AttributeTypeChoice("XMLLANG", `The animation will use the XML LANG namespace.`),
						AttributeTypeChoice("XMLSPACE", `The animation will use the XML SPACE namespace.`),
					),
				},
				{
					Key:         "begin",
					Description: `Defines when the animation should begin.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "by",
					Description: `Defines a relative offset value for the animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "calcMode",
					Description: `Defines the pacing of the animation.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("discrete", `The animation is not paced. Each iteration of the animation is displayed as fast as possible.`),
						AttributeTypeChoice("linear", `The animation is paced such that it takes the same amount of time to go from the start value to the end value throughout the animation.`),
						AttributeTypeChoice("paced", `The animation is paced according to a cubic function.`),
						AttributeTypeChoice("spline", `The animation is paced according to a cubic function, but with easing at both the start and end.`),
					),
				},
				{
					Key:         "dur",
					Description: `Defines the duration of the animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "end",
					Description: `Defines when the animation should end.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "fill",
					Description: `Defines the fill behavior for the animation.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("freeze", `The animation will hold the attribute value when the animation ends.`),
						AttributeTypeChoice("remove", `The animation will remove the attribute value when the animation ends.`),
					),
				},
				{
					Key:         "from",
					Description: `Defines the initial value of the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "keySplines",
					Description: `Defines the values for a cubic Bézier function that controls interval pacing.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "keyTimes",
					Description: `Defines when the animation should take place in terms of time fractions.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "max",
					Description: `Defines the maximum value allowed for the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "min",
					Description: `Defines the minimum value allowed for the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "repeatCount",
					Description: `Defines the number of times the animation should repeat.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "repeatDur",
					Description: `Defines the duration for repeating an animation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "restart",
					Description: `Defines if an animation should restart after it completes.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("always", `The animation will restart indefinitely.`),
						AttributeTypeChoice("never", `The animation will not restart after it completes.`),
						AttributeTypeChoice("whenNotActive", `The animation will restart after it completes if the animation is not currently active.`),
					),
				},
				{
					Key:         "to",
					Description: `Defines the ending value of the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: `Defines which transform to use.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("rotate", `The animation will use the rotate transform.`),
						AttributeTypeChoice("scale", `The animation will use the scale transform.`),
						AttributeTypeChoice("translate", `The animation will use the translate transform.`),
					),
				},
				{
					Key:         "values",
					Description: `Defines a list of discrete values to interpolate.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "circle",
			Description: `The <circle> SVG element is an SVG basic shape, used to create circles based on a center point and a radius.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "cx",
					Description: `The x-axis coordinate of the center of the circle.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "cy",
					Description: `The y-axis coordinate of the center of the circle.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "r",
					Description: `The radius of the circle.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "clipPath",
			Description: `The <clipPath> SVG element defines a clipping path. A clipping path is used/referenced using the clip-path property.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "clipPathUnits",
					Description: `The coordinate system for the contents of the <clipPath> element.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The contents of the <clipPath> element represent values in the current user coordinate system.`),
						AttributeTypeChoice("objectBoundingBox", `The contents of the <clipPath> element represent values in the coordinate system that results from taking the current user coordinate system in place at the time when the <clipPath> element is referenced (i.e., the user coordinate system for the element referencing the <clipPath> element via a clip-path property).`),
					),
				},
			},
		},

		{
			Tag:         "defs",
			Description: `The <defs> SVG element is used to embed definitions that can be reused inside an SVG image.`,
		},

		{
			Tag:         "desc",
			Description: `The <desc> SVG element provides a description container for SVG content.`,
		},

		{
			Tag:         "ellipse",
			Description: `The <ellipse> SVG element is an SVG basic shape, used to create ellipses based on a center coordinate, and both their x and y radius.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "cx",
					Description: `The x-axis coordinate of the center of the ellipse.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "cy",
					Description: `The y-axis coordinate of the center of the ellipse.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "rx",
					Description: `The x-axis radius of the ellipse.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "ry",
					Description: `The y-axis radius of the ellipse.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feBlend",
			Description: `The <feBlend> SVG filter primitive composes two objects together ruled by a certain blending mode. This is similar to what is known from image editing software when blending two layers. The mode is defined by the mode attribute.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `Input for the blending.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "in2",
					Description: `Second input for the blending.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "mode",
					Description: `The mode used to blend the two inputs together.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("normal", `The input image is placed over the backdrop image, then the parts of the input image that are outside the backdrop are discarded.`),
						AttributeTypeChoice("multiply", `The input image is multiplied by the backdrop image.`),
						AttributeTypeChoice("screen", `Multiplies the complements of the backdrop and input image color values, then complements the result.`),
						AttributeTypeChoice("darken", `Selects the darker of the backdrop and input image pixels.`),
						AttributeTypeChoice("lighten", `Selects the lighter of the backdrop and input image pixels.`),
					),
				},
			},
		},

		{
			Tag:         "feColorMatrix",
			Description: `The <feColorMatrix> SVG filter element changes colors based on a transformation matrix. Every pixel's color value (represented by an [R,G,B,A] vector) is matrix multiplied to create a new color.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "type",
					Description: `The type of matrix operation.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("matrix", `The type of matrix operation.`),
						AttributeTypeChoice("saturate", `The type of matrix operation.`),
						AttributeTypeChoice("hueRotate", `The type of matrix operation.`),
						AttributeTypeChoice("luminanceToAlpha", `The type of matrix operation.`),
					),
				},
				{
					Key:         "values",
					Description: `The list of one or more numbers that represent the matrix.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "feComponentTransfer",
			Description: `The <feComponentTransfer> SVG filter primitive performs color-component-wise remapping of data for each pixel. It allows operations like brightness adjustment, contrast adjustment, color balance or thresholding.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "feComposite",
			Description: `The <feComposite> SVG filter primitive performs the combination of two input images pixel-wise in image space using one of the Porter-Duff compositing operations: over, in, atop, out, xor.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `Input for the compositing operation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "in2",
					Description: `Second input for the compositing operation.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "operator",
					Description: `The type of compositing operation.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("over", `The source image is composited over the destination image.`),
						AttributeTypeChoice("in", `The part of the source image that lies inside of the destination image is composited over the destination image.`),
						AttributeTypeChoice("out", `The part of the source image that lies outside of the destination image is composited over the destination image.`),
						AttributeTypeChoice("atop", `The part of the source image that lies inside of the destination image is composited over the destination image and replaces the destination image.`),
						AttributeTypeChoice("xor", `The part of the source image that lies outside of the destination image is composited over the destination image.`),
						AttributeTypeChoice("arithmetic", `A standard arithmetic operator is applied (`),
					),
				},
				{
					Key:         "k1",
					Description: `First value to use in the arithmetic operation.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "k2",
					Description: `Second value to use in the arithmetic operation.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "k3",
					Description: `Third value to use in the arithmetic operation.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "k4",
					Description: `Fourth value to use in the arithmetic operation.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feConvolveMatrix",
			Description: `The <feConvolveMatrix> SVG filter primitive applies a matrix convolution filter effect.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "order",
					Description: `The number of cells in each dimension for 'kernelMatrix'`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "kernelMatrix",
					Description: `A list of numbers that make up the kernel matrix for the convolution.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "divisor",
					Description: `The divisor attribute specifies the value by which to divide the result of applying the convolution operator.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "bias",
					Description: `The bias attribute shifts the range of the filter. After applying the matrix operation, this bias value is added to each component.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "targetX",
					Description: `The targetX attribute determines the positioning in X of the convolution matrix relative to a given target pixel in the input image.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "targetY",
					Description: `The targetY attribute determines the positioning in Y of the convolution matrix relative to a given target pixel in the input image.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "edgeMode",
					Description: `The edgeMode attribute determines how to extend the input image as necessary with color values so that the matrix operations can be applied when the kernel is positioned at or near the edge of the input image.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("duplicate", `The input image is extended along each of its borders as necessary by duplicating the color values at the given edge of the input image.`),
						AttributeTypeChoice("wrap", `The input image is extended by taking the component values from the opposite edge of the image.`),
						AttributeTypeChoice("none", `Any values outside the input image are assumed to be transparent black.`),
					),
				},
				{
					Key:         "kernelUnitLength",
					Description: `The kernelUnitLength attribute defines the intended distance in current filter units (i.e., units as determined by the value of attribute 'primitiveUnits') for dx and dy in the surface normal calculation formulas.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "preserveAlpha",
					Description: `The preserveAlpha attribute indicates how the convolution will handle the alpha channel of the input image.`,
					Type:        AttributeTypeBool(),
				},
			},
		},

		{
			Tag:         "feDiffuseLighting",
			Description: `The <feDiffuseLighting> SVG filter primitive lights an image using the alpha channel as a bump map. The resulting image, which is an RGBA opaque image, depends on the light color, light position and surface geometry of the input bump map.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "surfaceScale",
					Description: `The 'surfaceScale' attribute indicates the height of the surface when the alpha channel is 1.0.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "diffuseConstant",
					Description: `The diffuseConstant attribute represents the proportion of the light that is reflected by the surface.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "kernelUnitLength",
					Description: `The kernelUnitLength attribute defines the intended distance in current filter units (i.e., units as determined by the value of attribute 'primitiveUnits') for dx and dy in the surface normal calculation formulas.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "feDisplacementMap",
			Description: `The <feDisplacementMap> SVG filter primitive uses the pixel values from the image from in2 to spatially displace the image from in.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "in2",
					Description: `The displacement map. This attribute can take on the same values as the 'in' attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "scale",
					Description: `The scale attribute defines the maximum value for the in2 displacement. A value of 0 disables the effect of the displacement map.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "xChannelSelector",
					Description: `The xChannelSelector attribute indicates which color channel from in2 to use to displace the pixels in in the horizontal direction.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("R", `The red channel of in2 is used to displace the x coordinate of each pixel.`),
						AttributeTypeChoice("G", `The green channel of in2 is used to displace the x coordinate of each pixel.`),
						AttributeTypeChoice("B", `The blue channel of in2 is used to displace the x coordinate of each pixel.`),
						AttributeTypeChoice("A", `The alpha channel of in2 is used to displace the x coordinate of each pixel.`),
					),
				},
				{
					Key:         "yChannelSelector",
					Description: `The yChannelSelector attribute indicates which color channel from in2 to use to displace the pixels in in the vertical direction.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("R", `The red channel of in2 is used to displace the y coordinate of each pixel.`),
						AttributeTypeChoice("G", `The green channel of in2 is used to displace the y coordinate of each pixel.`),
						AttributeTypeChoice("B", `The blue channel of in2 is used to displace the y coordinate of each pixel.`),
						AttributeTypeChoice("A", `The alpha channel of in2 is used to displace the y coordinate of each pixel.`),
					),
				},
			},
		},

		{
			Tag:         "feDistantLight",
			Description: `The <feDistantLight> SVG filter primitive defines a distant light source that can be used within a lighting filter primitive: <feDiffuseLighting> or <feSpecularLighting>`,
			Attributes: []*pb.Attribute{
				{
					Key:         "azimuth",
					Description: `The azimuth attribute represent the direction vector of the light source in the XY plane (clockwise), in degrees from the x axis.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "elevation",
					Description: `The elevation attribute represent the direction vector of the light source perpendicular to the XY plane, in degrees from the XY plane towards the z axis (clockwise).`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feDropShadow",
			Description: `The <feDropShadow> filter primitive creates a drop shadow of the input image. It is a shorthand filter, and is defined in terms of the <feGaussianBlur> and <feOffset> filter primitives.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "dx",
					Description: `The amount of offset in the x direction. If the <length> is 0, the shadow is placed at the same position as the input.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "dy",
					Description: `The amount of offset in the y direction. If the <length> is 0, the shadow is placed at the same position as the input.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "stdDeviation",
					Description: `The standard deviation for the blur operation. If two <numbers> are provided, the first number represents a standard deviation value along the x-axis of the coordinate system established by attribute 'primitiveUnits' on the <filter> element. The second value represents a standard deviation in Y. If one number is provided, then that value is used for both X and Y. Negative values are not allowed. A value of zero disables the effect of the given filter primitive (i.e., the result is a transparent black image).`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "flood-color",
					Description: `The flood-color attribute indicates what color to use to flood the current filter primitive subregion defined through the <feFlood> element. If attribute 'flood-color' is not specified, then the effect is as if a value of black were specified.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "flood-opacity",
					Description: `The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion defined through the <feFlood> element.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feFlood",
			Description: `The <feFlood> SVG filter primitive fills the filter subregion with the color and opacity defined by flood-color and flood-opacity.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "flood-color",
					Description: `The flood-color attribute indicates what color to use to flood the current filter primitive subregion defined through the <feFlood> element. If attribute 'flood-color' is not specified, then the effect is as if a value of black were specified.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "flood-opacity",
					Description: `The flood-opacity attribute indicates the opacity value to use across the current filter primitive subregion defined through the <feFlood> element.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feFuncA",
			Description: `The <feFuncA> SVG filter primitive defines the transfer function for the alpha component of the input graphic of its parent <feComponentTransfer> element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "type",
					Description: `The type of transfer function.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("identity", `The type of transfer function.`),
						AttributeTypeChoice("table", `The type of transfer function.`),
						AttributeTypeChoice("discrete", `The type of transfer function.`),
						AttributeTypeChoice("linear", `The type of transfer function.`),
						AttributeTypeChoice("gamma", `The type of transfer function.`),
					),
				},
				{
					Key:         "tableValues",
					Description: `Contains the list of <number>s that define the lookup table. Values must be in the 0-1 range and be equally spaced. There must be at least two values.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "slope",
					Description: `The slope attribute indicates the slope of the linear function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "intercept",
					Description: `The intercept attribute indicates the intercept of the linear function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "amplitude",
					Description: `The amplitude attribute indicates the amplitude of the cubic function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "exponent",
					Description: `The exponent attribute indicates the exponent of the exponential function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "offset",
					Description: `The offset attribute indicates the offset of the function.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feFuncB",
			Description: `The <feFuncB> SVG filter primitive defines the transfer function for the blue component of the input graphic of its parent <feComponentTransfer> element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "type",
					Description: `The type of transfer function.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("identity", `The type of transfer function.`),
						AttributeTypeChoice("table", `The type of transfer function.`),
						AttributeTypeChoice("discrete", `The type of transfer function.`),
						AttributeTypeChoice("linear", `The type of transfer function.`),
						AttributeTypeChoice("gamma", `The type of transfer function.`),
					),
				},
				{
					Key:         "tableValues",
					Description: `Contains the list of <number>s that define the lookup table. Values must be in the 0-1 range and be equally spaced. There must be at least two values.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "slope",
					Description: `The slope attribute indicates the slope of the linear function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "intercept",
					Description: `The intercept attribute indicates the intercept of the linear function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "amplitude",
					Description: `The amplitude attribute indicates the amplitude of the cubic function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "exponent",
					Description: `The exponent attribute indicates the exponent of the exponential function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "offset",
					Description: `The offset attribute indicates the offset of the function.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feFuncG",
			Description: `The <feFuncG> SVG filter primitive defines the transfer function for the green component of the input graphic of its parent <feComponentTransfer> element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "type",
					Description: `The type of transfer function.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("identity", `The type of transfer function.`),
						AttributeTypeChoice("table", `The type of transfer function.`),
						AttributeTypeChoice("discrete", `The type of transfer function.`),
						AttributeTypeChoice("linear", `The type of transfer function.`),
						AttributeTypeChoice("gamma", `The type of transfer function.`),
					),
				},
				{
					Key:         "tableValues",
					Description: `Contains the list of <number>s that define the lookup table. Values must be in the 0-1 range and be equally spaced. There must be at least two values.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "slope",
					Description: `The slope attribute indicates the slope of the linear function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "intercept",
					Description: `The intercept attribute indicates the intercept of the linear function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "amplitude",
					Description: `The amplitude attribute indicates the amplitude of the cubic function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "exponent",
					Description: `The exponent attribute indicates the exponent of the exponential function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "offset",
					Description: `The offset attribute indicates the offset of the function.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feFuncR",
			Description: `The <feFuncR> SVG filter primitive defines the transfer function for the red component of the input graphic of its parent <feComponentTransfer> element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "type",
					Description: `The type of transfer function.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("identity", `The type of transfer function.`),
						AttributeTypeChoice("table", `The type of transfer function.`),
						AttributeTypeChoice("discrete", `The type of transfer function.`),
						AttributeTypeChoice("linear", `The type of transfer function.`),
						AttributeTypeChoice("gamma", `The type of transfer function.`),
					),
				},
				{
					Key:         "tableValues",
					Description: `Contains the list of <number>s that define the lookup table. Values must be in the 0-1 range and be equally spaced. There must be at least two values.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "slope",
					Description: `The slope attribute indicates the slope of the linear function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "intercept",
					Description: `The intercept attribute indicates the intercept of the linear function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "amplitude",
					Description: `The amplitude attribute indicates the amplitude of the cubic function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "exponent",
					Description: `The exponent attribute indicates the exponent of the exponential function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "offset",
					Description: `The offset attribute indicates the offset of the function.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feGaussianBlur",
			Description: `The <feGaussianBlur> SVG filter primitive blurs the input image by the amount specified in stdDeviation, which defines the bell-curve.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "stdDeviation",
					Description: `The standard deviation for the blur operation. If two <numbers> are provided, the first number represents a standard deviation value along the x-axis of the coordinate system established by attribute 'primitiveUnits' on the <filter> element. The second value represents a standard deviation in Y. If one number is provided, then that value is used for both X and Y. Negative values are not allowed. A value of zero disables the effect of the given filter primitive (i.e., the result is a transparent black image).`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feImage",
			Description: `The <feImage> SVG filter primitive fetches image data from an external source and provides the pixel data as output (meaning if the external source is an SVG image, it is rasterized.)`,
			Attributes: []*pb.Attribute{
				{
					Key:         "externalResourcesRequired",
					Description: `Indicates whether or not to force synchronous behavior.`,
					Type:        AttributeTypeBool(),
				},
				{
					Key:         "preserveAspectRatio",
					Description: `Indicates how the fetched image is fitted into the destination rectangle.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", `Do not force uniform scaling.`),
						AttributeTypeChoice("xMinYMin", `Scale the image to the smallest size such that both its width and its height can completely fit inside the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMin", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMaxYMin", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMinYMid", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMid", `Scale the image to the smallest size such that it can completely fit inside the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMaxYMid", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMinYMax", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMax", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMaxYMax", `Scale the image to the smallest size such that both its width and its height can completely fit inside the corresponding dimension of the viewPort.`),
					),
				},
				{
					Key:         "href",
					Description: `A URI reference to an external resource.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "feMerge",
			Description: `The <feMerge> SVG element allows filter effects to be applied concurrently instead of sequentially.`,
		},

		{
			Tag:         "feMergeNode",
			Description: `The <feMergeNode> SVG element allows a series of filter primitives to be connected together graphically. Incoming nodes are blended into the background via the defined compositing operator.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The identifier for the input SVGAnimatedString attribute on the given 'feMergeNode' element.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "feMorphology",
			Description: `The <feMorphology> SVG filter primitive is used to erode or dilate the input image. It's usefulness lies especially in fattening or thinning effects.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "operator",
					Description: `The operator attribute defines what type of operation is performed.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("erode", `The operator attribute defines what type of operation is performed.`),
						AttributeTypeChoice("dilate", `The operator attribute defines what type of operation is performed.`),
					),
				},
				{
					Key:         "radius",
					Description: `The radius attribute indicates the size of the matrix.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feOffset",
			Description: `The <feOffset> SVG filter primitive allows to offset the input image. The amount of offset can be controlled by attributes dx and dy.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "dx",
					Description: `The dx attribute indicates a shift along the x-axis on the kernel matrix.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "dy",
					Description: `The dy attribute indicates a shift along the y-axis on the kernel matrix.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "fePointLight",
			Description: `The <fePointLight> SVG filter primitive defines a light source at a point on the plane of the user coordinate system.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "x",
					Description: `The x attribute indicates the x location of the light source in the coordinate system established by attribute 'primitiveUnits' on the <filter> element.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y",
					Description: `The y attribute indicates the y location of the light source in the coordinate system established by attribute 'primitiveUnits' on the <filter> element.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "z",
					Description: `The z attribute indicates the z location of the light source in the coordinate system established by attribute 'primitiveUnits' on the <filter> element.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feSpecularLighting",
			Description: `The <feSpecularLighting> SVG filter primitive lights a source graphic using the alpha channel as a bump map. The resulting image is an RGBA image based on the light color. The lighting calculation follows the standard specular component of the Phong lighting model. The resulting image depends on the light color, light position and surface geometry of the input bump map.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "surfaceScale",
					Description: `The 'surfaceScale' attribute indicates the height of the surface when the alpha channel is 1.0.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "specularConstant",
					Description: `The specularConstant attribute represents the diffuse reflection constant.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "specularExponent",
					Description: `The specularExponent attribute represents the specular reflection constant.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "kernelUnitLength",
					Description: `The kernelUnitLength attribute defines the intended distance in current filter units (i.e., units as determined by the value of attribute 'primitiveUnits') for dx and dy in the surface normal calculation formulas.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "feSpotLight",
			Description: `The <feSpotLight> SVG filter primitive allows to create a light source placed at a point x, y, z.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "x",
					Description: `The x attribute indicates the x location of the light source in the coordinate system established by attribute 'primitiveUnits' on the <filter> element.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y",
					Description: `The y attribute indicates the y location of the light source in the coordinate system established by attribute 'primitiveUnits' on the <filter> element.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "z",
					Description: `The z attribute indicates the z location of the light source in the coordinate system established by attribute 'primitiveUnits' on the <filter> element.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "pointsAtX",
					Description: `The pointsAtX attribute indicates the x location in the coordinate system established by attribute 'primitiveUnits' on the <filter> element of the point at which the light source is pointing.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "pointsAtY",
					Description: `The pointsAtY attribute indicates the y location in the coordinate system established by attribute 'primitiveUnits' on the <filter> element of the point at which the light source is pointing.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "pointsAtZ",
					Description: `The pointsAtZ attribute indicates the z location in the coordinate system established by attribute 'primitiveUnits' on the <filter> element of the point at which the light source is pointing.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "specularExponent",
					Description: `The specularExponent attribute represents the specular reflection constant.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "limitingConeAngle",
					Description: `The limitingConeAngle attribute represents the angle in degrees between the spot light axis and the spot light cone.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "feTile",
			Description: `The <feTile> SVG filter primitive allows to fill a target rectangle with a repeated, tiled pattern of an input image. The effect is similar to the one of a <pattern> element, but <feTile> can use complex (i.e., filter) tree as input, and can be animated.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "in",
					Description: `The input for this filter.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "feTurbulence",
			Description: `The <feTurbulence> SVG filter primitive creates an image using the Perlin turbulence function. It allows the synthesis of artificial textures like clouds or marble.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "baseFrequency",
					Description: `The baseFrequency attribute represent the base frequencies in the X and Y directions of the turbulence function.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "numOctaves",
					Description: `The numOctaves attribute indicates the number of octaves to be used by the noise function.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "seed",
					Description: `The seed attribute indicates which number to use to seed the random number generator.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "stitchTiles",
					Description: `The stitchTiles attribute indicates how the Perlin noise function should be tiled. It is ignored if type is not set to 'turbulence'.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("noStitch", `The <feTurbulence> SVG filter primitive creates an image using the Perlin turbulence function. It allows the synthesis of artificial textures like clouds or marble.`),
						AttributeTypeChoice("stitch", `The <feTurbulence> SVG filter primitive creates an image using the Perlin turbulence function. It allows the synthesis of artificial textures like clouds or marble.`),
					),
				},
				{
					Key:         "type",
					Description: `The type of turbulence function.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("fractalNoise", `The type of turbulence function.`),
						AttributeTypeChoice("turbulence", `The type of turbulence function.`),
					),
				},
			},
		},

		{
			Tag:         "filter",
			Description: `The <filter> SVG element defines a custom filter effect by grouping atomic filter primitives. It is never rendered directly. A filter is referenced by using the filter attribute on the target SVG element or via the filter CSS property.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "filterUnits",
					Description: `The coordinate system for attributes x, y, width and height.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for attributes x, y, width and height.`),
						AttributeTypeChoice("objectBoundingBox", `The coordinate system for attributes x, y, width and height.`),
					),
				},
				{
					Key:         "primitiveUnits",
					Description: `The coordinate system for the various length values within the filter.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for the various length values within the filter.`),
						AttributeTypeChoice("objectBoundingBox", `The coordinate system for the various length values within the filter.`),
					),
				},
				{
					Key:         "x",
					Description: `The x attribute indicates where the left edge of the filter is placed.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "y",
					Description: `The y attribute indicates where the top edge of the filter is placed.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: `The width attribute indicates the width of the filter primitive box.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "height",
					Description: `The height attribute indicates the height of the filter primitive box.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "foreignObject",
			Description: `The <foreignObject> SVG element allows for inclusion of a foreign XML namespace which has its graphical content drawn by a different user agent. The included foreign graphical content is subject to SVG transformations and compositing.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "x",
					Description: `The x-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: `The width of the rectangular region.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "height",
					Description: `The height of the rectangular region.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "requiredExtensions",
					Description: `A space-separated list of required extensions, indicating that the parent SVG document must include the specified extensions for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "requiredFeatures",
					Description: `A space-separated list of required features, indicating that the parent SVG document must include support for all of the specified features for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "systemLanguage",
					Description: `A space-separated list of language codes, indicating that the parent SVG document must include support for all of the specified languages for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "g",
			Description: `The <g> SVG element is a container used to group other SVG elements.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "requiredExtensions",
					Description: `A space-separated list of required extensions, indicating that the parent SVG document must include the specified extensions for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "requiredFeatures",
					Description: `A space-separated list of required features, indicating that the parent SVG document must include support for all of the specified features for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "systemLanguage",
					Description: `A space-separated list of language codes, indicating that the parent SVG document must include support for all of the specified languages for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "image",
			Description: `The <image> SVG element includes images inside SVG documents.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "preserveAspectRatio",
					Description: `Indicates how the fetched image is fitted into the destination rectangle.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", `Do not force uniform scaling.`),
						AttributeTypeChoice("xMinYMin", `Scale the image to the smallest size such that both its width and its height can completely fit inside the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMin", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMaxYMin", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMinYMid", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMid", `Scale the image to the smallest size such that it can completely fit inside the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMaxYMid", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMinYMax", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMax", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMaxYMax", `Scale the image to the smallest size such that both its width and its height can completely fit inside the corresponding dimension of the viewPort.`),
					),
				},
				{
					Key:         "x",
					Description: `The x-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "width",
					Description: `The width of the rectangular region.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "height",
					Description: `The height of the rectangular region.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "href",
					Description: `A URI reference to the image to embed.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "line",
			Description: `The <line> SVG element is an SVG basic shape, used to create a line connecting two points.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "x1",
					Description: `The x-axis coordinate of the starting point of the line.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y1",
					Description: `The y-axis coordinate of the starting point of the line.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "x2",
					Description: `The x-axis coordinate of the ending point of the line.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y2",
					Description: `The y-axis coordinate of the ending point of the line.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "linearGradient",
			Description: `The <linearGradient> SVG element lets authors define linear gradients to fill or stroke graphical elements.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "gradientUnits",
					Description: `The coordinate system for attributes x1, y1, x2 and y2.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for attributes x1, y1, x2 and y2.`),
						AttributeTypeChoice("objectBoundingBox", `The coordinate system for attributes x1, y1, x2 and y2.`),
					),
				},
				{
					Key:         "gradientTransform",
					Description: `The definition of how the gradient is applied, read about <a href="https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/gradientTransform">gradientTransform</a>.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "spreadMethod",
					Description: `The method by which to fill a shape.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("pad", `The method by which to fill a shape.`),
						AttributeTypeChoice("reflect", `The method by which to fill a shape.`),
						AttributeTypeChoice("repeat", `The method by which to fill a shape.`),
					),
				},
				{
					Key:         "x1",
					Description: `The x-axis coordinate of the start of the gradient.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y1",
					Description: `The y-axis coordinate of the start of the gradient.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "x2",
					Description: `The x-axis coordinate of the end of the gradient.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y2",
					Description: `The y-axis coordinate of the end of the gradient.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "marker",
			Description: `The <marker> SVG element defines the graphics that is to be used for drawing arrowheads or polymarkers on a given <path>, <line>, <polyline> or <polygon> element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "refX",
					Description: `The x-axis coordinate of the reference point which is to be aligned exactly at the marker position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "refY",
					Description: `The y-axis coordinate of the reference point which is to be aligned exactly at the marker position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "markerWidth",
					Description: `The width of the marker viewport.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "markerHeight",
					Description: `The height of the marker viewport.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "orient",
					Description: `The orientation of the marker relative to the shape it is attached to.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("auto", `The orientation of the marker relative to the shape it is attached to.`),
						AttributeTypeChoice("auto-start-reverse", `The orientation of the marker relative to the shape it is attached to.`),
						AttributeTypeChoice("angle", `The orientation of the marker relative to the shape it is attached to.`),
					),
				},
				{
					Key:         "markerUnits",
					Description: `The coordinate system for the various length values within the marker.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for the various length values within the marker.`),
						AttributeTypeChoice("strokeWidth", `The coordinate system for the various length values within the marker.`),
					),
				},
				{
					Key:         "viewBox",
					Description: `The position and size of the marker viewport (the bounds of the marker).`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "mask",
			Description: `The <mask> SVG element hides portions of SVG elements for user display.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "maskContentUnits",
					Description: `The coordinate system for attributes x, y, width and height.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for attributes x, y, width and height.`),
						AttributeTypeChoice("objectBoundingBox", `The coordinate system for attributes x, y, width and height.`),
					),
				},
				{
					Key:         "maskUnits",
					Description: `The coordinate system for the various length values within the filter.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for the various length values within the filter.`),
						AttributeTypeChoice("objectBoundingBox", `The coordinate system for the various length values within the filter.`),
					),
				},
				{
					Key:         "x",
					Description: `The x-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: `The width of the rectangular region.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "height",
					Description: `The height of the rectangular region.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "metadata",
			Description: `The <metadata> SVG element allows to add metadata to SVG content. Metadata is structured information about data. In XML, metadata can be added to an element using for example attributes.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "requiredExtensions",
					Description: `A space-separated list of required extensions, indicating that the parent SVG document must include the specified extensions for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "requiredFeatures",
					Description: `A space-separated list of required features, indicating that the parent SVG document must include support for all of the specified features for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "systemLanguage",
					Description: `A space-separated list of language codes, indicating that the parent SVG document must include support for all of the specified languages for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "mpath",
			Description: `The <mpath> SVG element allows to use the functionality of <animateMotion> to animate the <startOffset> attribute of SVG <textPath> elements.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "href",
					Description: `A URI reference to the motion path definition.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "path",
			Description: `The <path> SVG element is the generic element to define a shape. All the basic shapes can be created with a path element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "d",
					Description: `The definition of the outline of a shape.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "fill",
					Description: `The <path> SVG element is the generic element to define a shape. All the basic shapes can be created with a path element.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "fill-opacity",
					Description: `The <path> SVG element is the generic element to define a shape. All the basic shapes can be created with a path element.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "pathLength",
					Description: `The total length for the path, in user units.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "pattern",
			Description: `The <pattern> SVG element fills a region with a pattern defined by an SVG image.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "patternUnits",
					Description: `The coordinate system for attributes x, y, width and height.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for attributes x, y, width and height.`),
						AttributeTypeChoice("objectBoundingBox", `The coordinate system for attributes x, y, width and height.`),
					),
				},
				{
					Key:         "patternContentUnits",
					Description: `The coordinate system for the various length values within the filter.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for the various length values within the filter.`),
						AttributeTypeChoice("objectBoundingBox", `The coordinate system for the various length values within the filter.`),
					),
				},
				{
					Key:         "patternTransform",
					Description: `The definition of how the pattern is tiled, read about <a href="https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/patternTransform">patternTransform</a>.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "x",
					Description: `The x-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "width",
					Description: `The width of the rectangular region.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "height",
					Description: `The height of the rectangular region.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "href",
					Description: `A URI reference to the image to paint.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "polygon",
			Description: `The <polygon> SVG element is an SVG basic shape, used to create a vector-based polygonal shape.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "points",
					Description: `A list of points, each of which is a coordinate pair.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "polyline",
			Description: `The <polyline> SVG element is an SVG basic shape, used to create a series of straight lines connecting several points. Typically a polyline is used to create open shapes as the last point doesn't have to be connected to the first point. For closed shapes see the <polygon> element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "points",
					Description: `A list of points, each of which is a coordinate pair.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "radialGradient",
			Description: `The <radialGradient> SVG element lets authors define radial gradients to fill or stroke graphical elements.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "gradientUnits",
					Description: `The coordinate system for attributes cx, cy and r.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("userSpaceOnUse", `The coordinate system for attributes cx, cy and r.`),
						AttributeTypeChoice("objectBoundingBox", `The coordinate system for attributes cx, cy and r.`),
					),
				},
				{
					Key:         "gradientTransform",
					Description: `The definition of how the gradient is applied, read about <a href="https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/gradientTransform">gradientTransform</a>.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "cx",
					Description: `The x-axis coordinate of the largest (i.e., outermost) circle for the radial gradient.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "cy",
					Description: `The y-axis coordinate of the largest (i.e., outermost) circle for the radial gradient.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "r",
					Description: `The radius of the largest (i.e., outermost) circle for the radial gradient.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "fx",
					Description: `The x-axis coordinate of the point at which the focal point of the radial gradient is placed.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "fy",
					Description: `The y-axis coordinate of the point at which the focal point of the radial gradient is placed.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "rect",
			Description: `The <rect> SVG element is a basic SVG shape that draws rectangles, defined by their position, width, and height. The shape is created by connecting a line from one point to the other three points.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "x",
					Description: `The x-axis coordinate of the side of the rectangle which has the smaller x-axis value.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the side of the rectangle which has the smaller y-axis value.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "width",
					Description: `The width of the rectangle.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "height",
					Description: `The height of the rectangle.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "rx",
					Description: `The x-axis radius of the ellipse used to round off the corners of the rectangle.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "ry",
					Description: `The y-axis radius of the ellipse used to round off the corners of the rectangle.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},
		{
			Tag:         "script",
			Description: `The <script> SVG element includes scripts, which can be used to trigger user interface events.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "type",
					Description: `The scripting language used for the given script element.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "href",
					Description: `A Uniform Resource Identifier (URI) reference that specifies the location of the script to execute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "crossorigin",
					Description: `How the element handles crossorigin requests.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("anonymous", `How the element handles crossorigin requests.`),
						AttributeTypeChoice("use-credentials", `How the element handles crossorigin requests.`),
					),
				},
			},
		},

		{
			Tag:         "set",
			Description: `The <set> SVG element provides a simple means of just setting the value of an attribute for a specified duration. It supports all attribute types, including those that cannot reasonably be interpolated, such as string and boolean values. The <set> element is non-additive. The additive and accumulate attributes are not allowed, and will be ignored if specified.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "to",
					Description: `The target attribute value to assign on end.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "attributeName",
					Description: `The name of the attribute to assign.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "attributeType",
					Description: `The namespace in which the target attribute and its associated values are defined.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("auto", `The namespace in which the target attribute and its associated values are defined.`),
						AttributeTypeChoice("CSS", `The namespace in which the target attribute and its associated values are defined.`),
						AttributeTypeChoice("XML", `The namespace in which the target attribute and its associated values are defined.`),
						AttributeTypeChoice("XMLNS", `The namespace in which the target attribute and its associated values are defined.`),
						AttributeTypeChoice("empty", `The namespace in which the target attribute and its associated values are defined.`),
					),
				},
				{
					Key:         "begin",
					Description: `The begin time for the element.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "dur",
					Description: `The simple duration for the element.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "end",
					Description: `The end for the element.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "min",
					Description: `The minimum value allowed for the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "max",
					Description: `The maximum value allowed for the attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "restart",
					Description: `Defines how the element is restarted.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("always", `Defines how the element is restarted.`),
						AttributeTypeChoice("whenNotActive", `Defines how the element is restarted.`),
						AttributeTypeChoice("never", `Defines how the element is restarted.`),
					),
				},
				{
					Key:         "repeatCount",
					Description: `Defines the number of times the element is repeated.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "repeatDur",
					Description: `Defines the duration for the element to repeat.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "fill",
					Description: `Defines the value the animation will have before the begin event.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("remove", `Defines the value the animation will have before the begin event.`),
						AttributeTypeChoice("freeze", `Defines the value the animation will have before the begin event.`),
					),
				},
			},
		},
		{
			Tag:         "stop",
			Description: `The <stop> SVG element defines the ramp of colors to use on a gradient, which is a child element to either the <linearGradient> or the <radialGradient> element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "offset",
					Description: `The offset from the start of the gradient where the color first takes effect.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "stop-color",
					Description: `The color of the gradient stop.`,
					Type:        AttributeTypeString(),
				},
			},
		},
		{
			Tag:         "style",
			Description: `The <style> SVG element allows style sheets to be embedded directly within SVG content. SVG's style element has the same attributes as the corresponding element in HTML (see HTML's <style> element).`,
			Attributes: []*pb.Attribute{
				{
					Key:         "type",
					Description: `The style sheet language.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "media",
					Description: `The intended destination medium for style information.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "title",
					Description: `The advisory title.`,
					Type:        AttributeTypeString(),
				},
			},
		},
		{
			Tag:         "svg",
			Description: `The <svg> element is a container that defines a new coordinate system and viewport. It is used as the outermost element of SVG documents, but it can also be used to embed a SVG fragment inside an SVG or HTML document.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "x",
					Description: `The x-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "width",
					Description: `The width of the rectangular region.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "height",
					Description: `The height of the rectangular region.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "viewBox",
					Description: `The position and size of the viewport (the viewBox) is defined by the viewBox attribute.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "preserveAspectRatio",
					Description: `Indicates how the viewport is fitted to the rectangle of the given width and height.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", `Do not force uniform scaling.`),
						AttributeTypeChoice("xMinYMin", `Scale the image to the smallest size such that both its width and its height can completely fit inside the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMin", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMaxYMin", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMinYMid", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMid", `Scale the image to the smallest size such that it can completely fit inside the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMaxYMid", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMinYMax", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMax", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMaxYMax", `Scale the image to the smallest size such that both its width and its height can completely fit inside the corresponding dimension of the viewPort.`),
					),
				},
			},
		},

		{
			Tag:         "switch",
			Description: `The <switch> SVG element evaluates the requiredFeatures, requiredExtensions and systemLanguage attributes on its direct child elements in order, and then processes and renders the first child for which these attributes evaluate to true. All others will be bypassed and therefore not rendered. If the child element is a container element such as a <g>, then the entire subtree is either processed/rendered or bypassed/not rendered.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "requiredFeatures",
					Description: `A space-separated list of required features, indicating that the parent SVG document must include support for all of the specified features for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "requiredExtensions",
					Description: `A space-separated list of required extensions, indicating that the parent SVG document must include the specified extensions for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "systemLanguage",
					Description: `A space-separated list of language codes, indicating that the parent SVG document must include support for all of the specified languages for this element to be valid.`,
					Type:        AttributeTypeString(),
				},
			},
		},

		{
			Tag:         "symbol",
			Description: `The <symbol> SVG element is used to define graphical template objects which can be instantiated by a <use> element. The use of symbol elements for graphics that are used multiple times in the same document adds structure and semantics. Documents that are rich in structure may be rendered graphically, as speech, or as Braille, and thus promote accessibility. note that a symbol element itself is not rendered. Only instances of a symbol element (i.e., a reference to a symbol by a <use> element) are rendered. To render a 'stand-alone' graphic that has been defined using a symbol, a reference to the symbol is referenced using a <use> element.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "preserveAspectRatio",
					Description: `Indicates how the fetched image is fitted into the destination rectangle.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("none", `Do not force uniform scaling.`),
						AttributeTypeChoice("xMinYMin", `Scale the image to the smallest size such that both its width and its height can completely fit inside the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMin", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMaxYMin", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMinYMid", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMid", `Scale the image to the smallest size such that it can completely fit inside the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMaxYMid", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMinYMax", `Align the image along the middle of the corresponding dimension of the viewPort.`),
						AttributeTypeChoice("xMidYMax", `Align the image with the corresponding side of the viewPort.`),
						AttributeTypeChoice("xMaxYMax", `Scale the image to the smallest size such that both its width and its height can completely fit inside the corresponding dimension of the viewPort.`),
					),
				},
			},
		},

		{
			Tag:         "text",
			Description: `The <text> SVG element renders the first character at the initial current text position. This position is modified by the lengthAdjust and textLength attributes.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "x",
					Description: `The x-axis coordinate of the initial current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the initial current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "dx",
					Description: `The x-axis coordinate of the current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "dy",
					Description: `The y-axis coordinate of the current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "rotate",
					Description: `The rotation angle about the current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "textLength",
					Description: `The total sum of all of the advance values from rendering all of the characters within this element, including the advance value on the glyph (horizontal or vertical), the effect of properties 'kerning', 'letter-spacing' and 'word-spacing' and adjustments due to attributes 'x' and 'y' on the <text> element.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "lengthAdjust",
					Description: `Indicates how the text is stretched or compressed to fit the textLength.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("spacing", `Indicates how the text is stretched or compressed to fit the textLength.`),
						AttributeTypeChoice("spacingAndGlyphs", `Indicates how the text is stretched or compressed to fit the textLength.`),
					),
				},
			},
		},

		{
			Tag:         "textPath",
			Description: `The <textPath> SVG element defines a set of glyphs that exactly fit along a curve.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "href",
					Description: `A URI reference to the path to render along.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "startOffset",
					Description: `Indicates an offset from the start of the path, where the first character is rendered.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "method",
					Description: `Indicates the method by which text should be rendered along the path.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("align", `Indicates the method by which text should be rendered along the path.`),
						AttributeTypeChoice("stretch", `Indicates the method by which text should be rendered along the path.`),
					),
				},
				{
					Key:         "spacing",
					Description: `Indicates the spacing behavior between characters.`,
					Type: AttributeTypeChoices(
						AttributeTypeChoice("auto", `Indicates the spacing behavior between characters.`),
						AttributeTypeChoice("exact", `Indicates the spacing behavior between characters.`),
					),
				},
			},
		},

		{
			Tag:         "title",
			Description: `The <title> SVG element represents a text container used for the context information. This element is usually nested inside a <desc> element.`,
		},

		{
			Tag:         "tspan",
			Description: `The <tspan> SVG element lets authors explicitly specify the location of a glyph along the given path via the attributes.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "x",
					Description: `The x-axis coordinate of the current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "dx",
					Description: `The x-axis coordinate of the current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "dy",
					Description: `The y-axis coordinate of the current text position.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "rotate",
					Description: `The rotation angle about the current text position.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "use",
			Description: `The <use> SVG element includes a reference to a <symbol> element and attempts to display the referenced content. The reference is drawn exactly as it was defined. It can be reused as often as needed and can be programmatically manipulated.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "href",
					Description: `A URI reference to the symbol to use.`,
					Type:        AttributeTypeString(),
				},
				{
					Key:         "x",
					Description: `The x-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "y",
					Description: `The y-axis coordinate of the side of the rectangular region which is closest to the user.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "width",
					Description: `The width of the rectangular region.`,
					Type:        AttributeTypeNumber(),
				},
				{
					Key:         "height",
					Description: `The height of the rectangular region.`,
					Type:        AttributeTypeNumber(),
				},
			},
		},

		{
			Tag:         "view",
			Description: `The <view> SVG element is used to define a view into a &lt;svg&gt; element. It is partially deprecated in SVG 2.0 and should generally not be used.`,
			Attributes: []*pb.Attribute{
				{
					Key:         "viewBox",
					Description: `The position and size of the viewport (the viewBox) is defined by the viewBox attribute.`,
					Type:        AttributeTypeString(),
				},
			},
		},
	},
}

Functions

func AttributeTypeBool

func AttributeTypeBool() *pb.Attribute_Type

func AttributeTypeChoice

func AttributeTypeChoice(name, description string) *pb.Attribute_Choice

func AttributeTypeChoices

func AttributeTypeChoices(choices ...*pb.Attribute_Choice) *pb.Attribute_Type

func AttributeTypeCommaDelimited

func AttributeTypeCommaDelimited() *pb.Attribute_Type

func AttributeTypeCustom

func AttributeTypeCustom(hasKey bool, valueType *pb.Attribute_Type, modifiers ...*pb.Attribute_Custom_Modifier) *pb.Attribute_Type

func AttributeTypeCustomModifier

func AttributeTypeCustomModifier(name string, hasKey bool, valueType *pb.Attribute_Type, modifiers ...*pb.Attribute_Custom_Modifier) *pb.Attribute_Type

func AttributeTypeDelimited

func AttributeTypeDelimited(s string) *pb.Attribute_Type

func AttributeTypeDuration

func AttributeTypeDuration() *pb.Attribute_Type

func AttributeTypeInt

func AttributeTypeInt() *pb.Attribute_Type

func AttributeTypeJSON

func AttributeTypeJSON() *pb.Attribute_Type

func AttributeTypeKV

func AttributeTypeKV(keyValueDelim, pairDelim string) *pb.Attribute_Type

func AttributeTypeKVColonSemicolon

func AttributeTypeKVColonSemicolon() *pb.Attribute_Type

func AttributeTypeNumber

func AttributeTypeNumber() *pb.Attribute_Type

func AttributeTypeRune

func AttributeTypeRune() *pb.Attribute_Type

func AttributeTypeSpaceDelimited

func AttributeTypeSpaceDelimited() *pb.Attribute_Type

func AttributeTypeString

func AttributeTypeString() *pb.Attribute_Type