whatwg/html

Features

• Document Content Structuring - Establishes semantic elements and hierarchical structures to organize a document's content and layout.
• Document Object Models - Defines the fundamental system for representing and manipulating document structures as hierarchical object trees.
• Event Loop Managers - Defines the core event loop orchestration that coordinates task execution and rendering updates.
• HTML Parsing - Implements the conversion of markup strings into a list of nodes based on the surrounding parent context.
• Form Validation - Enforces constraints on form controls such as required values and patterns to report validation errors.
• HTML Processing - Establishes the fundamental process of creating a document and associating it with a byte-stream parser.
• Document Metadata Management - Defines document-level information, character encoding, and external resource relationships using head and meta elements.
• Origin-Based Isolation - Implements security boundaries that prevent different origins from accessing each other's data and storage.
• URL Resolvers - Converts strings into URL records by resolving relative paths against a base URL and specific encoding.
• Markup Parsers - Converts raw markup strings into traversable document objects or fragments without triggering a render.
• HTML Tokenization - Defines the state-machine-based tokenization algorithm used to parse HTML documents.
• Element Focus Controllers - Defines how keyboard focus and navigation flow are managed between interactive UI elements.
• Background Task Runners - Provides the infrastructure for running tasks in background worker threads.
• Audio Playback - Represents a sound or audio stream with configurable playback and loading behaviors.
• Canvas Rendering - Provides a bitmap canvas for on-the-fly drawing of shapes, text, and images.
• Media Playback Controls - The HTML specification starts, pauses, and resets media playback and modifies the playback rate.
• Cross-Window Messaging - Establishes secure messaging channels and data transfers between windows, iframes, and background workers.
• Character Encoding Utilities - Identifies the correct character encoding of a byte stream using sniffing algorithms and metadata.
• Timer Schedulers - Implements interfaces for scheduling asynchronous tasks using timeouts and intervals via timer functions.
• Structured Cloning - Implements the structured clone algorithm for creating deep copies of complex data types for transfer between realms.
• Web Worker Execution - Allows scripts to run independently of the user interface to maintain page responsiveness.
• Cross-Origin Security Policies - Establishes the fundamental security boundary that isolates data and storage based on origin.
• HTML Content Sanitization - Filters dangerous elements and attributes from markup strings to prevent XSS during DOM insertion.
• HTTP Security Headers - Uses HTTP response headers to enforce cross-origin policies and embedding restrictions.
• CORS Policy Configurations - Configures whether resource requests use anonymous or credentialed modes for cross-origin sharing.
• Byte Stream Decoding - Converts an input byte stream into characters based on a determined encoding while handling invalid sequences.
• Microtask Queues - Implements the microtask queue scheduling algorithm as a fundamental part of the browser event loop.
• External Resource References - Displays an external resource as an image or child navigable using a specified URL.
• External Resource Associations - Connects the document to external assets like stylesheets or icons using defined relationship links.
• Project Metadata Declarations - Embeds key-value pairs and encoding declarations to describe the document using standardized metadata formats.
• DOM Tree Construction - Defines the core algorithm for building the document object model from parsed tokens.
• Accessibility Role Mapping - Defines the default ARIA roles for elements to ensure consistent interpretation by assistive technologies.
• Alternative Text Provisions - Assigns a text replacement for an image to ensure meaning remains intact for all users.
• Bidirectional Text Layouts - Implements mechanisms for handling and overriding text direction for bidirectional language support.
• Content Sectioning - Uses numbered heading levels to establish structural importance and organize sections.
• Foreign Namespace Integration - The HTML specification integrates elements from other namespaces, supporting self-closing tags and data escaping.
• CSS Styling - Defines the mechanism for embedding CSS styles directly within an HTML document.
• DOM Manipulators - Implements the core APIs for modifying the structure and attributes of the document tree at runtime.
• Element Groupings - The HTML specification provides a generic container for grouping elements for styling or semantic annotation.
• Focus Management - Manages keyboard focus movement to specific elements and controls the visibility of focus rings.
• Sequential Navigation Orders - Establishes the standard for defining sequential navigation order for focusable areas using indices.
• Form and Input Management - Defines constraints and validation logic, such as required attributes and patterns, to ensure valid user input.
• Input Validation Rules - Establishes declarative rules for validating input length, required fields, and format before submission.
• Interaction and Event Handling - Defines the logic for executing callback functions in response to user interactions and state changes.
• Form Input Controls - Defines the visual layout and behavior of native input widgets like text fields, date pickers, and sliders.
• Form Submission Management - Implements the mechanisms for submitting user input to servers via specified HTTP methods and target URLs.
• Interactive State Disablers - Defines how to prevent user interaction and exclude elements from the focus sequence.
• Structural Groupings - The HTML specification clusters a primary heading with related elements to treat them as a single unit.
• Document Layout Calculations - Establishes the fundamental algorithms for calculating document margins and viewport sizing.
• Image Embeddings - The HTML specification displays a graphic resource and provides alternative text for accessibility.
• Inline Content Containers - The HTML specification provides a generic inline container for grouping content to apply global attributes.
• Subtree Interaction Restrictions - Implements the ability to make an element and all its descendants inert to block interaction.
• Modal Dialogs - Implements transitory window components for user tasks, supporting both modal and non-modal behaviors.
• Table Layout Engines - Manages the structural layout and alignment of tabular data, including cell spanning and borders.
• Tabular Data Layouts - Organizes multi-dimensional data using a system of table elements, headers, and bodies.
• Text Selection Control - Controls the start, end, and direction of text selection and programmatic range replacement.
• User Interface Components - Provides the standard set of interactive controls and form elements for collecting user input.
• Autonomous Custom Elements - The HTML specification defines new HTML tags with independent classes and logic that function separately from existing built-in elements.
• Browser Navigation Utilities - Controls session history, manages browsing contexts, and coordinates transitions between web resources.
• Built-in Element Extensions - The HTML specification adds custom functionality and lifecycle hooks to existing HTML elements while preserving native behaviors and semantics.
• Content Type Identification - Assigns media types to resources so browsers can correctly process HTML, XML, JSON, and event streams.
• MIME Type Definitions - Defines the standard MIME types used to inform browsers how to parse and render different data formats.
• Custom Data Attributes - Allows the embedding of custom, non-visible information in elements via data attributes for use by site-specific scripts.
• Document Language Specifications - Specifies the primary language of the document to assist speech synthesis and translation tools.
• Document Lifecycle Management - Defines the process for aborting documents and removing them from the session history.
• Document Navigation - Defines how the browser loads new documents, handles HTTP POST requests, and executes JavaScript URLs.
• DOM Content Model Enforcement - Restricts the types of child elements allowed within a parent based on standardized content categories.
• DOM Content Modeling - Establishes how tags delimit content types, including the definitions of void and template elements.
• DOM Element Manipulators - Provides programmatic access to root HTML, head, and body elements for structure modification.
• DOM Serialization - Defines the process of converting a DOM element or document and its children back into a markup string.
• Dynamic Script Embedding - Includes JavaScript, import maps, and data blocks in a document with configurable execution timing and loading priority.
• Element Lifecycle Management - The HTML specification executes code when an element is connected, disconnected, moved, adopted, or has its attributes changed.
• Embedded Browsing Contexts - Specifies the rules for nesting external pages and HTML strings within a document, including security and permissions.
• URL Change Interceptors - Specifies how the browser changes the current location by setting new URLs or reloading the page.
• External Resource Loading - Integrates external content using specialized elements and controls for playback and loading.
• Form Data Support - Specifies how form data is encoded into byte sequences, including URL-encoded and multipart formats, for server transmission.
• HTML and XML Serialization - Provides specialized methods to parse and serialize HTML or XML strings using internal properties.
• Hyperlink Definitions - The HTML specification links to web pages, files, email addresses, or internal page locations using a specific URL.
• Hyperlink Implementations - The HTML specification links documents to other resources using anchor or area elements.
• List Item Definitions - The HTML specification represents an individual entry within an ordered list, unordered list, or menu.
• Main Content Identification - The HTML specification marks the dominant content of a document to distinguish it from repeated layout elements.
• Navigation Block Definitions - Defines semantic elements that identify major sections of a page containing primary navigation links.
• Navigation History Providers - Defines the core mechanics for managing the session history stack and traversing pages via history APIs.
• Nested Navigable Embedding - The HTML specification creates a nested navigable within a container element and links its history to the parent.
• Ordered Lists - Defines the structure and numbering logic for intentional sequences of content items.
• Page Structure Standards - Specifies a standardized set of elements and attributes to organize content and ensure consistent rendering across browsers.
• Paragraph Elements - Defines the structural representation of text as paragraphs to separate content blocks.
• Preformatted Text Rendering - Provides a way to display blocks of text exactly as written, preserving all whitespace and line breaks.
• Resource Preloading - Defines the standards for fetching high-priority assets immediately to optimize page loading performance.
• Script Execution Controls - Toggles the ability to run scripts based on user preferences, agent support, and security flags.
• Stylesheet Integration - Defines how external stylesheets are linked to control the visual presentation of a web page.
• User Interface Frameworks - Creating interactive controls, form elements, and layout components to collect user input and trigger actions.
• XML Fragment Parsing - Specifies how to convert XML markup strings into DOM nodes within a given context.
• XML Parsing - Defines the standard algorithms for mapping XML byte streams into document objects.
• Form-Associated Elements - Defines how elements are associated with forms to ensure data inclusion during submission.
• Pixel-Level Image Manipulation - Enables reading and writing raw pixel data for a rectangular area to perform image processing.
• Character Reference Mapping - Translates character reference names into Unicode code points to ensure consistent text rendering.
• Content Citations - Represents sections of content quoted from another source with an optional citation URL.
• Independent Compositions - The HTML specification marks self-contained compositions that are independently distributable or reusable.
• Lifecycle Events - The HTML specification fires an event and activates transitions when a document is first rendered or reactivated.
• Complex Data Serialization - Provides the structured clone algorithm to serialize complex objects for realm-independent storage and transfer.
• Content Type Detection - Identifies the type of a resource using sniffing heuristics to ensure consistent content handling.
• Local Storage Solutions - Manages client-side key-value storage using local and session storage APIs.
• XML Parsers - Defines the initialization of a document and its associated XML parser to render XML content.
• Numeric Range Constraints - Enforces minimum and maximum allowable values for numeric, date, and time input controls.
• XML Serialization - Provides the standard for converting DOM nodes into namespace-well-formed XML strings.
• Key-Value Stores - Provides mechanisms to save and retrieve simple string data associated with keys in persistent storage.
• Local Data Persistence - Ensures data remains available across sessions for a specific origin after a browser restart.
• Input Suggestions - Links text inputs to a list of predefined suggested values for user selection.
• Session Management - Implements standards for managing user-specific context and data throughout a page session.
• Date String Parsers - Implements ISO 8601 compliant parsing to convert date and time strings into structured timestamps.
• Tabular Data Formatters - Defines the visual formatting and structural representation of tabular data using rows and columns.
• Task Scheduling - Schedules the repeated execution of code snippets at fixed time intervals.
• URI Scheme Definitions - The HTML specification defines naming conventions for web-based URI schemes that allow applications to handle custom protocols.
• Worker Lifecycle Management - Defines how to stop worker execution environments and discard all pending tasks in their event loop.
• Proactive Cache Prefetching - Defines mechanisms for proactively fetching and caching documents to improve perceived navigation speed.
• Shape Drawing - Renders paths, curves, and rectangles onto a bitmap surface using fill and stroke styles.
• Vector Graphics Resources - Provides the standards for integrating scalable vector graphics as inline elements or external resources.
• Text Rendering - The HTML specification draws filled or outlined text strings at specific coordinates and calculates text metrics.
• Asynchronous Decoding Pipelines - Specifies how images can be decoded asynchronously to prevent blocking the main rendering thread.
• Responsive Images - Provides multiple image candidates to allow the browser to select the best resource for the current device.
• Timed Text Tracks - The HTML specification adds subtitles, captions, or chapter metadata via external files to enhance accessibility.
• Video Embeddings - Defines the mechanisms for embedding and playing video files with options for captions, autoplay, and looping.
• Render Blocking - Defines the conditions under which external resources block the initial rendering of the page.
• XML Namespace Management - Defines how elements are assigned to namespaces to ensure compatibility between HTML and XML.
• Navigation Interceptors - Establishes the standards for intercepting and canceling outgoing navigations via event handlers.
• Broadcast Messaging Channels - Allows broadcasting messages to all browsing contexts or workers sharing the same origin.
• Bidirectional Communication Pipes - The HTML specification creates a private, two-way pipe with connected ports that allow direct message exchange between execution contexts.
• Connection Reconnection Policies - Manages the automatic reconnection lifecycle for server-sent event streams after a network drop.
• Connection Prewarming - Implements origin preconnection to reduce latency by initiating TCP and TLS handshakes early.
• DNS Prefetching - Provides a standard for preemptive DNS resolution to accelerate the navigation process.
• Protocol Handlers - Defines the mechanism for associating websites with custom URL schemes to handle specific protocols.
• Real-Time Data Streams - Establishes long-lived HTTP connections to receive real-time data updates in a text event stream format.
• Real-time Event Streams - Implements a unidirectional stream of data from server to browser for real-time updates.
• Document Load Abortions - Provides a standard for cancelling ongoing fetch requests and parsers to stop the document loading process.
• Server-Sent Events - Processes server-sent messages by mapping specific event types to corresponding listener functions.
• Encoding Extraction - Implements rules for extracting character encoding from document meta elements to ensure correct text rendering.
• Global Scope Script Loading - Enables workers to fetch and execute external scripts synchronously within their global scope.
• Import Maps - Uses JSON maps to resolve module specifiers to specific URLs without requiring a build step.
• Numeric Parsers - Converts strings into signed integers or floating-point numbers using base-ten parsing algorithms.
• Markup Integrations - The HTML specification renders mathematical formulas using a specialized markup language integrated into the document.
• Execution Sandboxes - Provides a sandbox mechanism to restrict capabilities of embedded content, such as script execution.
• Agent Cluster Isolation - Organizes documents into clusters based on origin to ensure security isolation and resource efficiency.
• Browsing Context Relationship Controls - Forces the creation of new browsing contexts to restrict the relationship between pages for security.
• Character Escaping - Uses character references to escape characters that would otherwise be illegal or misinterpreted in HTML text.
• Cryptographic Nonce Assignments - Implements the assignment of unique tokens to elements to validate fetch requests via security policies.
• Same-Origin Policy Relaxation - Allows pages on different subdomains to access each other's DOMs by modifying the domain property.
• Security Context Definitions - Determines the security level of an environment based on the trust and scheme of its URL.
• Browser Context Managers - Manages whether a navigation maintains a link to the original window for security and context control.
• Policy-Based Access Control - Provides a policy framework to control access to disruptive browser capabilities like autoplay.
• Private Embedding Controls - Restricts whether a document can be loaded inside a child navigable using response headers.
• Referrer Header Management - Controls the level of detail sent in the Referer header during page transitions.
• Referrer Leakage Prevention - Prevents the leakage of referring URLs when following hyperlinks to maintain user privacy.
• Referrer Policies - Defines the policies that determine how much referrer information is sent with a request.
• Regex Input Validation - Defines the ability to validate form input values against a specified regular expression.
• Text Length Restrictions - Enforces minimum and maximum character limits on text inputs to ensure data meets length requirements.
• Vocabulary Mapping - The HTML specification categorizes semantic items by associating them with URLs that define the vocabulary used.
• Asynchronous Messaging - Provides the mechanism for processing incoming asynchronous data from WebSockets and server-sent events.
• Email Input Types - Specifies the email input type for capturing and validating email addresses according to global syntax.
• Global Scope Isolation - Provides isolated global environments for executing modules without polluting the main thread.
• Attribute Synchronization - Synchronizes interface properties with content attributes to ensure updates in one are reflected in the other.
• String Tokenization - Splits strings into collections of unique tokens separated by spaces or commas for attribute processing.
• Visual Progress Indicators - Visualizes task completion status using determinate ranges or indeterminate states.
• UI Page State Tracking - The HTML specification detects whether a page is visible or obscured to optimize resource usage.
• Network Connectivity Monitoring - The HTML specification tracks whether the agent is connected to a network and fires events on change.
• Semantic Metadata Extensions - Adds custom meanings and data to elements using attributes and metadata tags to ensure forward compatibility.
• Page Lifecycle Monitors - Provides the lifecycle monitoring system to detect when a page is shown, hidden, or restored from cache.
• Document Unloading Processes - Defines how documents transition to a hidden state and fire unload events.
• Action Trigger Components - Provides a generic button element for initiating custom application actions via scripts.
• State Update Schedulers - Coordinates function execution with the browser's native repaint cycle for smooth animations.
• Image Composition - The HTML specification draws external images onto a bitmap and controls how new shapes blend with existing content.
• Buttons - Defines the behavior and functionality of buttons used to submit forms to a server.
• Code Formatting Marks - Provides semantic elements to represent fragments of computer code as distinct from prose.
• Color Pickers - Implements a standardized color well interface for selecting colors and alpha transparency.
• Content Embedding Tools - Defines specialized interfaces for integrating audio, video, and scriptable graphics into web pages.
• Coordinate Transformation Utilities - Provides mechanisms for scaling, rotating, and translating the coordinate space for graphics rendering.
• Date and Time Pickers - Provides specialized UI controls for selecting both local date and time without time-zone offsets.
• Date Selection Components - Provides a native interactive control for selecting calendar dates and validating date strings.
• Delayed Event Scheduling - Implements temporal scheduling for triggering actions after a specific millisecond delay.
• Disclosure Components - Provides components for collapsible sections that hide content until a user interacts with a summary.
• Document Visibility Management - The HTML specification tracks whether a document is visible to the user via visibility properties.
• Drag and Drop Libraries - Manages the movement of data between source and target elements using a shared store.
• Automatic Focus Assignment - Provides the mechanism to automatically focus a specific element when a page loads.
• Footers - Defines a semantic area for metadata or copyright information for the nearest ancestor section.
• Form Handling - Provides logic and utilities for managing form control collections and specialized handling for radio button groups.
• Data Transfer Mechanisms - Stores and retrieves text or binary files during a drag operation.
• Interaction Modalities - Specifies how virtual keyboards adapt their layout based on the expected input modality and data type.
• Label and Control Association - Defines the mechanism for associating labels with form controls to enhance usability and accessibility.
• Autofill Suggestions - Provides the standard for suggesting and populating previously entered information into form fields based on their purpose.
• Checkbox Inputs - Provides the standard checkbox input for selecting binary or boolean states.
• Character Length Limits - Provides the mechanism to restrict the number of characters a user can enter into a text field.
• Implicit Submissions - Defines behavior where pressing the enter key in a valid text control automatically triggers form submission.
• Form Element Hierarchies - Defines the structural organization of related form fields into hierarchies using fieldsets and legends.
• Gauge Widgets - Represents measurements within a known range using defined low, high, and optimum marks.
• Globalization Preference Retrieval - Provides user-preferred language tags and triggers events when those globalization preferences change.
• Synthetic Event Bridges - Provides the mechanism to trigger synthetic click events to programmatically invoke element activation.
• Virtual Keyboard Layout Optimizations - Specifies the optimal virtual keyboard layout to display based on the expected input data type.
• Keyboard Shortcuts - Provides hints and standards for creating keyboard shortcuts to activate specific interface elements.
• DOM Mutation Lifecycles - Executes specific steps and logic when nodes are added to or removed from a document tree.
• Link Relationship Definitions - Annotates the relationship between the current document and a linked resource using descriptive keywords.
• Description Lists - Associates a set of names or terms with one or more descriptions or values.
• Alert Dialogs - Defines modal alerts and prompts that pause execution until the user provides a response.
• Document Title Management - Assigns a unique name to the document for use in browser interfaces and search engine results.
• Numeric Inputs - Provides UI components for entering floating-point numbers with optional range constraints.
• Password Input Fields - Implements text fields that obscure characters to protect sensitive password data.
• Plain Text Input Fields - Provides a standardized one-line edit control for entering plain text or search queries.
• Multiline Text Areas - Provides a plain text edit control for users to enter and edit large amounts of multi-line content.
• Popovers - Implements contextual overlays that are rendered on top of page content and triggered by user interaction.
• Light Dismiss Behaviors - Automatically closes active popovers when a user clicks outside the element boundaries.
• Print Stylesheets - Defines the specialized rendering requirements for physical paper and PDF output via print stylesheets.
• Progress Indicators - Renders visual measurements and task completion levels using consistent progress bar and gauge styles.
• Radio Button Groups - Implements groups of radio buttons to ensure only one option can be selected at a time.
• Range Sliders - Implements a slider interface for selecting numerical values within a defined range.
• Read-Only Access Controls - Implements read-only states for form controls to prevent user modification of displayed values.
• Scroll Restoration - Determines whether the browser automatically restores the scroll position during navigation.
• Input and Form State Restoration - Defines how browsers recover persisted form values and scroll positions during session navigation.
• Select Components - Displays single or multi-select interfaces as drop-down boxes or list boxes.
• Option Grouping - Implements the categorization of selection options into labeled groups to improve usability.
• Selection Components - Creates controls that allow users to select one or more options from a predefined list.
• Selection Controls - Provides a specialized selection control for choosing a specific month and year.
• Shadow DOM Slotting - Defines placeholders in a shadow tree that are populated by elements from the host element.
• Document Media Queries - Implements the evaluation of media queries to apply styles based on device dimensions and orientation.
• Thematic Break Elements - The HTML specification represents a paragraph-level thematic shift or a separator between options in a menu.
• Table Accessibility Associations - The HTML specification links specific cells to corresponding headers using scopes or IDs to improve accessibility navigation.
• Table Cell Definitions - The HTML specification creates data or header cells within a row and specifies column or row spans.
• Table Column Grouping - The HTML specification defines a set of columns to apply structural properties or styling across a span.
• Dynamic Markup Injection - Provides mechanisms for writing strings of markup directly into the document stream to replace or add content.
• Rich Text Editable Regions - Enables elements or entire documents to be edited directly by the user in rich text or plaintext modes.
• Textarea Components - Creates multiline text input areas that support automatic field sizing and text wrapping.
• Toolbar Components - Defines the structural and semantic representation of interactive command toolbars.
• Viewport Division Layouts - The HTML specification splits a window into multiple independent sections to load separate documents.
• Offscreen Rendering - Defines rendering contexts that allow graphics to be processed in background workers without direct document connection.
• Window Management - Provides the APIs for tracking window names, checking closure status, and stopping resource loading.
• Shared Workers - Provides the standard for creating shared background scripts that can be accessed across multiple windows or tabs.
• Context Isolation Managers - Organizes top-level browsing contexts to manage agent clusters and security isolation modes.
• Browsing Context Management - Defines the behavior for opening new windows and managing the relationship between different browsing contexts.
• Browsing Context Relationships - Specifies how to retrieve references to related windows, such as the parent navigable or the opener of a window.
• CSS Dimension Parsing - Extracts numerical values from markup and identifies them as percentages or lengths for layout calculation.
• Scoped Registries - Provides isolated registries to allow multiple libraries to define custom elements without naming conflicts.
• Document Mode Declarations - Includes a preamble that instructs the user agent to follow current specifications and avoid legacy rendering modes.
• Navigable Lifecycles - The HTML specification removes a child or top-level navigable and cleans up associated documents.
• DOM Content Updating - Implements logic for replacing an element's children or shell with new parsed markup.
• DOM Node Positioning - Allows for the parsing of markup strings and their insertion into the DOM at specific relative positions.
• Element Attributes - Defines the system for managing universal attributes that apply to all HTML elements for styling and accessibility.
• Command Attributes - Invokes specific actions on elements using command attributes to trigger behavior like closing dialogs.
• File Uploads - Provides the standard mechanism for selecting and uploading binary files via multipart form data.
• Fragment Navigation - The HTML specification updates the document URL to a specific fragment and scrolls to the corresponding element without reloading.
• Global Item Identifiers - The HTML specification assigns a unique absolute URL to a typed item to allow external referencing.
• HTML Templates - Defines snippets of markup that remain inactive until they are cloned and inserted into the document.
• Inter-Thread Communication - The HTML specification transmits cloned or transferred data between the main thread and background workers using a messaging port.
• Interactive Element Styling - Defines how styles are applied based on the dynamic state of an element, such as active or visited.
• Directional Layout Support - Defines how browsers handle directional layout support for right-to-left and left-to-right text rendering.
• Navigable Initialization - Defines the initialization process for new top-level windows, establishing their session history and root documents.
• Navigable Target Resolution - Provides the standard for how browsers resolve named targets for window and iframe navigations.
• Non-Reloading History Updates - Specifies how to modify the session history URL and state without refreshing the page.
• Page Load State Tracking - Provides mechanisms for monitoring the page-load lifecycle to trigger logic when content becomes interactive.
• Page Metadata Associations - Associates the document with an application manifest, an icon, or a preferred canonical URL.
• Deferred Loading - Implements standards for delaying the loading of media and iframes until they enter the viewport.
• Resource Fetch Priorities - Establishes how relative priority levels are assigned to resource requests to optimize download order.
• HTML Namespace Integration - Modifies XPath and XSLT behavior to correctly process HTML namespaces and case-sensitivity.
• Semantic Data Markup - The HTML specification creates groups of name-value pairs on elements to signal the start of a new entity.
• Semantic Item Properties - The HTML specification associates names or URLs with elements to create key-value pairs describing a semantic item.
• Speculation Rule Prerendering - Defines the Speculation Rules API to instruct browsers to prefetch or prerender future navigation targets.
• Speculative Resource Preloading - Implements the scanner that identifies and fetches external assets ahead of the main HTML parser.
• Enumerated Attribute Parsing - Maps attribute values to specific states using standardized keywords and default values.
• Unordered Lists - The HTML specification creates a list of items where the order does not affect the meaning of the document.
• Custom Elements - Defines the standard for creating new element types with specific constructor behaviors and registry associations.

Star-Verlauf