HTML Dependencies

Various specifications it references and the significance of the dependencies.

Dependencies on Infra

The Infra specification provides fundamental definitions and concepts used throughout the WHATWG HTML specification. These include terms related to iteration, assertion, character encoding, and data structures, among others. Some key dependencies on Infra include:

• General iteration terms: "while," "continue," and "break" are used to control program flow within the specification.
• String operations: Terms like "starts with," "ends with," "length," and "code point length" are crucial for processing and manipulating strings in web content.
• Data structures: The specification relies on data structures such as ordered maps, lists, stacks, queues, and sets for organizing and managing data.
• Byte sequence: The byte sequence data structure is used to handle binary data efficiently.
• Forgiving-base64: These algorithms are used for encoding and decoding base64 data, which is common in web applications.

Dependencies on Unicode and Encoding

The Unicode character set and the Encoding specification are integral to handling textual data in the WHATWG HTML specification. Key dependencies on Unicode and Encoding include:

• Character encodings: The specification relies on encoding definitions for interpreting character data, especially for dealing with non-ASCII characters.
• Decode algorithms: Algorithms like UTF-8 decode are used to convert byte streams into character streams while handling UTF-8 Byte Order Marks (BOM).
• Encode algorithms: Encoding algorithms, including UTF-8 encode, are used for the reverse process, converting character streams into byte streams.
• BOM sniff algorithm: This algorithm helps detect character encoding from a given byte stream.

Dependencies on XML and Related Specifications

The specification references XML and its related specifications to ensure compatibility with XML-based content. Key dependencies on XML include:

• XML syntax support: Implementations supporting the XML syntax for HTML must adhere to XML and its corresponding namespaces specification.
• XML namespace: This is essential for handling namespaces in the HTML syntax, although namespace prefixes do not have the same significance as in XML.
• Attributes: Certain attributes are defined by the Extensible Markup Language (XML).
• Processing instructions: The specification refers to the <?xml-stylesheet?> processing instruction used in associating style sheets with XML documents.

Dependencies on URLs

The WHATWG HTML specification deals extensively with URLs, including their parsing, serialization, and various components. Key dependencies on URLs include:

• URL components: The specification defines various components of a URL, such as scheme, username, password, host, port, path, query, and fragment.
• URL parser: Algorithms for parsing and handling URLs, including their components, are essential for web content processing.
• URL schemes: The specification references a variety of URL schemes, including HTTP, HTTPS, mailto, data, and more.

Dependencies on HTTP and Related Specifications

The HTTP and related specifications play a significant role in defining how web content interacts with servers and networks. Key dependencies on HTTP include:

• HTTP headers: The specification references numerous HTTP headers, including Accept, Cache-Control, Content-Disposition, and others.
• Cookies: Definitions related to cookies, such as the Cookie header and related terms, are crucial for session management and state retention.
• Link header: The Link header is used for establishing relationships between resources in web content.
• MIME types: The specification relies on MIME types to determine how to handle various resources, such as HTML, JavaScript, JSON, and more.
• Fetch API: The Fetch specification is referenced for making network requests, handling response data, and other related tasks.

JavaScript

JavaScript is a fundamental component of web development, and many aspects of the WHATWG HTML specification depend on it. While the official term for the language is ECMAScript, the specification primarily uses "JavaScript" due to its widespread recognition. The specification incorporates various JavaScript terms and concepts, including:

• Active Function Object: This term is crucial for understanding how functions operate within JavaScript and plays a key role in the execution of web pages.
• Agent and Agent Cluster: Agents are used to model the execution environment for JavaScript code. Agent clusters provide a structured way to manage and coordinate multiple agents.
• Automatic Semicolon Insertion: This feature helps interpret and execute JavaScript code by inserting semicolons where they are missing to ensure valid syntax.
• Candidate Execution: Refers to the evaluation of certain code constructs to determine if they should be executed or not.
• The Current Realm: Understanding the realm is important when managing execution contexts and global objects in JavaScript.
• Early Error: This concept deals with identifying and handling errors in JavaScript code at an early stage.
• JavaScript Execution Context: The execution context is crucial for managing code execution, including variable scopes and function calls.
• Well-Known Symbols and Intrinsic Objects: These include special symbols and objects used in various JavaScript operations and features.
• Functions and Modules: Different types of functions and modules are defined in the JavaScript specification, which HTML leverages for web development.
• Abstract Operations: Various abstract operations are specified for common tasks, such as array creation, object property handling, and more.
• Host Operations: These operations connect JavaScript to the host environment, enabling interactions with the browser and the web page.
• Web APIs: JavaScript interacts with web APIs to enable features like manipulating the DOM, making HTTP requests, and more.

ECMAScript Internationalization API

User agents supporting JavaScript are also required to implement the ECMAScript Internationalization API. This API facilitates internationalization and localization in web applications, enabling developers to work with different languages, regions, and cultural conventions seamlessly.

Import Attributes Proposal

The Import Attributes proposal is another vital component, with terms defined in this specification and used within WHATWG HTML. It adds flexibility to module imports, allowing for more granular control over how modules are loaded and executed, enhancing the efficiency and security of web applications.

JSON Modules Proposal

JavaScript support must include the JSON modules proposal, which defines terms and concepts related to importing and working with JSON data as modules. This feature simplifies data management and retrieval in web applications, ensuring consistent and predictable behavior when dealing with JSON.

Resizable ArrayBuffer and Growable SharedArrayBuffer Proposal

This proposal introduces support for resizable ArrayBuffer and growable SharedArrayBuffer, offering greater flexibility for working with binary data in web applications. These features enhance the performance and memory management of web applications that require low-level data manipulation.

WebAssembly

WebAssembly is a binary instruction format that enables high-performance execution of code on web browsers. The WHATWG HTML specification incorporates the WebAssembly Module term, which is essential for integrating WebAssembly with web applications and ensuring efficient execution of code.

Document Object Model (DOM)

The DOM is a critical part of web development, as it provides a structured representation of a document's content. The specification defines numerous features related to the DOM, including interfaces, methods, and concepts. Some key components of the DOM include:

• Element Interfaces: These interfaces define how web elements are represented in the DOM, enabling manipulation of the web page's structure and content.
• Event Handling: The specification defines various events and their associated behaviors, such as click events, keypress events, and more. This ensures that user interactions with web pages are captured and processed.
• Shadow DOM: The shadow DOM introduces encapsulation and scoping for web components, enabling developers to create isolated and reusable components within a web page.
• HTMLCollection and DOMTokenList: These interfaces facilitate efficient manipulation of HTML collections and token lists within the DOM.
• Custom Elements: The specification supports the creation and management of custom elements, allowing developers to extend the capabilities of HTML and create their own reusable components.
• Mutation Observers: These provide a mechanism to observe and react to changes in the DOM, ensuring dynamic web applications can respond to user actions and external events.
• High-Resolution Time: This feature provides accurate time measurements, crucial for animations, scheduling, and other time-sensitive web tasks.

File API

The File API specification is instrumental in HTML's support for file-related operations. It provides a set of interfaces and concepts used in HTML, including:

• Blob interface: Represents raw data and includes attributes like type.
• File interface: Represents a file with attributes such as name and lastModified.
• FileList interface: Represents a list of files.
• Blob's snapshot state: A concept related to Blob objects.
• Read errors: Defines how errors during file reading are handled.
• Blob URL Store: This includes blob URL entries and their related objects and environments.

These components are essential for handling files and interacting with user-uploaded content, which is a common requirement for web applications.

Indexed Database API

HTML relies on the Indexed Database API to handle Indexed Database transactions efficiently. This API facilitates the management of data in indexed databases and provides the necessary methods and structures for working with them.

Media Source Extensions

The Media Source Extensions specification is crucial for multimedia content on the web. It defines terms like MediaSource interface and provides guidelines for detaching from a media element. This enables HTML to offer video and audio playback, streaming, and synchronization.

Media Capture and Streams

For multimedia input, HTML depends on the Media Capture and Streams specification. It introduces the MediaStream interface, which is integral for accessing and managing audio and video streams. It enables features like video conferencing and real-time communication on the web.

Reporting

The Reporting specification introduces the ability to queue reports, specify report types, and make information visible to ReportingObservers. This supports various analytics and monitoring features on web platforms.

XMLHttpRequest

XMLHttpRequest is an essential component for making asynchronous requests to web servers. HTML relies on the XMLHttpRequest interface, ProgressEvent interface, and FormData interface, which allow web applications to fetch data and interact with servers without reloading the entire page.

Battery Status API

The Battery Status API is employed for obtaining information about the user's device battery. The getBattery() method provides access to this information, which can be useful for optimizing the user experience based on device battery conditions.

Media Queries

HTML specifications require support for Media Queries. This allows web developers to create responsive designs by specifying how content should be displayed under different conditions, such as screen size and device orientation.

CSS Modules

While not strictly a dependency, HTML references CSS modules for specific styling requirements. It mandates adherence to CSS grammars, including error handling rules, and extends the core CSS properties to enable consistent rendering of web content.

Intersection Observer

Intersection Observer is a critical web API that allows developers to track elements' visibility and position within the viewport. The WHATWG HTML specification depends on the following terms defined in Intersection Observer:

• `run the update intersection observations steps`
• `IntersectionObserver`
• `IntersectionObserverInit`
• `observe`
• `unobserve`
• `isIntersecting`
• `target`

Resize Observer

Resize Observer is another important web API that enables tracking changes in the size of DOM elements. The WHATWG HTML specification relies on terms defined in Resize Observer, such as:

• `gather active resize observations at depth`
• `has active resize observations`
• `has skipped resize observations`
• `broadcast active resize observations`
• `deliver resize loop error`

WebGL

WebGL is a JavaScript API for rendering 3D graphics within web browsers. The WHATWG HTML specification relies on the following interfaces defined in WebGL specifications:

• `WebGLRenderingContext interface`
• `WebGL2RenderingContext interface`
• `WebGLContextAttributes dictionary`

WebGPU

WebGPU is a web API for GPU acceleration and parallel computing. The WHATWG HTML specification depends on the following interfaces defined in WebGPU:

• `GPUCanvasContext interface`

WebVTT (Web Video Text Tracks)

WebVTT is a format used for displaying subtitles, captions, and metadata in media resources. The WHATWG HTML specification relies on several terms defined in WebVTT, including:

• `WebVTT file`
• `WebVTT file using cue text`
• `WebVTT file using only nested cues`
• `WebVTT parser`
• `VTTCue interface`

 ARIA (Accessible Rich Internet Applications)

The Accessibility Rich Internet Applications (ARIA) specification defines roles and attributes that help make web content more accessible. The WHATWG HTML specification relies on ARIA for several roles and attributes, including:

• `role`
• `accessible name`

Content Security Policy (CSP)

Content Security Policy is a security feature that helps prevent cross-site scripting (XSS) attacks. The WHATWG HTML specification depends on various terms defined in CSP, such as:

• `Content Security Policy`
• `directive set`
• `CSP list`
• `enforce the policy`
• `The report-uri directive`

Service Workers

Service Workers are scripts that run in the background and can intercept and handle network requests. The WHATWG HTML specification relies on terms defined in Service Workers, including:

• `service worker`
• `ServiceWorker interface`
• `ServiceWorkerContainer interface`
• `ServiceWorkerGlobalScope interface`

Secure Contexts

The WHATWG HTML specification depends on algorithms defined in Secure Contexts for determining whether a URL is potentially trustworthy.

Permissions Policy

The Permissions Policy specification is essential for controlling access to certain features and APIs. The WHATWG HTML specification relies on terms such as:

• `permissions policy`
•  `policy-controlled feature`

Payment Request API

The Payment Request API is used for handling online payments. The WHATWG HTML specification relies on the `PaymentRequest interface` defined in this specification.

MathML (Mathematical Markup Language)

While not required, support for MathML is encouraged, especially for web browsers. The WHATWG HTML specification relies on specific MathML elements and attributes, including `MathML annotation-xml element` and others.

SVG (Scalable Vector Graphics)

The WHATWG HTML specification encourages support for SVG. It relies on certain features defined in the SVG 2 specification, including interfaces and elements.