The HTML vocabulary establishes a draft standard to semantically represent HTML documents in RDF. The vocabulary is based on the HTML Living Standard. It includes classes for HTML elements, datatype properties for attributes, and SHACL shapes for code serialization. HTML documents can thus be represented, queried, generated, validated, analysed, transformed and reused as semantic objects themselves. As HTML documents are widely used in a myriad of use cases, from websites, dashboard, applications, to social media and documents, this vocabulary helps organisations and individuals to get a better grasp of their information products.
The HTML vocabulary establishes a draft standard that enables the semantic representation of any HTML document in RDF. The vocabulary can be used to generate, validate, query, annotate, reuse and adapt HTML documents within a semantic web framework. The vocabulary is based on the Living Standard of HTML (https://html.spec.whatwg.org/) and offers classes to represent HTML elements, datatype properties to represent HTML attributes and a small number of SHACL shapes and SPARQL functions for the serialisation of HTML code. The example below shows how a 'Hello world!' snippet of HTML code can be represented in RDF using the HTML vocabulary.
This is represented in RDF using the HTML vocabulary as follows:
#### Basic components of the ontology ##### HTML document The HTML vocabulary describes all the components of the HTML Living Standard. Central to the Living Standard is the concept of an HTML document. An HTML document is a document written in the standard markup language HyperText Markup Language (HTML) and designed to be displayed in a web browser. The HTML of that document defines its content and structure. An HTML document contains underlying nodes, like HTML elements, text, comments, processing instructions, CDATA sections and a document type declaration. Hence, the ontology provides the following main classes to model instances of these HTML components: ***Main classes*** ``` html:Document html:DocumentType html:Element html:Text html:Comment html:ProcessingInstruction html:CDATASection ``` ##### Document structure The components of an HTML document together form a tree-like structure of nodes known as the Document Object Model (DOM), which is a programmatic representation of the document that allows it to be manipulated dynamically. The HTML vocabulary models the relationship between the DOM and the HTML components, as described in the Living Standard of HTML. The DOM itself requires a separate RDF-based DOM vocabulary, modeling the Living Standard of DOM. Essential classes like html:Document, html:DocumentType, html:Element, html:Text, html:Comment, html:ProcessingInstruction and html:CDATASection, are defined as subclasses of respectively dom:Document, dom:DocumentType, dom:Text, dom:Comment, dom:ProcessingInstruction and dom:CDATASection, which all are manifestations of dom:DocumentTreeNode. The DOM vocabulary provides thus, through a RDF-based representation of the Document Object Model, the necessary context for the HTML vocabulary. ***Overview DOM and HTML classes*** ``` dom:DocumentTreeNode ├── dom:Document │ └── html:Document ├── dom:DocumentType │ └── html:DocumentType ├── dom:Element │ └── html:Element ├── dom:Text │ └── html:Text ├── dom:Comment │ └── html:Comment ├── dom:ProcessingInstruction │ └── html:ProcessingInstruction └── dom:CDATASection └── html:CDATASection ``` ***Document hierarchy*** The treelike structure underlying an HTML document is hierarchical. Every node in that tree occupies a certain hierarchical position. This position is modeled in the HTML vocabulary through the use of the rdfs:member property and its subproperties, e.g. rdf:_1, rdf:_2, rdf:_3,... The use of this property and its subproperties indicates a parent-child relationship between two nodes as well as the relative position of a node towards any preceding or following siblings.
##### HTML element An HTML element is the building block of an HTML document. For each HTML element, its name and the definition as given in the according section of the HTML Living Standard is modeled in the ontology using SKOS properties skos:prefLabel and skos:definition. In addition, the tag of the HTML element (like 'body' for the body element) is represented through the property html:tag. Each element is linked to the section of the HTML Living Standard in which the element is described, using the dct:conformsTo property.
A specific instance of the body element can be seen in the example below.
***Kinds of elements*** According to the Living Standard of HTML there are six different kinds of elements: void elements, the template element, raw text elements, escapable raw text elements, foreign elements and normal elements. In addition, the Living Standard also distinguishes the custom element, making for a total of seven different kinds of HTML elements. These kinds of elements are represented in the HTML vocabulary as follows: ``` html:Element ├── html:VoidElement │ ├── html:Area │ ├── html:Base │ ├── html:Br │ ├── html:Col │ ├── html:Embed │ ├── html:Hr │ ├── html:Img │ ├── html:Input │ ├── html:Link │ ├── html:Meta │ ├── html:Source │ ├── html:Track │ └── html:Wbr ├── html:Template ├── html:RawTextElement │ ├── html:Script │ └── html:Style ├── html:ForeignElement │ ├── mathml:MathML │ └── svg:Svg ├── html:CustomElement └── html:NormalElement └── all other subclasses of html:Element ``` ##### Content category The Living Standard of HTML states that each HTML element falls into zero or more content categories that group elements with similar characteristics together. The following classes are used in the vocabulary to model these content categories: ***Content category classes*** ``` html:ContentCategory ├── html:MetadataContent ├── html:FlowContent ├── html:SectioningContent ├── html:HeadingContent ├── html:PhrasingContent ├── html:EmbeddingContent ├── html:InteractiveContent ├── html:PalpableContent ├── html:ScriptSupportingElement ├── html:FormAssociatedElement └── html:LabelableElement ``` These content categories are all subclasses of html:ContentCategory. Note that the HTML Living Standard defines its content categories scattered across multiple sections of its specification. As the content categories are defined in the vocabulary as complex classes using OWL, one can use an OWL inference engine to establish which element belongs in which category. ##### HTML attribute The Living Standard of HTML defines an HTML attribute as a key-value pair that is associated with an HTML element to control its behavior, written within the start tag of an element. Examples are 'style' and 'colspan'. The ontology provides the 'html:Attribute' class to represent the set of all these HTML attributes, like the attributes 'html:style' and 'html:colspan'. Note that 'html:Attribute' itself is a subclass of dom:Attribute, a node in the Document Object Model (DOM). The key of the HTML attribute (like 'colspan' in 'html:colspan') is represented through the property html:key. In addition, every HTML attribute in the HTML vocabulary is also defined as a subproperty of 'html:attribute'. For each HTML attribute, its name and the definition as given in the according section of the HTML Living Standard is modeled in the ontology using SKOS properties skos:prefLabel and skos:definition.
Next to the already defined HTML attributes in the HTML vocabulary (conforming to the Living Standard of HTML), custom defined attributes can also be used in RDF-based HTML documents. These attributes need to be defined in some arbitrary vocabulary using the same design pattern as is shown in the example. An example of an existing vocabulary with a custom defined attribute is the RDFa vocabulary, based on the formal RDFa specification of W3C.
##### HTML serialisation A RDF-based HTML document, HTML element, text, document type declaration, HTML comment or CDATA section can have an associated HTML fragment through the html:fragment property, representing the HTML code of itself, its possible underlying child nodes and possible HTML attributes. If a RDF-based node of an HTML document contains an HTML fragment through this property, it is said to be serialized to HTML. In order to serialize an HTML document to actual HTML code based on its RDF-representation, the ontology provides the SHACL based node shape shp:HTMLFragmentSerializationAlgorithm, with its associated target target:HTMLFragmentSerializationAlgorithm; and rule rule:HTMLFragmentSerializationAlgorithm. In doing so, we make use of the Advanced Features of SHACL (see https://www.w3.org/TR/shacl-af/). Let us have a closer look at how this works. ***shp:HTMLFragmentSerializationAlgorithm*** This nodeshape searches, through its target, for nodes that do not have an HTML fragment yet and then transforms these nodes to contain actual HTML code by applying its rule. The logic behind the shape is that the HTML code of an HTML document can only be serialized from the leaves of the DOM tree upwards up and till the top of the tree. It means that an arbitrary element in the DOM tree of an HTML document can only be serialized to HTML code, whenever the underlying child elements of that element already have been serialized to HTML, including the HTML code of any possible attributes. The outer edges of the tree are text nodes and other nodes that do not contain any child nodes, like void elements, comments and processing instructions. Please note that instances of html:Text already need to have an html:fragment statement (representing the very text without actual HTML code) before the serializing is run, or else the serialisation will not result in a fully HTML-rendered document. From the start the nodes that do not contain any child nodes can be transformed into HTML code immediately without the necessity of traversing the tree in depth. The next iteration of the SHACL engine can then work its way up the tree, using the previously obtained results until the moment that all the nodes in the document have received an HTML fragment. The processing (by calling the SHACL engine iteratively) halts the moment the document itself has an html:fragment statement. ``` shp:HTMLFragmentSerializationAlgorithm a sh:NodeShape; sh:rule rule:HTMLFragmentSerializationAlgorithm; sh:target target:HTMLFragmentSerializationAlgorithm; skos:prefLabel 'Node shape for HTML fragment serialization algorithm'@en; skos:definition 'A node shape with an algorithm to serialize an HTML fragment for a node in an HTML document.'@en; rdfs:isDefinedBy html:. ``` ***target:HTMLFragmentSerializationAlgorithm*** This target looks for nodes that do not have an HTML fragment yet, but whose child nodes (if any) all have an HTML fragment. ``` target:HTMLFragmentSerializationAlgorithm a sh:SPARQLTarget; skos:prefLabel 'SPARQL target for HTML fragment serialization algorithm'@en; skos:definition 'A SPARQL Target to select all nodes in an HTML document that do not have an HTML fragment yet, and whose child nodes all have an HTML fragment already.'@en; sh:prefixes html:; sh:select """ select $this { # Select all DOM nodes... $this a/rdfs:subClassOf* dom:DocumentTreeNode. # ...that do not yet have an HTML fragment. filter not exists { $this html:fragment []. } # ...but whose child nodes (if any) all have an HTML fragment filter not exists { $this ?member ?child. filter(function:isMembershipProperty(?member)) filter not exists { ?child html:fragment []. } ?child a/rdfs:subClassOf* dom:DocumentTreeNode. } }"""; rdfs:isDefinedBy html:. ``` ***rule:HTMLFragmentSerializationAlgorithm*** This rule establishes and asserts the new HTML fragment for the node that was found by the target. It does so by calling a SPARQL function, depending on the kind of node within the HTML document. ``` rule:HTMLFragmentSerializationAlgorithm a sh:SPARQLRule; skos:prefLabel 'SPARQL rule for HTML fragment serialization algorithm'@en; skos:definition 'A SPARQL rule to serialize an HTML fragment for a node in an HTML document, analogue to the HTML fragment serialisation algorithm as described in the living standard of HTML.'@en; sh:prefixes html:; sh:construct """ construct { # Assert the new HTML fragment for this node in the HTML document $this html:fragment ?fragment. } where { # Establish the class of the node in the HTML document $this a/rdfs:subClassOf* ?htmlClass. ?htmlClass rdfs:isDefinedBy html:. # Build the HTML fragment for the node in the HTML document depending on its class bind(if(?htmlClass = html:Element, function:getElementFragment($this), if(?htmlClass = html:Text, function:getTextFragment($this), if(?htmlClass = html:Comment, function:getCommentFragment($this), if(?htmlClass = html:ProcessingInstruction, function:getProcessingInstructionFragment($this), if(?htmlClass = html:DocumentType, function:getDocumentTypeFragment($this), if(?htmlClass = html:Document, function:getDocumentFragment($this), ?unboundDummy)))))) as ?fragmentString) # Convert result from string to rdf:HTML if fragment exists bind(if(bound(?fragmentString), strdt(?fragmentString, rdf:HTML), ?unboundDummy) as ?fragment) }"""; rdfs:isDefinedBy html:. ``` ***Main functions*** The rule:HTMLFragmentSerializationAlgorithm can call six SPARQL functions as defined in the HTML vocabulary, depending on the kind of node within the HTML document. These functions are: ``` function:getElementFragment function:getTextFragment function:getCommentFragment function:getProcessingInstructionFragment function:getDocumentTypeFragment function:getDocumentFragment ``` These functions establish and return the HTML fragment for a node in an HTML document. For illustration purposes, let us examine the function:getDocumentFragment. ``` function:getDocumentFragment a sh:SPARQLFunction; skos:prefLabel "the getDocumentFragment() function"@en; skos:definition "A SPARQL function that returns an HTML fragment for an HTML document."@en; sh:parameter [ sh:path function:document; sh:datatype xsd:anyURI; sh:description "An HTML document."; ]; sh:prefixes html:; sh:returnType xsd:string; sh:select """ select ?result { optional { # Establish the HTML fragment of the HTML document by retrieving the HTML fragments of all child nodes. bind(function:getChildNodeFragment($document) as ?fragment) } bind(coalesce(?fragment, '') as ?result) }"""; rdfs:isDefinedBy html:. ``` This function has a name and definition, captured through the SKOS properties skos:prefLabel and skos:definition. There is a parameter defined (for an arbitrary document), and a returntype which details the kind of output the function will give back (a string). In the select query the actual algorithm is represented to retrieve the HTML code for the HTML document, by calling function function:getChildNodeFragment. As one can see, the HTML vocabulary has a modular structure, not only for classes but also for rules, targets, functions and the like. ***Supporting functions*** The HTML vocabulary offers some additional supporting functions in order to serialize a HTML document to HTML from its RDF-representation. ``` function:getChildNodeFragment # returns the HTML fragment for the child nodes of an HTML node (if any). function:getElementAttribute # returns the attributes for an HTML node (if any). function:getMemberIndex # returns the relative position of an HTML node towards possible previous siblings. function:isMembershipProperty # returns true/false whether a property is or is not an instance of the ContainerMembershipProperty class (rdf:_1, rdf:_2, rdf:_3,...). ``` ***Parameters*** For the latter two functions, the HTML vocabulary also models two parameters that are used in these functions: ``` parameter:getMemberIndex_property # a property parameter:isMembershipProperty_term # a term ``` Take for example the HTML document as modeled above. Running this through a SHACL engine will lead to the following triples:
Note how each node in the HTML document has a html:fragment statement in which the resulting HTML code of that node is represented. ##### Custom element As the Living Standard of HTML provides the possibility of custom defined HTML elements, so should the HTML vocabulary. Hence, the class html:CustomElement, the node shape shp:CustomElement and associated rule rule:CustomElement are defined in the vocabulary. A custom element can then be defined in some arbitrary vocabulary and applied in some HTML document.
A visualisation of the ontology
| Prefix | Namespace |
|---|---|
| aria | http://www.w3.org/ns/wai-aria/ |
| dom | http://www.w3.org/DOM/model/def/ |
| function | https://www.w3.org/html/model/function/ |
| html | https://www.w3.org/html/model/def/ |
| mathml | http://www.w3.org/1998/Math/MathML/model/def/ |
| parameter | https://www.w3.org/html/model/parameter/ |
| rdf | http://www.w3.org/1999/02/22-rdf-syntax-ns# |
| rdfs | http://www.w3.org/2000/01/rdf-schema# |
| rule | https://www.w3.org/html/model/rule/ |
| section | https://www.w3.org/html/id/section/ |
| shp | https://www.w3.org/html/model/shp/ |
| standard | https://www.w3.org/html/id/standard/ |
| svg | http://www.w3.org/SVG/model/def/ |
| target | https://www.w3.org/html/model/target/ |
| xsd | http://www.w3.org/2001/XMLSchema# |
A serialisation of the ontology in Turtle-format (*.ttl) can be found here.
Issue can automatically be populated from GitHub
html:A
The <a> HTML 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.html:Abbr
The <abbr> HTML element represents an abbreviation or acronym; the optional title attribute can provide an expansion or description for the abbreviation. If present, title must contain this full description and nothing else.html:Address
The <address> HTML element indicates that the enclosed HTML provides contact information for a person or people, or for an organization.html:Area
The <area> HTML 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 hypertext link.html:Article
The <article> HTML 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). Examples include: a forum post, a magazine or newspaper article, or a blog entry, a product card, a user-submitted comment, an interactive widget or gadget, or any other independent item of content.html:Aside
The <aside> HTML element represents a portion of a document whose content is only indirectly related to the document's main content. Asides are frequently presented as sidebars or call-out boxes.html:Attribute
An attribute is a name-value pair that is associated with an HTML element. Attributes provide additional information about an element and are specified within the start tag of an element. Attributes can modify the behavior or appearance of an element, define relationships between elements, or provide other metadata. The name of the attribute is followed by an equal sign (=) and the attribute's value, which is enclosed in double or single quotes. Some attributes affect the element simply by their presence in the start tag of the element, with the value implicitly being an empty string.html:Audio
The <audio> HTML 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.html:AutocapitalizeInheritingElement
Denotes elements that inherit the autocapitalize attribute from their form owner.html:AutonomousCustomElement
An autonomous custom element is a custom HTML element that is defined with no extends option. These types of custom elements have a local name equal to their defined name.html:B
The <b> HTML element 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.html:Base
The <base> HTML element specifies the base URL to use for all relative URLs in a document. There can be only one <base> element in a document.html:Bdi
The <bdi> HTML element tells the browser's bidirectional algorithm to treat the text it contains in isolation from its surrounding text. It's particularly useful when a website dynamically inserts some text and doesn't know the directionality of the text being inserted.html:Bdo
The <bdo> HTML element overrides the current directionality of text, so that the text within is rendered in a different direction.html:Blockquote
The <blockquote> HTML 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.html:Body
The <body> HTML element is the second element in a root html element. It contains the contents of the document.html:Br
The <br> HTML 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.html:Button
The <button> HTML element represents a clickable button, used to submit forms or anywhere in a document for accessible, standard button functionality.html:CDATASection
A DOM element with textual content that contain characters that would otherwise be treated as markup. A CDATA section is typically used to include code snippets, scripts, or other data within an HTML document without having to worry about escaping special characters. In HTML, a CDATA section is denoted by enclosing the block of text within <![CDATA[ and ]]> tags. Anything contained within these tags is treated as raw character data and is not parsed as markup.html:Canvas
Use the HTML <canvas> element with either the canvas scripting API or the WebGL API to draw graphics and animations.html:Caption
The caption element represents the title of the table that is its parent, if it has a parent and that is a table element.html:Cell
The ontology does not provide a definition for this entity.html:Cite
The <cite> HTML element 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.html:Code
The <code> HTML 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.html:Col
The <col> HTML 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.html:Colgroup
The <colgroup> HTML element defines a group of columns within a table.html:Comment
A comment is a markup construct used to insert comments within the HTML code. Comments are not displayed in the web browser, but they can be viewed in the HTML source code. Comments are typically used to add notes, descriptions, or explanations to the HTML code for the benefit of developers, without affecting the rendered output in the browser. Comments are denoted by enclosing the comment text within <!-- and --> tags. Anything contained within these tags is treated as a comment and is ignored by the web browser during rendering.html:ContentCategory
Each element in HTML falls into zero or more categories that group elements with similar characteristics together.html:CustomDataAttribute
A custom data attribute is an attribute in no namespace whose name starts with the string "data-", has at least one character after the hyphen, is XML-compatible, and contains no ASCII upper alphas.html:CustomElement
A custom element is an element that is custom. Informally, this means that its constructor and prototype are defined by the author, instead of by the user agent. This author-supplied constructor function is called the custom element constructor. Two distinct types of custom elements can be defined: An autonomous custom element, which is defined with no extends option. These types of custom elements have a local name equal to their defined name. A customized built-in element, which is defined with an extends option. These types of custom elements have a local name equal to the value passed in their extends option, and their defined name is used as the value of the is attribute, which therefore must be a valid custom element name.html:CustomizedBuiltInElement
A customized built-in element is a custom HTML element that is defined with an extends option. These types of custom elements have a local name equal to the value passed in their extends option, and their defined name is used as the value of the is attribute, which therefore must be a valid custom element name.html:Data
The <data> HTML element links a given piece of content with a machine-readable translation. If the content is time- or date-related, the <time> element must be used.html:DataCell
The data cell (<td> element) represents a cell in a table that contains some unspecified form of data.html:Datalist
The <datalist> HTML element contains a set of <option> elements that represent the permissible or recommended options available to choose from within other controls.html:Dd
The <dd> HTML element provides the description, definition, or value for the preceding term (<dt>) in a description list (<dl>).html:Del
The <del> HTML 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.html:Details
The <details> HTML element creates a disclosure widget in which information is visible only when the widget is toggled into an "open" state. A summary or label must be provided using the <summary> element.html:Dfn
The <dfn> HTML element is used to indicate the term being defined within the context of a definition phrase or sentence. The <p> element, the <dt>/<dd> pairing, or the <section> element which is the nearest ancestor of the <dfn> is considered to be the definition of the term.html:Dialog
The <dialog> HTML element represents a dialog box or other interactive component, such as a dismissible alert, inspector, or subwindow.html:Div
The <div> HTML element is the generic container for flow content. It has no effect on the content or layout until styled in some way using CSS (e.g. styling is directly applied to it, or some kind of layout model like Flexbox is applied to its parent element).html:Dl
The <dl> HTML 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).html:Document
An HTML document consists of a tree of elements and text. Each element is denoted in the source by a start tag, such as ‘<body>’, and an end tag, such as ‘</body>’. Tags have to be nested such that elements are all completely within each other, without overlapping. Elements can have attributes, which control how the elements work. The HTML vocabulary defines a set of elements that can be used in a HTML document, along with rules about the ways in which the elements can be nested. HTML user agents (e.g., web browsers) parse a HTML document, turning it into a DOM (Document Object Model) tree. A DOM tree is an in-memory representation of a document. A HTML document represents a media-independent description of interactive content. A HTML document might be rendered to a screen, or through a speech synthesizer, or on a braille display. To influence exactly how such rendering takes place, authors can use a styling language such as CSS.html:DocumentType
A DOCTYPE is a required preamble. When omitted, browsers tend to use a different rendering mode that is incompatible with some specifications. Including the DOCTYPE in a document ensures that the browser makes a best-effort attempt at following the relevant specifications.html:Dt
The <dt> HTML element specifies a term in a description or definition list, and as such must be used inside a <dl> element. It is usually followed by a <dd> element; however, multiple <dt> elements in a row indicate several terms that are all defined by the immediate next <dd> element.html:Element
An HTML element in the Document Object Model (DOM) represents a thing; that is, it has intrinsic meaning, also known as semantics. An element consists of an HTML start tag and an HTML end tag and has value content. An HTML start tag consists of a "smaller than" character ("<") and a tag name, followed by a "greater than" character (">"). An HTML end tag consists of a "smaller than" character ("<"), a slash ("/") and a tag name, followed by a "greater than" character (">"). The value content of an element can be arbitrarily complex.html:Em
The <em> HTML element marks text that has stress emphasis. The <em> element can be nested, with each level of nesting indicating a greater degree of emphasis.html:Embed
The <embed> HTML 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.html:EmbeddedContent
Embedded content is content that imports another resource into the document, or content from another vocabulary that is inserted into the document.html:EscapableRawTextElement
HTML element where the text inside is treated as raw text and not parsed as HTML, but character references can still be escaped within their text content.html:EventHandlerContentAttribute
An event handler content attribute is a content attribute for a specific event handler. The name of the content attribute is the same as the name of the event handler.html:Fieldset
The <fieldset> HTML element is used to group several controls as well as labels (<label>) within a web form.html:Figcaption
The <figcaption> HTML element represents a caption or legend describing the rest of the contents of its parent <figure> element.html:Figure
The <figure> HTML 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.html:FlowContent
Most elements that are used in the body of documents and applications are categorized as flow content.html:Footer
The <footer> HTML 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 or links to related documents.html:ForeignElement
HTML element from a namespace other than the HTML namespace.html:Form
The <form> HTML element represents a document section containing interactive controls for submitting information.html:FormAssociatedElement
A number of the elements are form-associated elements, which means they can have a form owner.html:GlobalAttribute
An attribute that is common to and may be specified on all HTML elements (even those not defined in this specification).html:H1
The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.html:H2
The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.html:H3
The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.html:H4
The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.html:H5
The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.html:H6
The <h1> to <h6> HTML elements represent six levels of section headings. <h1> is the highest section level and <h6> is the lowest.html:Head
The <head> HTML element contains machine-readable information (metadata) about the document, like its title, scripts, and style sheets.html:Header
The <header> HTML 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.html:HeaderCell
The <th> element represents a header cell in a table.html:HeadingContent
Heading content defines the heading of a section (whether explicitly marked up using sectioning content elements, or implied by the heading content itself).html:Hgroup
The <hgroup> HTML element represents a multi-level heading for a section of a document. It groups a set of <h1>-<h6> elements.html:Hr
The <hr> HTML 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.html:Html
The <html> HTML element represents the root (top-level element) of an HTML document, so it is also referred to as the root element or document element. All other elements must be descendants of this element.html:I
The <i> HTML element represents a range of text that is set off from the normal text for some reason, such as idiomatic text, technical terms, taxonomical designations, among others. Historically, these have been presented using italicized type, which is the original source of the <i> naming of this element.html:Iframe
The <iframe> HTML element represents a nested browsing context, embedding another HTML page into the current one.html:Img
The <img> HTML element embeds an image into the document.html:Input
The <input> HTML 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. The <input> element is one of the most powerful and complex in all of HTML due to the sheer number of combinations of input types and attributes.html:Ins
The <ins> HTML element represents a range of text that has been added to a document. You can use the <del> element to similarly represent a range of text that has been deleted from the document.html:InteractiveContent
Interactive content is content that is specifically intended for user interaction.html:Kbd
The <kbd> HTML element represents a span of inline text denoting textual user input from a keyboard, voice input, or any other text entry device. By convention, the user agent defaults to rendering the contents of a <kbd> element using its default monospace font, although this is not mandated by the HTML standard.html:Label
The <label> HTML element represents a caption for an item in a user interface.html:LabelableElement
Some elements, not all of them form-associated, are categorized as labelable elements. These are elements that can be associated with a label element.html:Legend
The <legend> HTML element represents a caption for the content of its parent <fieldset>.html:Li
The <li> HTML element is used to represent an item in a list. It must be contained in a parent element: an ordered list (<ol>), an unordered list (<ul>), or a menu (<menu>). In menus and unordered lists, list items are usually displayed using bullet points. In ordered lists, they are usually displayed with an ascending counter on the left, such as a number or letter.html:Link
The link element allows authors to link their document to other resources.html:ListedElement
Denotes elements that are listed in the form.elements and fieldset.elements APIs. These elements also have a form content attribute, and a matching form IDL attribute, that allow authors to specify an explicit form owner.html:Main
The <main> HTML 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.html:Map
The <map> HTML element is used with <area> elements to define an image map (a clickable link area).html:Mark
The <mark> HTML element 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.html:Menu
The <menu> HTML element is a semantic alternative to <ul>. It represents an unordered list of items (represented by <li> elements), each of these represent a link or other command that the user can activate.html:Meta
The <meta> HTML element can represent document-level metadata with the name attribute, pragma directives with the http-equiv attribute, and the file's character encoding declaration when an HTML document is serialized to string form (e.g. for transmission over the network or for disk storage) with the charset attribute.html:MetadataContent
Metadata content is content that sets up the presentation or behavior of the rest of the content, or that sets up the relationship of the document with other documents, or that conveys other "out of band" information.html:Meter
The <meter> HTML element represents either a scalar value within a known range or a fractional value.html:Nav
The <nav> HTML 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.html:NormalElement
Exclusionary definition: the elements that are neither (1) void elements, (2) the template element, (3) raw text elements, (4) escapable raw text elements, nor (5) foreign elements.html:Noscript
The <noscript> HTML 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.html:Object
The <object> HTML 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.html:Ol
The <ol> HTML element represents an ordered list of items - typically rendered as a numbered list.html:Optgroup
The <optgroup> HTML element creates a grouping of options within a <select> element.html:Option
The <option> HTML 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.html:Output
The <output> HTML element is a container element into which a site or app can inject the results of a calculation or the outcome of a user action.html:P
The <p> HTML element represents a paragraph. Paragraphs are usually represented in visual media as blocks of text separated from adjacent blocks by blank lines and/or first-line indentation, but HTML paragraphs can be any structural grouping of related content, such as images or form fields.html:PalpableContent
As a general rule, elements whose content model allows any flow content or phrasing content should have at least one node in its contents that is palpable content and that does not have the hidden attribute specified.html:PhrasingContent
Phrasing content is the text of the document, as well as elements that mark up that text at the intra-paragraph level. Runs of phrasing content form paragraphs.html:Picture
The <picture> HTML element contains zero or more <source> elements and one <img> element to offer alternative versions of an image for different display/device scenarios.html:Pre
The <pre> HTML 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, or monospaced, font. Whitespace inside this element is displayed as written.html:Progress
The <progress> HTML element displays an indicator showing the completion progress of a task, typically displayed as a progress bar.html:Q
The <q> HTML element indicates that the enclosed text is a short inline quotation. Most modern browsers implement this by surrounding the text in quotation marks. This element is intended for short quotations that don't require paragraph breaks; for long quotations use the <blockquote> element.html:RawTextElement
HTML element where the text inside is treated as raw text and not parsed as HTML.html:ResettableElement
Denotes elements that can be affected when a form element is reset.html:Row
The <tr> element represents a row of cells in a table.html:Rp
The <rp> HTML element is used to provide fall-back parentheses for browsers that do not support display of ruby annotations using the <ruby> element. One <rp> element should enclose each of the opening and closing parentheses that wrap the <rt> element that contains the annotation's text.html:Rt
The <rt> HTML element specifies the ruby text component of a ruby annotation, which is used to provide pronunciation, translation, or transliteration information for East Asian typography. The <rt> element must always be contained within a <ruby> element.html:Ruby
The <ruby> HTML element represents small annotations that are rendered above, below, or next to base text, usually used for showing the pronunciation of East Asian characters. It can also be used for annotating other kinds of text, but this usage is less common.html:S
The <s> HTML 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.html:Samp
The <samp> HTML element is used to enclose inline text which represents sample (or quoted) output from a computer program. Its contents are typically rendered using the browser's default monospaced font (such as Courier or Lucida Console).html:Script
The <script> HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code. The <script> element can also be used with other languages, such as WebGL's GLSL shader programming language and JSON.html:ScriptSupportingElement
Script-supporting elements are those that do not represent anything themselves (i.e. they are not rendered), but are used to support scripts, e.g. to provide functionality for the user.html:Search
The <search> element represents a part of a document or application that contains a set of form controls or other content related to performing a search or filtering operation. This could be a search of the web site or application; a way of searching or filtering search results on the current web page; or a global or Internet-wide search function.html:Section
The <section> HTML element represents a generic standalone section of a document, which doesn't have a more specific semantic element to represent it. Sections should always have a heading, with very few exceptions.html:SectioningContent
Sectioning content is content that defines the scope of header and footer elements.html:Select
The <select> HTML element represents a control that provides a menu of options:html:Slot
The <slot> HTML 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.html:Small
The <small> HTML element represents side-comments and small print, like copyright and legal text, independent of its styled presentation. By default, it renders text within it one font-size smaller, such as from small to x-small.html:Source
The <source> HTML element specifies multiple media resources for the <picture>, the <audio> element, or the <video> element. It is an empty element, meaning that it has no content and does not have a closing tag. It is commonly used to offer the same media content in multiple file formats in order to provide compatibility with a broad range of browsers given their differing support for image file formats and media file formats.html:Span
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 element.html:Strong
The <strong> HTML element indicates that its contents have strong importance, seriousness, or urgency. Browsers typically render the contents in bold type.html:StyleSheet
The <style> HTML element contains style information for a document, or part of a document. It embeds a CSS style sheet, which is applied to the contents of the document containing the <style> element.html:Sub
The <sub> HTML element specifies inline text which should be displayed as subscript for solely typographical reasons. Subscripts are typically rendered with a lowered baseline using smaller text.html:SubmittableElement
Denotes elements that can be used for constructing the entry list when a form element is submitted.html:Summary
The <summary> HTML 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.html:Sup
The <sup> HTML element specifies inline text which should be displayed as superscript for solely typographical reasons. Superscripts are typically rendered with half a character above the normal line, and are sometimes rendered in a smaller font.html:Table
A table (<table> element) represents data with more than one dimension. Tables have rows, columns, and cells given by their descendants. The rows and columns form a grid; a table its cells must completely cover that grid without overlap.html:TableBody
The table body (<tbody> element) represents a block of rows that consist of a body of data for the parent table.html:TableFooter
The table footer (<tfoot> element) represents the block of rows that consist of the column summaries (footers) for the parent table.html:TableHeader
The table header (<thead> element) represents the block of rows that consist of the column labels (headers) for the parent table.html:Template
The <template> HTML element is a mechanism for holding HTML that is not to be rendered immediately when a page is loaded but may be instantiated subsequently during runtime using JavaScript.html:Text
Textual content that does not contain any HTML vocabulary.html:Textarea
The <textarea> HTML 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.html:Time
The <time> HTML element represents a specific period in time. It may include the datetime attribute to translate dates into machine-readable format, allowing for better search engine results or custom features such as reminders.html:Title
The Title (<title> element) defines a document its title that is shown in a browser title bar or a page tab. It only contains text; tags within the element are ignored.html:Track
The <track> HTML 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.html:U
The <u> HTML element represents a span of inline text which should be rendered in a way that indicates that it has a non-textual annotation. This is rendered by default as a simple solid underline, but may be altered using CSS.html:Ul
The <ul> HTML element represents an unordered list of items, typically rendered as a bulleted list.html:Var
The <var> HTML element represents the name of a variable in a mathematical expression or a programming context. It's typically presented using an italicized version of the current typeface, although that behavior is browser-dependent.html:Video
The <video> HTML element embeds a media player which supports video playback into the document. You can use <video> for audio content as well, but the <audio> element may provide a more appropriate user experience.html:VoidElement
A HTML element whose content model never allows it to have contents under any circumstances. Void elements can have attributes.html:Wbr
The <wbr> HTML 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.
[=Object Properties/html:extends=]
Specifies the element that is extended by the custom element.
[=Datatype Properties/html:abbr=]
Specifies an abbreviated version of a text, typically used for providing a shortened form or acronym.[=Datatype Properties/html:accept-charset=]
Specifies the character encodings that are to be used for form submission.[=Datatype Properties/html:accept=]
Specifies the types of files that the server accepts through the file input.[=Datatype Properties/html:accesskey=]
Defines a keyboard shortcut for accessing an element.[=Datatype Properties/html:action=]
Specifies the URL to which the form's data will be submitted when the form is submitted.[=Datatype Properties/html:allow=]
Used with the <iframe> element to specify a feature policy for the embedded content.[=Datatype Properties/html:allowfullscreen=]
Used with the <iframe> element to allow the embedded content to be displayed in fullscreen mode.[=Datatype Properties/html:alt=]
Provides alternative text for an image, describing the content or function of the image.[=Datatype Properties/html:as=]
Specifies the media type (or file type) of a resource referenced by the <link> element.[=Datatype Properties/html:async=]
Indicates that the script should be executed asynchronously as soon as it is available.[=Datatype Properties/html:attribute=]
Property that is the parent property of all existing HTML attributes. An attribute is a name-value pair that is associated with an HTML element. Attributes provide additional information about an element and are specified within the start tag of an element. Attributes can modify the behavior or appearance of an element, define relationships between elements, or provide other metadata. The name of the attribute is followed by an equal sign (=) and the attribute's value, which is enclosed in double or single quotes. Some attributes affect the element simply by their presence in the start tag of the element, with the value implicitly being an empty string.[=Datatype Properties/html:autocapitalize=]
Controls whether and how text input is automatically capitalized as it is entered or edited.[=Datatype Properties/html:autocomplete=]
Specifies whether a form or text input should have autocomplete enabled.[=Datatype Properties/html:autofocus=]
Specifies that an input element should automatically get focus when the page loads.[=Datatype Properties/html:autoplay=]
Specifies that the audio or video should start playing as soon as it is ready.[=Datatype Properties/html:blocking=]
Indicates that the fetching of a resource should block the loading of the page until the resource is fetched.[=Datatype Properties/html:charset=]
Specifies the character encoding used in an external script file.[=Datatype Properties/html:checked=]
Indicates whether a checkbox or radio button is initially selected or checked.[=Datatype Properties/html:cite=]
Contains a URL that provides a citation or reference to a source.[=Datatype Properties/html:class=]
Specifies one or more class names for an HTML element, which can be used by CSS to style the element.[=Datatype Properties/html:color=]
Specifies the text color of an element's content.[=Datatype Properties/html:cols=]
Specifies the visible width of a text area, in average character widths.[=Datatype Properties/html:colspan=]
Specifies the number of columns a table cell should span.[=Datatype Properties/html:content=]
Specifies the value associated with the http-equiv or name attribute.[=Datatype Properties/html:contenteditable=]
Indicates whether the content of an element is editable.[=Datatype Properties/html:controls=]
Indicates whether video or audio should display controls (like play, pause, etc.).[=Datatype Properties/html:coords=]
Specifies the coordinates of the area in an image map.[=Datatype Properties/html:crossorigin=]
Controls how the element handles crossorigin requests.[=Datatype Properties/html:data=]
Used to link the element to machine-readable data.[=Datatype Properties/html:datetime=]
Specifies the date and time associated with the element.[=Datatype Properties/html:decoding=]
Specifies how the browser should decode an image.[=Datatype Properties/html:default=]
Specifies whether a track should be enabled by default in the media element.[=Datatype Properties/html:defer=]
Specifies that the script should be executed after the page has been parsed.[=Datatype Properties/html:dir=]
Specifies the text direction for the content in an element.[=Datatype Properties/html:dirname=]
Specifies the name of the directory for the text in an input field.[=Datatype Properties/html:disabled=]
Indicates whether an element should be disabled or not.[=Datatype Properties/html:documentTypeName=]
Specifies the doctype name of a doctype declaration in a HTML document.[=Datatype Properties/html:download=]
Specifies that the target will be downloaded when a user clicks on the hyperlink.[=Datatype Properties/html:draggable=]
Specifies whether an element is draggable or not.[=Datatype Properties/html:enctype=]
Specifies the character encoding used in the form data when it is submitted.[=Datatype Properties/html:enterkeyhint=]
Specifies a hint for the type of action that should be taken when the enter key is pressed.[=Datatype Properties/html:fetchpriority=]
Sets the priority of the fetch operation for the resource.[=Datatype Properties/html:for=]
Specifies the form element that the label is associated with.[=Datatype Properties/html:form=]
Specifies the form an input element belongs to.[=Datatype Properties/html:formaction=]
Specifies the URL for form submission for the input element.[=Datatype Properties/html:formenctype=]
Specifies the character encoding for the form submission for the input element.[=Datatype Properties/html:formmethod=]
Specifies the HTTP method for form submission for the input element.[=Datatype Properties/html:formnovalidate=]
Specifies that the form should not be validated when submitted.[=Datatype Properties/html:formtarget=]
Specifies where to display the response after submitting the form for the input element.[=Datatype Properties/html:fragment=]
Property that links the html fragment to a node in a document, representing the HTML document itself or the document type, HTML element, text, CDATA section or comment within that HTML document. [=Datatype Properties/html:headers=]
Specifies a space-separated list of header names that are sent with the request.[=Datatype Properties/html:height=]
Specifies the height of the content area of an element.[=Datatype Properties/html:hidden=]
Specifies that an element is not yet, or is no longer, relevant.[=Datatype Properties/html:high=]
Specifies the range that is considered the upper limit of the element.[=Datatype Properties/html:href=]
Specifies the URL of the linked resource.[=Datatype Properties/html:hreflang=]
Specifies the language of the linked resource.[=Datatype Properties/html:http-equiv=]
Provides an HTTP header for the information/value of the content attribute.[=Datatype Properties/html:id=]
Specifies a unique id for an HTML element.[=Datatype Properties/html:imagesizes=]
Specifies the sizes of the icons for visual media contained in the resource.[=Datatype Properties/html:imagesrcset=]
Specifies a list of possible images to use for the visual media contained in the resource.[=Datatype Properties/html:inert=]
Indicates that an element and its descendants are not to be rendered or considered interactive.[=Datatype Properties/html:inputmode=]
Specifies the type of user interface to display for the editing control.[=Datatype Properties/html:integrity=]
Specifies a cryptographic hash of the resource for integrity checking.[=Datatype Properties/html:is=]
Specifies the custom element's local name.[=Datatype Properties/html:ismap=]
Indicates that an image is part of a server-side image map.[=Datatype Properties/html:itemid=]
Specifies a unique identifier for the item in a list.[=Datatype Properties/html:itemprop=]
Specifies the property or properties the element represents.[=Datatype Properties/html:itemref=]
Specifies additional items that are related to the item in a list.[=Datatype Properties/html:itemscope=]
Creates a new item in the HTML data model.[=Datatype Properties/html:itemtype=]
Specifies the type of the item in a list.[=Datatype Properties/html:key=]
Property that links the key name of a specific HTML attribute to that HTML attribute.[=Datatype Properties/html:kind=]
Specifies the kind of text track, such as subtitles, captions, or descriptions.[=Datatype Properties/html:label=]
Specifies a user-readable description for the form element.[=Datatype Properties/html:lang=]
Specifies the language of the element's content or the value of an input element.[=Datatype Properties/html:list=]
Refers to a <datalist> element that contains pre-defined options for an <input> element.[=Datatype Properties/html:loading=]
Specifies how the browser should load an external resource.[=Datatype Properties/html:loop=]
Specifies that the audio or video should play again after it has finished.[=Datatype Properties/html:low=]
Specifies the range that is considered the lower limit of the element.[=Datatype Properties/html:max=]
Specifies the maximum value for an input element.[=Datatype Properties/html:maxlength=]
Specifies the maximum number of characters allowed in an input element.[=Datatype Properties/html:media=]
Specifies the media type or media query for the linked resource.[=Datatype Properties/html:method=]
Specifies the HTTP method for form submission.[=Datatype Properties/html:min=]
Specifies the minimum value for an input element.[=Datatype Properties/html:minlength=]
Specifies the minimum number of characters required in an input element.[=Datatype Properties/html:multiple=]
Indicates that multiple values can be selected in an input element.[=Datatype Properties/html:muted=]
Specifies that the audio output of the video should be muted.[=Datatype Properties/html:name=]
Specifies the name of an HTML element, used as a reference when submitting a form or scripting.[=Datatype Properties/html:nomodule=]
Specifies that a script should not be executed in browsers that support ES6 modules.[=Datatype Properties/html:nonce=]
Specifies a cryptographic nonce that can be used to validate the origin of a script.[=Datatype Properties/html:novalidate=]
Specifies that a form should not be validated when submitted.[=Datatype Properties/html:onafterprint=]
Specifies the afterprint event handler for a Window object.[=Datatype Properties/html:onauxclick=]
Specifies the auxclick event handler.[=Datatype Properties/html:onbeforeinput=]
Specifies the beforeinput event handler.[=Datatype Properties/html:onbeforematch=]
Specifies the beforematch event handler.[=Datatype Properties/html:onbeforeprint=]
Specifies the beforeprint event handler for a Window object.[=Datatype Properties/html:onbeforetoggle=]
Specifies the beforetoggle event handler.[=Datatype Properties/html:onbeforeunload=]
Specifies the beforeunload event handler for a Window object.[=Datatype Properties/html:onblur=]
Specifies the blur event handler.[=Datatype Properties/html:oncancel=]
Specifies the cancel event handler.[=Datatype Properties/html:oncanplay=]
Specifies the canplay event handler.[=Datatype Properties/html:oncanplaythrough=]
Specifies the canplaythrough event handler.[=Datatype Properties/html:onchange=]
Specifies the change event handler.[=Datatype Properties/html:onclick=]
Specifies the click event handler.[=Datatype Properties/html:onclose=]
Specifies the close event handler.[=Datatype Properties/html:oncontextlost=]
Specifies the contextlost event handler.[=Datatype Properties/html:oncontextmenu=]
Specifies the contextmenu event handler.[=Datatype Properties/html:oncontextrestored=]
Specifies the contextrestored event handler.[=Datatype Properties/html:oncopy=]
Specifies the copy event handler.[=Datatype Properties/html:oncuechange=]
Specifies the cuechange event handler.[=Datatype Properties/html:oncut=]
Specifies the cut event handler.[=Datatype Properties/html:ondblclick=]
Specifies the dblclick event handler.[=Datatype Properties/html:ondrag=]
Specifies the drag event handler.[=Datatype Properties/html:ondragend=]
Specifies the dragend event handler.[=Datatype Properties/html:ondragenter=]
Specifies the dragenter event handler.[=Datatype Properties/html:ondragleave=]
Specifies the dragleave event handler.[=Datatype Properties/html:ondragover=]
Specifies the dragover event handler.[=Datatype Properties/html:ondragstart=]
Specifies the dragstart event handler.[=Datatype Properties/html:ondrop=]
Specifies the drop event handler.[=Datatype Properties/html:ondurationchange=]
Specifies the durationchange event handler.[=Datatype Properties/html:onemptied=]
Specifies the emptied event handler.[=Datatype Properties/html:onended=]
Specifies the ended event handler.[=Datatype Properties/html:onerror=]
Specifies the error event handler.[=Datatype Properties/html:onfocus=]
Specifies the focus event handler.[=Datatype Properties/html:onformdata=]
Specifies the formdata event handler.[=Datatype Properties/html:onhashchange=]
Specifies the hashchange event handler for Window object.[=Datatype Properties/html:oninput=]
Specifies the input event handler.[=Datatype Properties/html:oninvalid=]
Specifies the invalid event handler.[=Datatype Properties/html:onkeydown=]
Specifies the keydown event handler.[=Datatype Properties/html:onkeypress=]
Specifies the keypress event handler.[=Datatype Properties/html:onkeyup=]
Specifies the keyup event handler.[=Datatype Properties/html:onlanguagechange=]
Specifies the languagechange event handler for a Window object.[=Datatype Properties/html:onload=]
Specifies the load event handler.[=Datatype Properties/html:onloadeddata=]
Specifies the loadeddata event handler.[=Datatype Properties/html:onloadedmetadata=]
Specifies the loadedmetadata event handler.[=Datatype Properties/html:onloadstart=]
Specifies the loadstart event handler.[=Datatype Properties/html:onmessage=]
Specifies the message event handler.[=Datatype Properties/html:onmessageerror=]
Specifies the messageerror event handler for a Window object.[=Datatype Properties/html:onmousedown=]
Specifies the mousedown event handler.[=Datatype Properties/html:onmouseenter=]
Specifies the mouseenter event handler.[=Datatype Properties/html:onmouseleave=]
Specifies the mouseleave event handler.[=Datatype Properties/html:onmousemove=]
Specifies the mousemove event handler.[=Datatype Properties/html:onmouseout=]
Specifies the mouseout event handler.[=Datatype Properties/html:onmouseover=]
Specifies the mouseover event handler.[=Datatype Properties/html:onmouseup=]
Specifies the mouseup event handler.[=Datatype Properties/html:onpaste=]
Specifies the paste event handler.[=Datatype Properties/html:onpause=]
Specifies the pause event handler.[=Datatype Properties/html:onplay=]
Specifies the play event handler.[=Datatype Properties/html:onplaying=]
Specifies the playing event handler.[=Datatype Properties/html:onpopstate=]
Specifies the popstate event handler for Window object.[=Datatype Properties/html:onprogress=]
Specifies the progress event handler.[=Datatype Properties/html:onratechange=]
Specifies the ratechange event handler.[=Datatype Properties/html:onrejectionhandled=]
Specifies the rejectionhandled event handler for Window object.[=Datatype Properties/html:onreset=]
Specifies the reset event handler.[=Datatype Properties/html:onresize=]
Specifies the resize event handler.[=Datatype Properties/html:onscroll=]
Specifies the scroll event handler.[=Datatype Properties/html:onscrollend=]
Specifies the scrollend event handler.[=Datatype Properties/html:onsecuritypolicyviolation=]
Specifies the securitypolicyviolation event handler.[=Datatype Properties/html:onseeked=]
Specifies the seeked event handler.[=Datatype Properties/html:onseeking=]
Specifies the seeking event handler.[=Datatype Properties/html:onselect=]
Specifies the select event handler.[=Datatype Properties/html:onslotchange=]
Specifies the slotchange event handler.[=Datatype Properties/html:onstalled=]
Specifies the stalled event handler.[=Datatype Properties/html:onstorage=]
Specifies the storage event handler for a Window object.[=Datatype Properties/html:onsubmit=]
Specifies the submit event handler.[=Datatype Properties/html:onsuspend=]
Specifies the suspend event handler.[=Datatype Properties/html:ontimeupdate=]
Specifies the timeupdate event handler.[=Datatype Properties/html:ontoggle=]
Specifies the toggle event handler.[=Datatype Properties/html:onunhandledrejection=]
Specifies the unhandledrejection event handler for Window object.[=Datatype Properties/html:onunload=]
Specifies the unload event handler for Window object.[=Datatype Properties/html:onvolumechange=]
Specifies the volumechange event handler.[=Datatype Properties/html:onwaiting=]
Specifies the waiting event handler.[=Datatype Properties/html:onwheel=]
Specifies the wheel event handler.[=Datatype Properties/html:open=]
Indicates whether the details element is open (visible) or not.[=Datatype Properties/html:optimum=]
Specifies the optimal numeric value for the gauge.[=Datatype Properties/html:pattern=]
Specifies a regular expression pattern that the input's value must match.[=Datatype Properties/html:ping=]
Specifies a space-separated list of URLs to which, when the resource is activated, post requests with the element's activation behavior should be sent.[=Datatype Properties/html:placeholder=]
Specifies a short hint that describes the expected value of an input element.[=Datatype Properties/html:playsinline=]
Specifies that the video should be played in-line with the other content on the page.[=Datatype Properties/html:popover=]
Specifies additional information or controls for an element, typically shown as a tooltip or pop-up.[=Datatype Properties/html:popovertarget=]
Specifies the target element for a popover, indicating where additional information or controls should be displayed.[=Datatype Properties/html:popovertargetaction=]
Specifies an action associated with a target element for a popover.[=Datatype Properties/html:poster=]
Specifies an image to be shown while the video is downloading or until the user hits the play button.[=Datatype Properties/html:preload=]
Specifies how the browser should load the audio or video.[=Datatype Properties/html:readonly=]
Specifies that an input field is read-only and cannot be edited by the user.[=Datatype Properties/html:referrerpolicy=]
Specifies which referrer information should be included when making requests.[=Datatype Properties/html:rel=]
Specifies the relationship between the current document and the linked resource.[=Datatype Properties/html:required=]
Specifies that an input field must be filled out before submitting the form.[=Datatype Properties/html:resource=]
Specifies the URL of the linked resource when used in a link or area element.[=Datatype Properties/html:reversed=]
Specifies that the list order should be descending, instead of ascending.[=Datatype Properties/html:rows=]
Specifies the visible number of lines in a text area.[=Datatype Properties/html:rowspan=]
Specifies the number of rows a table cell should span.[=Datatype Properties/html:sandbox=]
Enables an extra set of restrictions for the content in an iframe.[=Datatype Properties/html:scope=]
Specifies whether a header cell is a header for a column, row, or group of columns or rows.[=Datatype Properties/html:selected=]
Specifies that an option in a dropdown list should be pre-selected when the page loads.[=Datatype Properties/html:shape=]
Specifies the shape of the hot spot in an image map.[=Datatype Properties/html:size=]
Specifies the size of the font in a <font> element.[=Datatype Properties/html:sizes=]
Specifies the sizes of the images for different viewport widths.[=Datatype Properties/html:slot=]
Specifies the name of the slot the element belongs to when used in a shadow DOM.[=Datatype Properties/html:span=]
Specifies the number of columns a table cell should span.[=Datatype Properties/html:spellcheck=]
Specifies whether the browser should check the spelling and grammar of the text in an element.[=Datatype Properties/html:src=]
Specifies the URL of the media resource.[=Datatype Properties/html:srcdoc=]
Specifies the HTML content of the page to show in an iframe.[=Datatype Properties/html:srclang=]
Specifies the language of the text track (subtitles or captions) referenced by the <track> element.[=Datatype Properties/html:srcset=]
Specifies a list of possible images to use for the visual media contained in the resource.[=Datatype Properties/html:start=]
Specifies the starting value of a list item.[=Datatype Properties/html:step=]
Specifies the legal number intervals for an input field.[=Datatype Properties/html:style=]
Specifies inline CSS styles for an element.[=Datatype Properties/html:tabindex=]
Specifies the tab order of an element.[=Datatype Properties/html:tag=]
Property that links the tag name of a specific HTML element to that element.[=Datatype Properties/html:target=]
Specifies where to open the linked document when the link is clicked.[=Datatype Properties/html:template=]
Property that links a literal to a template element to declare fragments of HTML that can be inserted into HTML documents.[=Datatype Properties/html:title=]
Specifies extra information about an element, often displayed as a tooltip.[=Datatype Properties/html:translate=]
Specifies whether the content of an element should be translated when the page is localized.[=Datatype Properties/html:type=]
Specifies the type of the element, such as the type of an input field.[=Datatype Properties/html:usemap=]
Specifies the name of a client-side image map to be used with the element.[=Datatype Properties/html:value=]
Specifies the initial value of an input element.[=Datatype Properties/html:width=]
Specifies the width of an element.[=Datatype Properties/html:wrap=]
Specifies how the text in a textarea is to be wrapped when submitted in a form.[=Datatype Properties/html:writingsuggestions=]
Specifies whether writing suggestions should be offered on this element.
[=Node Shapes/shp:CustomElement=]
A node shape to establish an individual custom element as a subclass of the class html:CustomElement.[=Node Shapes/shp:ForeignElement=]
A node shape to transform the contents of a foreign element into a html fragment.[=Node Shapes/shp:HTMLFragmentSerializationAlgorithm=]
A node shape with an algorithm to serialize an HTML fragment for a node in an HTML document.
[=SPARQL Targets/target:ForeignElement=]
A SPARQL Target to select all foreign element nodes in an HTML document that do not have an HTML fragment yet, but who do have a XML fragment.SPARQL query
select $this {
# Select all foreign element nodes with a XML fragment...
$this a/rdfs:subClassOf* html:ForeignElement;
xml:fragment [].
# ...that do not yet have an HTML fragment.
filter not exists { $this html:fragment []. }
} [=SPARQL Targets/target:HTMLFragmentSerializationAlgorithm=]
A SPARQL Target to select all nodes in an HTML document that do not have an HTML fragment yet, and whose child nodes all have an HTML fragment already.SPARQL query
select $this {
# Select all DOM nodes...
$this a/rdfs:subClassOf* dom:DocumentTreeNode.
# ...that do not yet have an HTML fragment.
filter not exists { $this html:fragment []. }
# ...but whose child nodes (if any) all have an HTML fragment
filter not exists {
$this ?member ?child.
filter(function:isMembershipProperty(?member))
filter not exists { ?child html:fragment []. }
?child a/rdfs:subClassOf* dom:DocumentTreeNode.
}
}
[=SPARQL Rules/rule:CustomElement=]
A SPARQL rule to establish an individual custom element as a subclass of the class html:CustomElement.SPARQL query
construct { $this rdfs:subClassOf html:CustomElement. }
where {} # Condition is already met via the target, hence empty where clause. [=SPARQL Rules/rule:ForeignElement=]
A SPARQL rule to establish a HTML fragment for a foreign element based on its XML fragment.SPARQL query
construct {
$this html:fragment ?fragment.
} where {
$this xml:fragment ?fragment.
} [=SPARQL Rules/rule:HTMLFragmentSerializationAlgorithm=]
A SPARQL rule to serialize an HTML fragment for a node in an HTML document, analogue to the HTML fragment serialisation algorithm as described in the living standard of HTML.SPARQL query
construct {
# Assert the new HTML fragment for this node in the HTML document
$this html:fragment ?fragment.
} where {
# Establish the class of the node in the HTML document
$this a/rdfs:subClassOf* ?htmlClass.
?htmlClass rdfs:isDefinedBy html:.
# Build the HTML fragment for the node in the HTML document depending on its class
bind(if(?htmlClass = html:Element, function:getElementFragment($this),
if(?htmlClass = html:Text, function:getTextFragment($this),
if(?htmlClass = html:Comment, function:getCommentFragment($this),
if(?htmlClass = html:ProcessingInstruction, function:getProcessingInstructionFragment($this),
if(?htmlClass = html:DocumentType, function:getDocumentTypeFragment($this),
if(?htmlClass = html:Document, function:getDocumentFragment($this), ?unboundDummy))))))
as ?fragmentString)
# Convert result from string to rdf:HTML if fragment exists
bind(if(bound(?fragmentString), strdt(?fragmentString, rdf:HTML), ?unboundDummy) as ?fragment)
}
[=SPARQL Functions/function:getChildNodeFragment=]
A SPARQL function that returns an HTML fragment of child nodes for a node in an HTML document.SPARQL query
select ?result {
optional {
# Get the HTML fragments of child nodes, if there are any.
select $parentNode (group_concat(str(?childFragment);separator='') as ?childFragments) {
{
select $parentNode ?member ?childFragment {
$parentNode ?member ?childNode.
filter(function:isMembershipProperty(?member))
?childNode html:fragment ?childFragment.
}
order by function:getMemberIndex(?member)
}
}
group by $parentNode
}
bind(coalesce(?childFragments, '') as ?result)
} [=SPARQL Functions/function:getCommentFragment=]
A SPARQL function that returns an HTML fragment for a comment node in an HTML document.SPARQL query
select ?result {
optional {
# Establish the HTML fragment for this HTML comment
bind(concat('<!--',function:getChildNodeFragment($comment),'-->') as ?fragment)
}
bind(coalesce(?fragment, '') as ?result)
} [=SPARQL Functions/function:getDocumentFragment=]
A SPARQL function that returns an HTML fragment for an HTML document.SPARQL query
select ?result {
optional {
# Establish the HTML fragment of the HTML document by retrieving the HTML fragments of all child nodes.
bind(function:getChildNodeFragment($document) as ?fragment)
}
bind(coalesce(?fragment, '') as ?result)
} [=SPARQL Functions/function:getDocumentTypeFragment=]
A SPARQL function that returns an HTML fragment for a document type in an HTML document.SPARQL query
select ?result {
optional {
# Establish the doctype name for this Document Type.
$doctype html:documentTypeName ?name.
bind(concat('<!DOCTYPE ',str(?name),'>') as ?fragment)
}
bind(coalesce(?fragment, '') as ?result)
} [=SPARQL Functions/function:getElementAttribute=]
A SPARQL function that returns an HTML fragment for the attributes of an HTML element.SPARQL query
select ?result {
optional {
# Get the HTML attributes for this element, if there are any.
select $element (group_concat(distinct ?attributeFragment) as ?attributeFragments) {
$element ?attribute ?value.
?attribute
a/rdfs:subClassOf* dom:Attribute;
?localName ?key.
?localName rdfs:subPropertyOf dom:localName.
bind(concat(?key,'="',str(?value),'"') as ?attributeFragment)
}
group by $element
}
bind(coalesce(?attributeFragments, '') as ?result)
} [=SPARQL Functions/function:getElementFragment=]
A SPARQL function that returns an HTML fragment for an element in an HTML document.SPARQL query
select ?result {
optional {
# Retrieve the tag name of the element.
$element a ?class.
?class
html:tag ?tag;
rdfs:subClassOf ?elementType.
# Get the HTML attributes for the element, if there are any.
bind(function:getElementAttribute($element) as ?attributes)
# Get the HTML fragments of child nodes for the element, if there are any.
bind(function:getChildNodeFragment($element) as ?childFragments)
# Build the HTML fragment for this HTML element, by combining everything retrieved above.
bind(concat(
'<',?tag,if(?attributes='','',concat(' ',?attributes)),'>',
# Void elements have neither content nor a closing tag.
if(?elementType=html:VoidElement,'',concat(?childFragments,'</',?tag,'>'))) as ?fragment)
}
bind(coalesce(?fragment, '') as ?result)
} [=SPARQL Functions/function:getMemberIndex=]
A SPARQL function that returns the sibling index of a node in an HTML document.SPARQL query
select(?index as $return) {
bind(strafter(str($property), concat(str(rdf:),'_')) as ?after)
bind(xsd:integer(?after) as ?index)
filter(isIRI($property) && ?index > 0 && ?after = str(?index))
} [=SPARQL Functions/function:getProcessingInstructionFragment=]
A SPARQL function that returns an HTML fragment for a processing instruction in an HTML document.SPARQL query
select ?result {
optional {
# Establish the HTML fragment for this HTML processingInstruction
bind(concat('<?',function:getChildNodeFragment($processingInstruction),'>') as ?fragment)
}
bind(coalesce(?fragment, '') as ?result)
} [=SPARQL Functions/function:getTextFragment=]
A SPARQL function that returns an HTML fragment for a text node in an HTML document.SPARQL query
select ?result {
# Text is stored in de data attribute of DOM text nodes
$text dom:data ?data.
optional {
# Establish the HTML fragment for this HTML text node
bind(strdt(?data,xsd:string) as ?fragment)
}
bind(coalesce(?fragment, '') as ?result)
} [=SPARQL Functions/function:isMembershipProperty=]
A SPARQL function that returns a boolean value based on whether a property is or is not an instance of the ContainerMembershipProperty class.SPARQL query
select $return {
bind(strafter(str($term), concat(str(rdf:),'_')) as ?after)
bind(xsd:integer(?after) as ?index)
bind(coalesce(isIRI($term) && ?index > 0 && ?after = str(?index), false) as $return)
}
[=SHACL Parameters/parameter:getMemberIndex_property=]
A SHACL parameter[=SHACL Parameters/parameter:isMembershipProperty_term=]
A SHACL parameter
Label: § 13.1.1 The DOCTYPE Label: § 13.1.2 Escapable raw text elements Label: § 13.1.2 Foreign elements Label: § 13.1.2 Normal elements Label: § 13.1.2 Raw text elements Label: § 13.1.2 Void elements Label: § 13.1.2.1 Start tags Label: § 13.1.2.2 End tags Label: § 13.1.2.3 Attributes Label: § 13.1.2 Elements Label: § 13.1.3 Text Label: § 13.1.5 CDATA sections Label: § 13.1.6 Comments Label: § 13.1 Writing HTML documents Label: § 13.3 Serializing HTML fragments Label: § 3.2.5.2.1 Metadata content Label: § 3.2.5.2.2 Flow content Label: § 3.2.5.2.3 Sectioning content Label: § 3.2.5.2.4 Heading content Label: § 3.2.5.2.5 Phrasing content Label: § 3.2.5.2.6 Metadata content Label: § 3.2.5.2.7 Interactive content Label: § 3.2.5.2.8 Palpable content Label: § 3.2.5.2.9 Script-supporting elements Label: § 3.2.5.2 Kinds of content Label: § 3.2.5.3 Transparant content models Label: § 3.2 Elements Label: § 4.1.1 The html element Label: § 4.10.10 The option element Label: § 4.10.11 The textarea element Label: § 4.10.12 The output element Label: § 4.10.13 The progress element Label: § 4.10.14 The meter element Label: § 4.10.15 The fieldset element Label: § 4.10.16 The legend element Label: § 4.10.2 Categories Label: § 4.10.3 The form element Label: § 4.10.4 The label element Label: § 4.10.5 The input element Label: § 4.10.6 The button element Label: § 4.10.7 The select element Label: § 4.10.8 The datalist element Label: § 4.10.9 The optgroup element Label: § 4.11.1 The details element Label: § 4.11.2 The summary element Label: § 4.11.4 The dialog element Label: § 4.12.1 The script element Label: § 4.12.2 The noscript element Label: § 4.12.3 The template element Label: § 4.12.4 The slot element Label: § 4.12.5 The canvas element Label: § 4.13.3 Core concepts Label: § 4.2.1 The head element Label: § 4.2.2 The title element Label: § 4.2.2 The base element Label: § 4.2.4 The link element Label: § 4.2.5 The meta element Label: § 4.2.6 The style element Label: § 4.3.10 The address element Label: § 4.3.1 The body element Label: § 4.3.2 The article element Label: § 4.3.3 The section element Label: § 4.3.4 The nav element Label: § 4.3.5 The aside element Label: § 4.3.6 The h1, h2, h3, h4 and h6 elements Label: § 4.3.7 The hgroup element Label: § 4.3.8 The header element Label: § 4.3.9 The footer element Label: § 4.4.10 The dt element Label: § 4.4.11 The dd element Label: § 4.4.12 The figure element Label: § 4.4.13 The figcaption element Label: § 4.4.14 The main element Label: § 4.4.15 The search element Label: § 4.4.16 The div element Label: § 4.4.1 The p element Label: § 4.4.2 The hr element Label: § 4.4.3 The pre element Label: § 4.4.4 The blockquote element Label: § 4.4.5 The ol element Label: § 4.4.6 The ul element Label: § 4.4.7 The menu element Label: § 4.4.8 The li element Label: § 4.4.9 The dl element Label: § 4.5.10 The ruby element Label: § 4.5.11 The rt element Label: § 4.5.12 The rp element Label: § 4.5.13 The data element Label: § 4.5.14 The time element Label: § 4.5.15 The code element Label: § 4.5.16 The var element Label: § 4.5.17 The samp element Label: § 4.5.18 The kbd element Label: § 4.5.19 The sub and sup elements Label: § 4.5.1 The a element Label: § 4.5.20 The i element Label: § 4.5.21 The b element Label: § 4.5.22 The u element Label: § 4.5.23 The mark element Label: § 4.5.24 The bdi element Label: § 4.5.25 The bdo element Label: § 4.5.26 The span element Label: § 4.5.27 The br element Label: § 4.5.28 The wbr element Label: § 4.5.2 The em element Label: § 4.5.3 The strong element Label: § 4.5.4 The small element Label: § 4.5.5 The s element Label: § 4.5.6 The cite element Label: § 4.5.7 The q element Label: § 4.5.8 The dfn element Label: § 4.5.9 The abbr element Label: § 4.7.1 The ins element Label: § 4.7.2 The del element Label: § 4.8.10 The track element Label: § 4.8.12 The map element Label: § 4.8.13 The area element Label: § 4.8.15 MathML Label: § 4.8.16 SVG Label: § 4.8.1 The picture element Label: § 4.8.2 The source element Label: § 4.8.3 The img element Label: § 4.8.5 The iframe element Label: § 4.8.6 The embed element Label: § 4.8.7 The object element Label: § 4.8.8 The video element Label: § 4.8.9 The audio element Label: § 4.9.10 The th element Label: § 4.9.1 The table element Label: § 4.9.2 The caption element Label: § 4.9.3 The colgroup element Label: § 4.9.4. The col element Label: § 4.9.5 The tbody element Label: § 4.9.6 The thead element Label: § 4.9.7 The tfoot element Label: § 4.9.8 The tr element Label: § 4.9.9 The td element Label: § 8.1.8.1 Event handlers Label: § 8.1.8 Events Label: HTML Living Standard[=Named Individuals/section:13.1.1=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2-EscapableRawTextElements=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2-ForeignElements=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2-NormalElements=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2-RawTextElements=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2-VoidElements=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2.1=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2.2=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2.3=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.2=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.3=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.5=]
A section in the living standard of HTML.[=Named Individuals/section:13.1.6=]
A section in the living standard of HTML.[=Named Individuals/section:13.1=]
A section in the living standard of HTML.[=Named Individuals/section:13.3=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.1=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.2=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.3=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.4=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.5=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.6=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.7=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.8=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2.9=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.2=]
A section in the living standard of HTML.[=Named Individuals/section:3.2.5.3=]
A section in the living standard of HTML.[=Named Individuals/section:3.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.1.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.10=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.11=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.12=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.13=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.14=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.15=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.16=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.4=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.5=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.6=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.7=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.8=]
A section in the living standard of HTML.[=Named Individuals/section:4.10.9=]
A section in the living standard of HTML.[=Named Individuals/section:4.11.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.11.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.11.4=]
A section in the living standard of HTML.[=Named Individuals/section:4.12.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.12.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.12.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.12.4=]
A section in the living standard of HTML.[=Named Individuals/section:4.12.5=]
A section in the living standard of HTML.[=Named Individuals/section:4.13.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.2.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.2.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.2.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.2.4=]
A section in the living standard of HTML.[=Named Individuals/section:4.2.5=]
A section in the living standard of HTML.[=Named Individuals/section:4.2.6=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.10=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.4=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.5=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.6=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.7=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.8=]
A section in the living standard of HTML.[=Named Individuals/section:4.3.9=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.10=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.11=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.12=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.13=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.14=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.15=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.16=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.4=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.5=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.6=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.7=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.8=]
A section in the living standard of HTML.[=Named Individuals/section:4.4.9=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.10=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.11=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.12=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.13=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.14=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.15=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.16=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.17=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.18=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.19=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.20=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.21=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.22=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.23=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.24=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.25=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.26=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.27=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.28=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.4=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.5=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.6=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.7=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.8=]
A section in the living standard of HTML.[=Named Individuals/section:4.5.9=]
A section in the living standard of HTML.[=Named Individuals/section:4.7.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.7.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.10=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.12=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.13=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.15=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.16=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.5=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.6=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.7=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.8=]
A section in the living standard of HTML.[=Named Individuals/section:4.8.9=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.10=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.1=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.2=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.3=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.4=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.5=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.6=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.7=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.8=]
A section in the living standard of HTML.[=Named Individuals/section:4.9.9=]
A section in the living standard of HTML.[=Named Individuals/section:8.1.8.1=]
A section in the living standard of HTML.[=Named Individuals/section:8.1.8=]
A section in the living standard of HTML.[=Named Individuals/standard:html=]
HTML is the World Wide Web's core markup language. It is described in the WHATWG "HTML Living Standard" specification.
This is required for specifications that contain normative material.
This is required for specifications that contain normative material.
This document was automatically generated by OntoReSpec.